1Z0-829 Working with Arrays and Collections — Timed 10 Questions

Question 1

A developer needs to remove elements from an ArrayList<String> while iterating over it. Which approach is safest and avoids ConcurrentModificationException?

Accepted Answer

Iterator<String> it = list.iterator(); while (it.hasNext()) { if (it.next().equals("x")) it.remove(); }. Option C is correct because the Iterator's remove() method is the only safe way to remove elements from a collection while iterating, as it updates both the iterator's internal cursor and the collection's modCount, preventing ConcurrentModificationException. The enhanced for-each loop (options A and D) uses an implicit iterator that does not expose a remove method, so calling list.remove() directly modifies the collection without updating the iterator's state, causing the exception. Option B avoids the exception by using an index-based loop, but it is unsafe because removing an element shifts subsequent elements left, causing the loop to skip the next element and potentially miss removals or throw an IndexOutOfBoundsException.

Answer

for (String s : list) { if (s.equals("x")) list.remove(s); break; }

Answer

for (int i = 0; i < list.size(); i++) { if (list.get(i).equals("x")) list.remove(i); }

Answer

for (String s : list) { if (s.equals("x")) list.remove(s); }

Question 2

Given: HashSet set = new HashSet<>(); set.add("A"); set.add("B"); set.add("C"); set.add("A"); System.out.println(set.size()); What is the output?

Accepted Answer

3. Option B is correct because HashSet does not allow duplicate elements. When adding "A" twice, the second add is ignored, so the set contains only three unique elements: "A", "B", and "C". Therefore, set.size() returns 3.

Answer

Compilation fails

Answer

4

Answer

2

Question 3

Which interface provides the ability to store key-value pairs and allows null keys?

Accepted Answer

HashMap. HashMap is the correct answer because it implements the Map interface, allows null keys (only one null key is permitted), and does not synchronize its operations, making it suitable for unsynchronized key-value storage. In contrast, ConcurrentHashMap, TreeMap, and Hashtable all prohibit null keys for various reasons, such as thread-safety guarantees or sorting requirements.

Answer

ConcurrentHashMap

Answer

TreeMap

Answer

Hashtable

Question 4

A method returns a List<Integer>. The caller wants to ensure the list cannot be modified. Which is the best approach?

Accepted Answer

return Collections.unmodifiableList(list);. Option D is correct because `Collections.unmodifiableList()` returns a read-only view of the specified list. Any attempt to modify the returned list (e.g., via `add`, `remove`, `set`) will throw an `UnsupportedOperationException`. This is the standard, recommended approach in the Java Collections Framework to provide an unmodifiable wrapper without copying the underlying data.

Answer

return Arrays.asList(list.toArray());

Answer

return new ArrayList<>(list);

Answer

return (List<Integer>) list.clone();

Question 5

Given: TreeSet ts = new TreeSet<>(Comparator.reverseOrder()); ts.add(10); ts.add(5); ts.add(20); ts.add(15); System.out.println(ts.first()); What is the result?

Accepted Answer

5. Option C is correct because `TreeSet` with `Comparator.reverseOrder()` sorts elements in descending order (20, 15, 10, 5). The `first()` method returns the smallest element according to the comparator, which in descending order is the last element in the natural order, i.e., 5.

Answer

20

Answer

15

Answer

10

Question 6

Which method of Collection interface returns a primitive int?

Accepted Answer

size(). The `size()` method is the only one in the `Collection` interface that returns a primitive `int`, representing the number of elements in the collection. All other methods listed return either a `boolean` or an array of objects, making D the correct answer.

Answer

contains(Object o)

Answer

isEmpty()

Answer

toArray()

Question 7

A developer writes: List list = new ArrayList<>(); list.add("A"); list.add("B"); list.add(1, "C"); System.out.println(list); What is the output?

Accepted Answer

[A, C, B]. The correct answer is A because the `add(int index, E element)` method inserts the element at the specified index, shifting subsequent elements to the right. Initially, the list is [A, B]. After `list.add(1, "C")`, "C" is inserted at index 1, moving "B" to index 2, resulting in [A, C, B].

Answer

[A, B, C]

Answer

[A, B]

Answer

[C, A, B]

Question 8

Given: Map map = new HashMap<>(); map.put("A", 1); map.put("B", 2); map.merge("A", 3, (v1, v2) -> v1 + v2); System.out.println(map.get("A")); What is the result?

Accepted Answer

4. The correct answer is B (4) because the `merge` method on a Map associates the key "A" with the result of applying the remapping function `(v1, v2) -> v1 + v2` to the current value (1) and the given value (3), producing 1 + 3 = 4. If the key had been absent, the new value would be 3, but since it is present, the function is invoked and the result replaces the old value.

Answer

1

Answer

3

Answer

null

Question 9

Which TWO are valid ways to create an immutable List in Java?

Accepted Answer

Collections.unmodifiableList(new ArrayList<>()). Option B is correct because `Collections.unmodifiableList()` returns a view of the specified list that cannot be structurally modified; any attempt to add, remove, or set elements will throw an `UnsupportedOperationException`. Option E is correct because `List.of()` (introduced in Java 9) directly creates an immutable list that disallows `null` elements and throws `UnsupportedOperationException` on mutation attempts.

Answer

Stream.of("a").collect(Collectors.toList())

Answer

Arrays.asList("a", "b")

Answer

new ArrayList<>()

Question 10

Which TWO are true about the PriorityQueue class?

Accepted Answer

It is not thread-safe.. Option C is correct because PriorityQueue is not thread-safe; it does not synchronize access, so concurrent modifications without external synchronization can lead to inconsistent behavior. Option D is correct because PriorityQueue can accept a custom Comparator at construction time to define the ordering of elements, overriding the natural order.

Answer

It allows null elements.

Answer

It orders elements based on insertion order.

Answer

It provides O(1) time for contains().