Chapter 5 Core Java APIs Notes

Question 1

+ operator rules:

Answer 1

1. If both operands are numeric, + means numeric addition.
2. If either operand is a String, + means concatenation.
3. The expression is evaluated left to right.

Question 2

IMPORTANT STRING METHODS

Answer 2

1. int length()
   returns the number of characters in the String.
2. char charAt(int index)
   query the string to find out what character is at a specific index.
3. int indexOf(int ch)
int indexOf(int ch, int fromIndex)
int indexOf(String str)
int indexOf(String str, int fromIndex)
   looks at the characters in the string and finds the first index that matches the desired value.
   Remember that a char can be passed to an int parameter type.
   indexOf() returns –1 when no match is found.
4. String substring(int beginIndex)
String substring(int beginIndex, int endIndex)
   It returns parts of the string.
5. String toLowerCase()
String toUpperCase()
6. boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
equals() takes an Object rather than a String. This is because the method is the same for all objects. If you pass in something that isn’t a String, it will just return false.
7. boolean startsWith(String prefix)
boolean endsWith(String suffix)
8. String replace(char oldChar, char newChar)
String replace(CharSequence target, CharSequence replacement)
   does a simple search and replace on the string.
9. boolean contains(CharSequence charSeq)
   looks for matches in the String.
10. String strip()
String stripLeading()
String stripTrailing()
String trim()
    The strip() method is new in Java 11. It does everything that
    trim() does, but it supports Unicode.
11. String intern()
    returns the value from the string pool if it is there. Otherwise, it adds the value to the string pool.

Question 3

String string = "animals";
System.out.println(string.charAt(0)); // a
System.out.println(string.charAt(6)); // s
System.out.println(string.charAt(7)); // throws exception

Question 4

String string = "animals";
System.out.println(string.indexOf('a')); // 0
System.out.println(string.indexOf("al")); // 4
System.out.println(string.indexOf('a', 4)); // 4
System.out.println(string.indexOf("al", 5)); // -1

Question 5

String string = "animals";
System.out.println(string.substring(3)); // mals
System.out.println(string.substring(string.indexOf('m'))); // mals
System.out.println(string.substring(3, 4)); // m
System.out.println(string.substring(3, 7)); // mals

System.out.println(string.substring(3, 3)); // empty string
System.out.println(string.substring(3, 2)); // throws exception
System.out.println(string.substring(3, 8)); // throws exception

Question 6

System.out.println("abc".strip()); // abc
System.out.println("\t a b c\n".strip()); // a b c
String text = " abc\t ";
System.out.println(text.trim().length()); // 3
System.out.println(text.strip().length()); // 3
System.out.println(text.stripLeading().length()); // 4
System.out.println(text.stripTrailing().length());// 4

Answer 6

First, remember that \t is a single character. The backslash escapes the t to represent a tab.

Question 7

> [!Note:]
You don’t need to know about Unicode for the exam. But if you want to test the difference, one of Unicode whitespace characters is as follows:
Unicode whitespace characters is as follows:

char ch = '\u2000';

Question 8

10: String alpha = "";
11: for(char current = 'a'; current <= 'z'; current++)
12:     alpha += current;
13: System.out.println(alpha);

15: StringBuilder alpha = new StringBuilder();
16: for(char current = 'a'; current <= 'z'; current++)
17:     alpha.append(current);
18: System.out.println(alpha);

Answer 8

abcdefghijklmnopqrstuvwxyz

Question 9

4: StringBuilder sb = new StringBuilder("start");
5: sb.append("+middle"); // sb = "start+middle"
6: StringBuilder same = sb.append("+end"); // "start+middle+end"

Question 10

4: StringBuilder a = new StringBuilder("abc");
5: StringBuilder b = a.append("de");
6: b = b.append("f").append("g");
7: System.out.println("a=" + a);
8: System.out.println("b=" + b);

Answer 10

printed:

a=abcdefg
b=abcdefg

Question 11

There are three ways to construct a StringBuilder:

Answer 11

StringBuilder sb1 = new StringBuilder();
StringBuilder sb2 = new StringBuilder("animal");
StringBuilder sb3 = new StringBuilder(10);

• The first says to create a StringBuilder containing an empty sequence of characters and assign sb1 to point to it.
• The second says to create a StringBuilder containing a specific value and assign sb2 to point to it.
• For the first two, it tells Java to manage the implementation details.
• The final example tells Java that we have some idea of how big the eventual value will be and would like the StringBuilder to reserve a certain capacity, or number of slots, for characters.

Question 12

IMPORTANT STRINGBUILDER METHODS

Answer 12

1. charAt(), work exactly the same as in the String class.
2. indexOf(), work exactly the same as in the String class.
3. length(), work exactly the same as in the String class.
4. substring(), work exactly the same as in the String class.
5. StringBuilder append(String str)
   It adds the parameter to the StringBuilder and returns a reference to the current StringBuilder.
6. StringBuilder insert(int offset, String str)
   adds characters to the StringBuilder at the requested index and returns a reference to the current StringBuilder.
7. StringBuilder delete(int startIndex, int endIndex)
StringBuilder deleteCharAt(int index)
8. StringBuilder replace(int startIndex, int endIndex, String newString)
9. StringBuilder reverse()
10. String toString()

Question 13

3: StringBuilder sb = new StringBuilder("animals");
4: sb.insert(7, "-"); // sb = animals-
5: sb.insert(0, "-"); // sb = -animals-
6: sb.insert(4, "-"); // sb = -ani-mals-
7: System.out.println(sb);

jshell> StringBuilder sb = new StringBuilder("animals");
jshell> sb.insert(8, "-");
|  Exception java.lang.StringIndexOutOfBoundsException: offset 8, length 7
|        at String.checkOffset (String.java:4576)
|        at AbstractStringBuilder.insert (AbstractStringBuilder.java:1170)
|        at StringBuilder.insert (StringBuilder.java:336)
|        at (#11:1)

Question 14

StringBuilder sb = new StringBuilder("abcdef");
sb.delete(1, 3); // sb = adef
sb.deleteCharAt(5); // throws an exception

StringBuilder sb = new StringBuilder("abcdef");
sb.delete(1, 100); // sb = a

Question 15

StringBuilder builder = new StringBuilder("pigeon dirty");
builder.replace(3, 6, "sty");
System.out.println(builder); // pigsty dirty

Question 16

StringBuilder builder = new StringBuilder("pigeon dirty");
builder.replace(3, 100, "");
System.out.println(builder);

Answer 16

prints:
pig

Question 17

StringBuilder did not implement equals().
You can call toString() on StringBuilder to get a String to check for equality instead.

Question 18

THE STRING POOL

Answer 18

The string pool, also known as the intern pool, is a location in the Java virtual machine (JVM) that collects all these strings.

Question 19

String x = "Hello World";
String y = "Hello World";
System.out.println(x == y); // true

Question 20

String x = "Hello World";
String z = " Hello World".trim();
System.out.println(x == z); // false

Answer 20

Since it isn’t the same at compile-time, a new String object is created.

Question 21

String singleString = "hello world";
String concat = "hello ";
concat += "world";
System.out.println(singleString == concat);

Answer 21

This prints false. Concatenation is just like calling a method and results in a new String.

Question 22

String x = "Hello World";
String y = new String("Hello World"); //create a new String 
System.out.println(x == y); // false

Question 23

String name = "Hello World";
String name2 = new String("Hello World").intern();
System.out.println(name == name2); // true

Answer 23

• First we tell Java to use the string pool normally for name.
• Then for name2, we tell Java to create a new object using the constructor but to intern it and use the string pool anyway.
• Since both variables point to the same reference in the string pool, we can use the == operator.

Question 24

15: String first = "rat" + 1;
16: String second = "r" + "a" + "t" + "1";
17: String third = "r" + "a" + "t" + new String("1");
18: System.out.println(first == second); // true
19: System.out.println(first == second.intern()); // true
20: System.out.println(first == third); // false
21: System.out.println(first == third.intern()); // true

Answer 24

• On line 15, we have a compile-time constant that automatically gets placed in the string pool as “rat1”.
• On line 16, we have a more complicated expression that is also a compile-time constant.
• Therefore, first and second share the same string pool reference. This makes line 18 and 19 print true.
• On line 17, we have a String constructor. This means we no longer have a compile-time constant, and third does not point to a reference in the string pool.
• Therefore, line 20 prints false.
• On line 21, the intern() call looks in the string pool. Java notices that first points to the same String and prints true.

Question 25

> [!Note:] > Remember to never use **intern()** or **==** to compare String objects in your code. The only time you should have to deal with these is on the exam.

Question 26

**The basic structure of an array**

Answer 26

``` int[] numbers = new int[3]; ``` 1. Type of array 2. Array symbol (required) 3. Size of array ``` int[] numbers2 = new int[] {42, 55, 99}; int[] numbers2 = {42, 55, 99}; // anonymous array int[] ids, types; // create 2 int array int ids[], types; // ids is a int array, types is a int // following do the exact same thing int[] numAnimals; int [] numAnimals2; int []numAnimals3; int numAnimals4[]; int numAnimals5 []; ```

Question 27

> [!Note:] > Since Java 5, Java has provided a method that prints an array nicely: > `Arrays.toString(bugs)` would print `[cricket, beetle, ladybug]`.

Question 28

``` 3: String[] strings = { "stringValue" }; 4: Object[] objects = strings; 5: String[] againStrings = (String[]) objects; 6: againStrings[0] = new StringBuilder(); // DOES NOT COMPILE 7: objects[0] = new StringBuilder(); // careful! ```

Answer 28

* Line 3 creates an array of type String. * Line 4 doesn’t require a cast because Object is a broader type than String. * On line 5, a cast is needed because we are moving to a more specific type. * Line 6 doesn’t compile because a String[] only allows String objects and StringBuilder is not a String. * Line 7 is where this gets interesting. From the point of view of the compiler, this is just fine. A StringBuilder object can clearly go in an Object[]. The problem is that we don’t actually have an Object[]. We have a String[] referred to from an Object[] variable. At runtime, the code throws an ArrayStoreException. You don’t need to memorize the name of this exception, but you do need to know that the code will throw an exception.

Question 29

**ARRAY SORTING**

Answer 29

**of the following two statements in your class:** ``` import java.util.*; // import whole package including Arrays import java.util.Arrays; // import just Arrays ``` ``` int[] numbers = { 6, 9, 1 }; Arrays.sort(numbers); for (int i = 0; i < numbers.length; i++) System.out.print(numbers[i] + " "); ``` print: `1 6 9` ``` String[] strings = { "10", "9", "100" }; Arrays.sort(strings); for (String string : strings) System.out.print(string + " "); ``` This code outputs: `10 100 9`

Question 30

**ARRAY SEARCHING**

Answer 30

Java also provides a convenient way to search—but only if the array is already sorted. Binary search rules: 1. Target element found in sorted array, return Index of match 2. Target element not found in sorted array, return Negative value showing one smaller than the negative of the index, where a match needs to be inserted to preserve sorted order 3. Unsorted array, will return A surprise—this result isn’t predictable example:

Question 31

**Arrays.binarySearch() examples:** ``` 3: int[] numbers = {2,4,6,8}; 4: System.out.println(Arrays.binarySearch(numbers, 2)); // 0 5: System.out.println(Arrays.binarySearch(numbers, 4)); // 1 6: System.out.println(Arrays.binarySearch(numbers, 1)); // -1 7: System.out.println(Arrays.binarySearch(numbers, 3)); // -2 8: System.out.println(Arrays.binarySearch(numbers, 9)); // -5 ```

Answer 31

* line 3 is a sorted array. * Line 4 searches for the index of 2. The answer is index 0. * Line 5 searches for the index of 4, which is 1. * Line 6 searches for the index of 1. Although 1 isn’t in the list, the search can determine that it should be inserted at element 0 to preserve the sorted order. Since 0 already means something for array indexes, Java needs to subtract 1 to give us the answer of –1. * Line 7 is similar. Although 3 isn’t in the list, it would need to be inserted at element 1 to preserve the sorted order. We negate and subtract 1 for consistency, getting –1 –1, also known as –2. * Finally, line 8 wants to tell us that 9 should be inserted at index 4. We again negate and subtract 1, getting –4 –1, also known as –5.

Question 32

``` 5: int[] numbers = new int[] {3,2,1}; 6: System.out.println(Arrays.binarySearch(numbers, 2)); 7: System.out.println(Arrays.binarySearch(numbers, 3)); ```

Answer 32

The exam creators will not expect you to know what incorrect values come out. As soon as you see the array isn’t sorted, look for an answer choice about unpredictable output.

Question 33

**ARRAY COMPARING**

Answer 33

``` compare() mismatch() ```

Question 34

**compare()**

Answer 34

**compare() return:** 1. A **negative** number means the **first array is smaller** than the second. 1. A **zero** means the arrays are **equal**. 1. A **positive** number means the **first array is larger** than the second. **how to compare arrays of different lengths:** 1. If both arrays are the **same length** and have **the same** values in each spot in the same order, **return zero**. 1. If all the elements are the same but the **second array has extra elements at the end, return a negative number.** 1. If all the elements are the same but the **first array has extra elements at the end, return a positive number.** 1. If the **first element that differs is smaller in the first array, return a negative number.** 1. If the **first element that differs is larger in the first array, return a positive number.** **rules that apply here and to compareTo()** 1. **null is smaller than any other value.** 1. For numbers, **normal numeric order applies.** 1. For strings, one is smaller if it is a prefix of another. 1. For strings/characters, **numbers are smaller than letters.** 1. For strings/characters, **uppercase is smaller than lowercase.**

Question 35

``` jshell> Arrays.compare(new int[]{1, 2}, new int[] {1}) $1 ==> 1 jshell> Arrays.compare(new int[]{1, 2}, new int[] {1, 2}) $2 ==> 0 jshell> Arrays.compare(new String[] {"a"}, new String[] {"aa"}) $3 ==> -1 jshell> Arrays.compare(new String[] {"a"}, new String[] {"A"}) $4 ==> 32 jshell> Arrays.compare(new String[] {"a"}, new String[] {null}) $5 ==> 1 System.out.println(Arrays.compare(new int[] {1}, new String[] {"a"})); // DOES NOT COMPILE ```

Answer 35

1. The first element is the same, but the first array is longer. 2. Exact match 3. The first element is a substring of the second. 4. **Uppercase is smaller than lowercase.** 5. **null is smaller than a letter.**

Question 36

**mismatch()**

Answer 36

If the arrays are equal, `mismatch()` **returns -1**. Otherwise, it returns the **first index where they differ.**

Question 37

``` System.out.println(Arrays.mismatch(new int[] {1}, new int[] {1})); System.out.println(Arrays.mismatch(new String[] {"a"}, new String[] {"A"})); System.out.println(Arrays.mismatch(new int[] {1, 2}, new int[] {1})); ```

Answer 37

* In the first example, the arrays are the same, so the result is **-1**. * In the second example, the entries at element 0 are not equal, so the result is **0**. * In the third example, the entries at element 0 are equal, so we keep looking. The element at index 1 is not equal. Or more specifically, one array has an element at index 1, and the other does not. Therefore, the result is **1**.

Question 38

**Equality vs. comparison vs. mismatch**

Answer 38

1. `equals() ` When arrays are the same return **true**, else return **false** 2. `compare()` When arrays are the same return **0**, else return **positive or negative number** 3. `mismatch()` When arrays are the same return **-1**, else **zero or positive index**

Question 39

**VARARGS**

Answer 39

**variable arguments** ex: ``` public static void main(String... args) // varargs ```

Question 40

**MULTIDIMENSIONAL ARRAYS**

Answer 40

**arrays can hold other arrays** **Creating a Multidimensional Array** ``` int[][] vars1; // 2D array int vars2 [][]; // 2D array int[] vars3[]; // 2D array int[] vars4 [], space [][]; // a 2D AND a 3D array String [][] rectangle = new String[3][2]; int[][] differentSizes = {{1, 4}, {3}, {9,8,7}}; int [][] args = new int[4][]; args[0] = new int[5]; args[1] = new int[3]; ```

Question 41

**Understanding an ArrayList**

Answer 41

**ArrayList can change capacity at runtime as needed**. Like an array, an ArrayList is an **ordered sequence that allows duplicates.** you must have either of the following two statements in your class: ``` import java.util.*; // import whole package import java.util.ArrayList; // import just ArrayList ``` **CREATING AN ARRAYLIST** ``` ArrayList list1 = new ArrayList(); ArrayList list2 = new ArrayList(10); ArrayList list3 = new ArrayList(list2); ArrayList list4 = new ArrayList(); //Generics ArrayList list5 = new ArrayList<>(); List list6 = new ArrayList<>(); ArrayList list7 = new List<>(); // DOES NOT COMPILE List is an interface and interfaces can’t be instantiated. ```

Question 42

**ArrayList methods:**

Answer 42

1. **`boolean add(E element)`** **`void add(int index, E element)`** **insert a new value in the ArrayList.** **It always returns true**. 2. `boolean remove(Object object)` `E remove(int index)` remove the first matching value in the ArrayList or remove the element at a specified index. This time the boolean return value tells us whether a match was removed. The E return type is the element that actually got removed. 3. `E set(int index, E newElement)` changes one of the elements of the ArrayList without changing the size. The E return type is the element that got replaced. 4. `boolean isEmpty()` `int size()` 5. `void clear()` 6. `boolean contains(Object object)` 7. `boolean equals(Object object)`

Question 43

``` ArrayList list = new ArrayList(); list.add("hawk"); // [hawk] list.add(Boolean.TRUE); // [hawk, true] System.out.println(list); // [hawk, true] ArrayList safer = new ArrayList<>(); safer.add("sparrow"); safer.add(Boolean.TRUE); // DOES NOT COMPILE 4: List birds = new ArrayList<>(); 5: birds.add("hawk"); // [hawk] 6: birds.add(1, "robin"); // [hawk, robin] 7: birds.add(0, "blue jay"); // [blue jay, hawk, robin] 8: birds.add(1, "cardinal"); // [blue jay, cardinal, hawk, robin] 9: System.out.println(birds); // [blue jay, cardinal, hawk, robin] ```

Question 44

Since calling remove() with an int uses the index, an index that doesn’t exist will throw an exception. For example, birds.remove(100) throws an IndexOutOfBoundsException.

Question 45

``` 15: List birds = new ArrayList<>(); 16: birds.add("hawk"); // [hawk] 17: System.out.println(birds.size()); // 1 18: birds.set(0, "robin"); // [robin] 19: System.out.println(birds.size()); // 1 20: birds.set(1, "robin"); // IndexOutOfBoundsException ```

Question 46

**WRAPPER CLASSES**

Answer 46

1. Primitive type: **boolean** Wrapper class: **Boolean** Ex: `Boolean.valueOf(true)` 2. Primitive type: **byte** Wrapper class: **Byte** Ex: `Byte.valueOf((byte) 1)` 3. Primitive type: **short** Wrapper class: **Short** Ex: `Short.valueOf((short) 1)` 4. Primitive type: **int** Wrapper class: **Integer** Ex: `Integer.valueOf(1)` 5. Primitive type: **long** Wrapper class: **Long** Ex: `Long.valueOf(1)` 6. Primitive type: **float** Wrapper class: **Float** Ex: `Float.valueOf((float) 1.0)` 7. Primitive type: **double** Wrapper class: **Double** Ex: `Double.valueOf(1.0)` 8. Primitive type: **char** Wrapper class: **Character** Ex: `Character.valueOf('c')`

Question 47

``` int primitive = Integer.parseInt("123"); Integer wrapper = Integer.valueOf("123"); int bad1 = Integer.parseInt("a"); // throws NumberFormatException Integer bad2 = Integer.valueOf("123.45"); // throws NumberFormatException ```

Question 48

Converting String to a primitive Converting String to a wrapper class

Answer 48

**1. Boolean** ``` Boolean.parseBoolean("true") // Converting String to a primitive Boolean.valueOf("TRUE") // Converting String to a wrapper class ``` **2. Byte** ``` Byte.parseByte("1") Byte.valueOf("2") ``` **3. Short** ``` Short.parseShort("1") Short.valueOf("2") ``` **4. Integer** ``` Integer.parseInt("1") Integer.valueOf("2") ``` **5. Long** ``` Long.parseLong("1") Long.valueOf("2") ``` **6. Float** ``` Float.parseFloat("1") Float.valueOf("2.2") ``` **7. Double** ``` Double.parseDouble("1") Double.valueOf("2.2") ``` **8. Character** ``` None None ```

Question 49

One advantage of a wrapper class over a primitive is that because it’s an object, it can be used to store a null value. While null values aren’t particularly useful for numeric calculations, they are quite useful in data-based services. For example, if you are storing a user’s location data using (latitude,longitude), it would be a bad idea to store a missing point as (0,0) since that refers to an actual location off the coast of Africa where the user could theoretically be.

Question 50

**AUTOBOXING AND UNBOXING**

Answer 50

Since Java 5, you can just type the primitive value, and Java will convert it to the relevant wrapper class for you. This is called autoboxing. The reverse conversion of wrapper class to primitive value is called unboxing. ``` 3: List weights = new ArrayList<>(); 4: Integer w = 50; 5: weights.add(w); // [50] 6: weights.add(Integer.valueOf(60)); // [50, 60] 7: weights.remove(new Integer(50)); // [60] 8: double first = weights.get(0); // 60.0 ``` ``` 3: List heights = new ArrayList<>(); 4: heights.add(null); 5: int h = heights.get(0); // NullPointerException ``` ``` List numbers = new ArrayList<>(); numbers.add(1); numbers.add(2); numbers.remove(1); System.out.println(numbers); ```

Question 51

**turning an ArrayList into an array:** ``` 13: List list = new ArrayList<>(); 14: list.add("hawk"); 15: list.add("robin"); 16: Object[] objectArray = list.toArray(); 17: String[] stringArray = list.toArray(new String[0]); 18: list.clear(); 19: System.out.println(objectArray.length); // 2 20: System.out.println(stringArray.length); // 2 ```

Answer 51

* Line 16 shows that an ArrayList knows how to convert itself to an array. The only problem is that it defaults to an array of class Object. This isn’t usually what you want. * Line 17 specifies the type of the array and does what we actually want. The advantage of specifying a size of 0 for the parameter is that Java will create a new array of the proper size for the return value. If you like, you can suggest a larger array to be used instead. If the ArrayList fits in that array, it will be returned. Otherwise, a new one will be created. * Also, notice that line 18 clears the original List. This does not affect either array. The array is a newly created object with no relationship to the original List. It is simply a copy.

Question 52

**create backed List:** ``` 20: String[] array = { "hawk", "robin" }; // [hawk, robin] 21: List list = Arrays.asList(array); // returns fixed size list 22: System.out.println(list.size()); // 2 23: list.set(1, "test"); // [hawk, test] 24: array[0] = "new"; // [new, test] 25: System.out.print(Arrays.toString(array));// [new, test] 26: list.remove(1); // throws UnsupportedOperationException ```

Answer 52

create a **List that is linked to the original array.** When a change is made to one, it is available in the other. It is a **fixed-size list** and is also known as a **backed List because the array changes with it.** * Line 21 converts the array to a List. Note that it isn’t the java.util.ArrayList we’ve grown used to. It is a fixed-size, backed version of a List. * Line 23 is okay because set() merely replaces an existing value. It updates both array and list because they point to the same data store. * Line 24 also changes both array and list. * Line 25 shows the array has changed to [new, test]. * Line 26 throws an exception because we are not allowed to change the size of the list.

Question 53

**create an immutable List** ``` 32: String[] array = { "hawk", "robin" }; // [hawk, robin] 33: List list = List.of(array); // returns immutable list 34: System.out.println(list.size()); // 2 35: array[0] = "new"; 36: System.out.println(Arrays.toString(array)); // [new, robin] 37: System.out.println(list); // [hawk, robin] 38: list.set(1, "test"); // throws UnsupportedOperationException ```

Answer 53

Another option is to create an **immutable List.** That means you **cannot change the values or the size of the List.** You **can change the original array, but changes will not be reflected in the immutable List.** * Line 33 creates the immutable List. It contains the two values that array happened to contain at the time the List was created. * On line 35, there is a change to the array. * Line 36 shows that array has changed. * Line 37 shows that list still has the original values. This is because it is an immutable copy of the original array. * Line 38 shows that changing a list value in an immutable list is not allowed.

Question 54

**USING VARARGS TO CREATE A LIST**

Answer 54

``` List list1 = Arrays.asList("one", "two"); List list2 = List.of("one", "two"); ``` Both of these methods take varargs, which let you pass in an array or just type out the String values. This is handy when testing because you can easily create and populate a List on one line. Both methods **create fixed-size arrays.** If you will need to later add or remove elements, you’ll still need to create an ArrayList using the constructor.

Question 55

**Array and list conversions**

Answer 55

1. `Object[] toArray()` ` T[] toArray(T[] a)` Not allowed to remove values from created object Allowed to change values in the created object Changing values in the created object will **not** affects the original or vice versa. 2. `static List asList(T... a)` (**fixed-size list/backed List**) Not allowed to remove values from created object Allowed to change values in the created object Changing values in the created object affects the original or vice versa. 3. `static List of()` (unmodifiable list) Not allowed to remove values from created object Not allowed to change values in the created object NA

Question 56

**ArrayList SORTING**

Answer 56

``` List numbers = new ArrayList<>(); numbers.add(99); numbers.add(5); numbers.add(81); Collections.sort(numbers); System.out.println(numbers); // [5, 81, 99] ```

Question 57

``` 3: Set set = new HashSet<>(); 4: System.out.println(set.add(66)); // true 5: System.out.println(set.add(66)); // false 6: System.out.println(set.size()); // 1 7: set.remove(66); 8: System.out.println(set.isEmpty()); // true ```

Answer 57

All the methods you learned for ArrayList apply to a Set with the exception of those taking an index as a parameter. Why is this? Well, a Set isn’t ordered, so it wouldn’t make sense to talk about the first element. This means you cannot call set(index, value) or remove(index). You can call other methods like add(value) or remove(value).

Question 58

**Common Map methods**

Answer 58

1. `V get(Object key)` Returns the value mapped by key or null if none is mapped 2. `V getOrDefault(Object key, V other)` Returns the value mapped by key or other if none is mapped 3. `V put(K key, V value)` Adds or replaces key/value pair. Returns previous value or null 4. `V remove(Object key)` Removes and returns value mapped to key. Returns null if none 5. `boolean containsKey(Object key)` Returns whether key is in map 6. `boolean containsValue(Object value)` Returns whether value is in map 7. `Set keySet()` Returns set of all keys 8. `Collection values()` Returns Collection of all values

Question 59

``` 8: Map map = new HashMap<>(); 9: map.put("koala", "bamboo"); 10: String food = map.get("koala"); // bamboo 11: String other = map.getOrDefault("ant", "leaf"); // leaf 12: for (String key: map.keySet()) 13: System.out.println(key + " " + map.get(key)); // koala bamboo ```

Question 60

**Calculating with Math APIs**

Answer 60

1. `double min(double a, double b)` `float min(float a, float b)` `int min(int a, int b)` `long min(long a, long b)` The max() method works the same way except it returns the larger value. 2. `long round(double num)` `int round(float num)` gets rid of the decimal portion of the value, choosing the next higher number if appropriate. If the fractional part is .5 or higher, we round up. 3. `double pow(double number, double exponent)` Fractional exponents are allowed as well. Sixteen to the .5 power means the square root of 16, which is 4. 4. `double random()` returns a value greater than or equal to 0 and less than 1.