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

Question 1

What is the result of executing this code?

Accepted Answer

Runtime exception. The code uses `Collectors.toUnmodifiableList()` which returns an unmodifiable list. Attempting to add an element to this list throws an `UnsupportedOperationException` at runtime. Therefore, option C (Runtime exception) is correct.

Answer

Compilation error

Answer

[b]

Answer

[b, d]

Question 2

A developer needs to maintain a collection of unique employee IDs where the natural ordering by ID is not the desired iteration order; instead, employees must be iterated by last name, then first name. The collection must also reject duplicate IDs and allow efficient retrieval by ID. Which collection should the developer use?

Accepted Answer

TreeMap<String, Employee> with a Comparator that compares the Employee's lastName then firstName. A sorted map keyed by employee ID enforces uniqueness on ID and provides efficient lookup by ID, while a comparator on the key type controls iteration order. The other options either do not support lookup by ID, do not enforce ID uniqueness, or do not accept a comparator at all. The design must ensure the comparator is consistent with the key type.

Answer

PriorityQueue<Employee> with a Comparator that compares lastName then firstName

Answer

TreeSet<Employee> with a Comparator that compares lastName then firstName

Answer

LinkedHashSet<Employee> with a Comparator that compares lastName then firstName

Question 3

A developer needs to convert an existing array of String objects into a List that is structurally unmodifiable, so any attempt to add or remove elements throws UnsupportedOperationException. The method must be a single expression and should not copy the array. Which Java 17 approach meets these requirements?

Accepted Answer

List<String> list = Arrays.asList(array);. Arrays.asList provides a fixed-size list view of the original array without copying. Structural modifications such as add and remove throw UnsupportedOperationException, while set is allowed. Since the scenario demands structural immutability and no array copy, this is the only option that satisfies both constraints. Other options either allow modification or create a copy.

Answer

List list = new ArrayList<>(Arrays.asList(array));

Answer

List<String> list = List.of(array);

Answer

List list = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array)));

Question 4

A developer writes a method that accepts a List<? extends Number> and wants to add Integer values to it. Which statement is true?

Accepted Answer

The method cannot add any elements to the list because of the wildcard capture.. The wildcard ? extends Number means the list is a producer of Number values, not a consumer. The compiler prevents adding any elements because the exact type of the list is unknown. This is a direct application of the PECS principle: producer extends, consumer super.

Answer

The method can add Integer values only if the list is cast to List<Integer>.

Answer

The method can add Integer values because Integer is a subtype of Number.

Answer

The method can add Integer values if it uses a helper method with a type parameter.

Question 5

A developer declares a Deque deque = new ArrayDeque<>(); and wants to add elements to both ends and retrieve them from both ends. Which method pair should be used to add to the front and remove from the back?

Accepted Answer

addFirst() and removeLast(). ArrayDeque implements Deque, which provides methods to add and remove from both ends. To add to the front and remove from the back, the correct methods are addFirst and removeLast. These are the standard exception-throwing versions. The offer/poll variants are also valid but return special values. The push/pop and add/remove pairs operate on the wrong ends or treat the deque as a stack or queue.

Answer

add() and remove()

Answer

push() and pop()

Answer

offerFirst() and pollLast()

Question 6

A developer wants to sort a list of strings in reverse alphabetical order. Which code snippet correctly achieves this using Java 17?

Accepted Answer

list.sort(Comparator.reverseOrder());. To sort a list in reverse alphabetical order, you can use Comparator.reverseOrder(), which returns a comparator that reverses the natural ordering. The List.sort method is the modern, idiomatic way to sort a list in place. The other options sort in ascending order.

Answer

Collections.sort(list);

Answer

list.sort(Comparator.naturalOrder());

Answer

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

Question 7

A developer needs to store a mapping from product IDs to product names and wants to ensure that iteration order is the same as insertion order. The map must also allow null values but not null keys. Which Map implementation should be used?

Accepted Answer

LinkedHashMap. LinkedHashMap is the only standard Map implementation that guarantees insertion-order iteration. It allows null values and one null key, though the requirement to disallow null keys would need additional handling. HashMap and Hashtable do not preserve insertion order, and TreeMap sorts keys and disallows null keys with natural ordering.

Answer

HashMap

Answer

TreeMap

Answer

Hashtable

Question 8

A developer needs to iterate over a Map and remove entries that meet a certain condition. Which approach is correct and safe in Java 17?

Accepted Answer

Use an Iterator over the entrySet and call iterator.remove().. The only safe way to remove entries from a map while iterating is to use an Iterator and its remove method. This ensures that the iterator's internal state remains consistent and avoids ConcurrentModificationException. Other approaches either cause exceptions or are not available.

Answer

Use a for-each loop over the entrySet and call map.remove(key) inside the loop.

Answer

Use a stream over the entrySet and call map.remove(key) inside the stream pipeline.

Answer

Use the Map.removeIf method with a predicate.

Question 9

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. 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 10

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 11

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);. `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 12

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 13

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 `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 14

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. (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 15

Which TWO are true about the PriorityQueue class?

Accepted Answer

It is not thread-safe.. Option C is correct because PriorityQueue is an unsynchronized collection; it does not internally guard its state, so concurrent access from multiple threads requires external synchronization (e.g., wrapping with Collections.synchronizedQueue or using PriorityBlockingQueue). Option D is correct because PriorityQueue offers a constructor PriorityQueue(int initialCapacity, Comparator comparator) and PriorityQueue(Comparator comparator), allowing a custom Comparator to define the ordering instead of natural ordering. Option A is wrong because PriorityQueue does not permit null elements; adding null throws NullPointerException (nulls are also disallowed because ordering would be undefined). Option B is wrong because PriorityQueue orders elements by their natural ordering or by the supplied Comparator, not by insertion order. Option E is wrong because contains() performs a linear scan, giving O(n) time, not O(1).

Answer

It allows null elements.

Answer

It orders elements based on insertion order.

Answer

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