1Z0-829 Working with Arrays and Collections Practice Test 3 — 15 Questions

Question 1

What does the Map.merge() method do if the specified key is absent?

Accepted Answer

Associates the key with the given value. When the specified key is absent in the map, the `Map.merge()` method associates the key with the given value without invoking the remapping function. This is specified in the Java API documentation: if the key is not present (or maps to null), the key is associated with the given non-null value.

Answer

Calls the remapping function with null and the value

Answer

Throws NullPointerException

Answer

Removes the key if present

Question 2

Which is true about CopyOnWriteArrayList?

Accepted Answer

Modifications are expensive as they create a new array.. CopyOnWriteArrayList is a thread-safe variant of ArrayList where all mutative operations (add, set, remove, etc.) are implemented by making a fresh copy of the underlying array. This design makes modifications expensive because each modification requires copying the entire array, but it provides safe iteration without locking. Option C correctly identifies that modifications are expensive due to the array copy.

Answer

It is not thread-safe.

Answer

Iterators reflect concurrent modifications.

Answer

It is optimized for frequent modifications.

Question 3

What will be the result of the following code?
Object[] arr = new Integer[5];
arr[0] = "String";

Accepted Answer

ArrayStoreException at runtime. The code creates an array of type `Integer[]` referenced by an `Object[]` variable. At runtime, the array's actual component type is `Integer`, so attempting to store a `String` violates the array's type constraint and throws an `ArrayStoreException`.

Answer

Successfully stores "String"

Answer

Compilation error

Answer

ClassCastException

Question 4

Which TWO statements are true about creating an unmodifiable List?

Accepted Answer

Collections.unmodifiableList() returns a view that is unmodifiable, but the backing list can still be changed.. A is correct because `Collections.unmodifiableList()` returns a view of the backing list that cannot be modified through the returned reference, but any changes made to the original backing list are reflected in the view. This means the view is unmodifiable but not immutable, as the underlying list can still be mutated.

Answer

List.copyOf() creates a list that, if the source list is changed, the copy also changes.

Answer

new ArrayList<>(Arrays.asList(...)) creates an unmodifiable list.

Answer

Arrays.asList() returns an unmodifiable list.

Question 5

Which TWO are true about HashSet and TreeSet?

Accepted Answer

HashSet uses equals() and hashCode() for uniqueness, TreeSet uses compareTo() or Comparator.. HashSet relies on the equals() and hashCode() methods to determine element uniqueness, while TreeSet uses the natural ordering (compareTo()) or a provided Comparator to maintain sorted order and check for duplicates. This distinction is fundamental to how these Set implementations enforce uniqueness.

Answer

HashSet maintains elements in insertion order.

Answer

Both implement the List interface.

Answer

Both guarantee constant-time performance for basic operations (add, remove, contains).

Question 6

Which THREE are methods of the Map.Entry interface? (Java 17)

Accepted Answer

getValue(). The Map.Entry interface in Java defines the getValue() method, which returns the value associated with the entry's key. This method is part of the core contract for accessing key-value pairs within a Map.

Answer

getHash()

Answer

getValueOrDefault()

Question 7

Given the code snippet: List list = new ArrayList<>(List.of("A","B","C")); list.add("D"); System.out.println(list.size()); What is the result?

Accepted Answer

4. The code creates an ArrayList from a fixed-size list returned by List.of() using the ArrayList constructor, which creates a new mutable list containing the elements "A", "B", "C". The subsequent call to list.add("D") successfully appends the element, resulting in a list of size 4. The ArrayList constructor copies the elements, so the original immutable list is not modified.

Answer

5

Answer

UnsupportedOperationException

Answer

Compilation fails

Answer

3

Question 8

Which of the following correctly sorts an array of integers (int[] arr) in descending order?

Accepted Answer

Integer[] boxed = Arrays.stream(arr).boxed().toArray(Integer[]::new); Arrays.sort(boxed, Collections.reverseOrder()); arr = Arrays.stream(boxed).mapToInt(i->i).toArray();. It demonstrates the proper technique for sorting a primitive int array in descending order. The `Arrays.sort()` method does not accept a `Comparator` for primitive arrays, so the array must first be boxed into an `Integer[]` using `Arrays.stream(arr).boxed().toArray(Integer[]::new)`. After sorting with `Collections.reverseOrder()`, the result is unboxed back to `int[]` via `mapToInt(i->i).toArray()`. This approach correctly leverages the `Comparator` interface, which only works with object types.

Answer

Arrays.sort(arr, Collections.reverseOrder());

Answer

None of the above, because primitive arrays cannot be sorted in descending order.

Answer

Arrays.sort(arr, (a,b) -> b - a);

Answer

Arrays.parallelSort(arr, (a,b) -> b - a);

Question 9

Given: Map map = new HashMap<>(); map.put("x", 10); map.put("y", 20); map.computeIfAbsent("x", k -> 30); map.computeIfPresent("z", (k,v) -> 40); System.out.println(map); What is the output?

Accepted Answer

{x=10, y=20}. `computeIfAbsent` only inserts a mapping if the key is absent, and since "x" already exists with value 10, the lambda is not executed and the value remains 10. `computeIfPresent` only modifies a mapping if the key is present, and since "z" is not in the map, the lambda is not executed and no entry is added. Thus the map remains {x=10, y=20}.

Answer

Compilation fails

Answer

{x=30, y=20}

Answer

{x=30, y=20, z=40}

Answer

{x=10, y=20, z=40}

Question 10

Which TWO of the following statements about the Collections framework are true?

Accepted Answer

Collections.unmodifiableList returns an unmodifiable view of the list.. `Collections.unmodifiableList()` returns a view of the specified list that cannot be modified. Any attempt to modify the returned list (e.g., add, remove, set) will throw an `UnsupportedOperationException`. This is a standard method in the Java Collections Framework to provide read-only access to a list.

Answer

Collections.checkedList performs type checking at compile time.

Answer

List.of returns a mutable list.

Answer

Arrays.asList returns a mutable list of variable size.

Question 11

Which THREE of the following variable declarations are valid in Java 17?

Accepted Answer

List list = new ArrayList();. `List` is a wildcard type that can hold any type, and `new ArrayList()` creates an `ArrayList` of a specific type (`String`). The wildcard `?` acts as a type-safe placeholder, allowing the assignment of a concrete parameterized type to an unbounded wildcard reference. This is valid because the wildcard represents an unknown type, and the list is read-only in terms of type safety (you cannot add elements except `null`).

Answer

List<Object> list = new ArrayList<String>();

Answer

List list = new ArrayList();

Question 12

Which TWO of the following will sort a List<String> in natural (ascending) order?

Accepted Answer

list.sort(Comparator.naturalOrder());. `Comparator.naturalOrder()` returns a comparator that imposes the natural (ascending) ordering on `String` objects, which is lexicographic order based on Unicode values. The `List.sort()` method accepts this comparator and sorts the list in place, making it a concise and idiomatic way to sort a list in ascending order.

Answer

list.sort((a,b) -> b.compareTo(a));

Answer

Collections.sort(list, Collections.reverseOrder());

Answer

Arrays.sort(list);

Question 13

What is the output of the above code?

Accepted Answer

[a, c]. The code uses `List.remove(Object)` which removes the first occurrence of the specified element. After removing "b" from the list [a, b, c], the list becomes [a, c]. Option B is correct because the output is [a, c].

Answer

[a, b]

Answer

[a, b, c]

Answer

[b, c]

Answer

Compilation fails

Question 14

Given the above Java version, which of the following is NOT a standard Java 17 feature?

Accepted Answer

Pattern matching for switch (preview). Pattern matching for switch is a preview feature in Java 17, not a standard feature. It was introduced as a preview under JEP 406 and requires the --enable-preview flag to be used. Standard features in Java 17 are finalized and do not require any preview flags.

Answer

All of the above are standard

Answer

Sealed classes

Answer

Text blocks

Answer

Records

Question 15

What is the result of attempting to compile and run the following code?
```java
import java.util.*;
List<String> list = Arrays.asList("A", "B");
list.removeIf(s -> s.startsWith("A"));
System.out.println(list);
```

Accepted Answer

Runtime exception. The code compiles successfully because `removeIf` is a default method in `Collection` and the predicate is a valid lambda. However, `Arrays.asList` returns a fixed-size list backed by the array, and `removeIf` attempts to modify the list structurally, which throws `UnsupportedOperationException` at runtime. Therefore, the correct answer is E: Runtime exception.

Answer

[A, B]

Answer

[A]

Answer

[B]

Answer

Compilation fails