1Z0-829 Working with Arrays and Collections — 20 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(); }. 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. 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);. `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. `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 `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. (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<>()). `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.. 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().

Question 11

Which THREE are valid ways to iterate over a Map<String, Integer>?

Accepted Answer

for (String key : map.keySet()) { }. `Map.keySet()` returns a `Set` containing all keys, which can be iterated using an enhanced for-each loop. This is a standard way to access keys in a `Map`.

Answer

for (Map.Entry<String, Integer> entry : map) { }

Answer

for (Integer value : map.values()) { }

Question 12

What is the output of the program?

Accepted Answer

[A, B, C]. The program code was not provided in the question. Without the code, it is impossible to determine the output. Therefore, none of the options can be confirmed as correct.

Answer

[A, B, C, D]

Answer

[A, B, D]

Answer

[B, C, D]

Question 13

What is the cause of the ClassCastException?

Accepted Answer

The value stored is Integer but retrieved as String.. The ClassCastException occurs because the code retrieves a value from the store map and attempts to cast it to String, but the actual stored object is an Integer. Since the map is not using generics (raw type), the compiler does not enforce type safety, allowing the mismatch to be caught only at runtime.

Answer

The store map is not type-safe.

Answer

The get method should use (T) cast instead of type.cast().

Answer

The type parameter T is not used correctly.

Question 14

A financial application processes transactions in batches. Each transaction is represented as a Transaction object with fields: long id, BigDecimal amount, LocalDateTime timestamp. Transactions are stored in a List<Transaction> in the order they arrive. The system needs to frequently check if a transaction with a specific id exists, and also needs to iterate through transactions in chronological order. The list currently contains millions of transactions, and the existence check is becoming a performance bottleneck because it currently uses a linear search. The system must also maintain insertion order for iteration. Which approach best improves the performance of the existence check while maintaining the required iteration order?

Accepted Answer

Replace List with LinkedHashMap mapping id to transaction. Iterate using values() which preserves insertion order.. LinkedHashMap maintains insertion order for iteration via its values() view, while providing O(1) key-based lookup for the existence check. This directly addresses the performance bottleneck of linear search in a List without sacrificing the required chronological iteration order.

Answer

Keep List and add a separate HashSet of ids for fast lookup. Use the list for iteration.

Answer

Keep List<Transaction> and sort it by id. Use Collections.binarySearch() for lookup.

Answer

Replace List with TreeMap mapping id to transaction. Iterate using values() which returns in natural key order.

Question 15

A web server logs user sessions. Each session has a unique session ID (String) and a last access time (long). The system needs to evict sessions that have been inactive for more than 30 minutes. The current implementation uses a HashMap<String, Long> to store session IDs and last access times. A scheduled task iterates over all entries and removes those where currentTime - lastAccess > 30 minutes. However, this iteration is becoming slow as the number of sessions grows (millions). The developer wants to improve the eviction performance without affecting the O(1) put and get operations. Which approach should be taken?

Accepted Answer

Use LinkedHashMap<String, Long> with access-order=true and override removeEldestEntry() to evict entries older than 30 minutes.. LinkedHashMap with access-order=true and a custom removeEldestEntry() method provides O(1) amortized put/get operations while automatically evicting the least-recently accessed entry when a condition is met. By overriding removeEldestEntry() to check if the eldest entry's last access time is older than 30 minutes, the eviction happens during put operations without requiring a separate iteration over all entries, thus solving the performance issue.

Answer

Use PriorityQueue<Session> ordered by last access time and update the time when accessed.

Answer

Use ConcurrentHashMap<String, Long> and use parallel streams to remove expired entries.

Answer

Use TreeMap<String, Long> sorted by last access time and poll the first entry if too old.

Question 16

A developer is implementing a custom sort for a list of Employee objects. The Employee class has fields: String name, int age. The list must be sorted first by name (ascending, case-insensitive), then by age (descending). Which Comparator implementation correctly achieves this?

Accepted Answer

Comparator.comparing(Employee::getName, String.CASE_INSENSITIVE_ORDER).thenComparing(Comparator.comparingInt(Employee::getAge).reversed()). It first sorts by name using a case-insensitive comparator, then chains a reversed comparator for age, ensuring descending order for age while preserving the primary sort by name. The `thenComparing` method correctly applies the reversed age comparator as a secondary sort, which is essential for multi-field sorting where one field requires descending order.

Answer

Comparator.comparing(Employee::getName, String.CASE_INSENSITIVE_ORDER).thenComparingInt(Employee::getAge)

Answer

Comparator.comparingInt(Employee::getAge).reversed().thenComparing(Employee::getName, String.CASE_INSENSITIVE_ORDER)

Answer

Comparator.comparing(Employee::getName).thenComparingInt(Employee::getAge).reversed()

Question 17

Which THREE statements are true about the java.util.Collection and java.util.stream.Stream APIs? (Choose three.)

Accepted Answer

The Stream.forEach() operation processes elements in the encounter order of the stream only for sequential streams.. The Stream.forEach() operation respects the encounter order of the stream only for sequential streams. For parallel streams, the order is not guaranteed unless the stream is explicitly forced to be sequential or uses forEachOrdered(). This behavior is defined in the Stream API specification.

Answer

The Collection.forEach() method is inherited from the Collection interface.

Answer

The Collection interface inherits the stream() method from the Iterable interface.

Question 18

What is the result of executing the code in the exhibit?

Accepted Answer

ConcurrentModificationException is thrown.. The code uses an ArrayList and iterates over it with an enhanced for-each loop while simultaneously removing an element via the list's remove() method. This structural modification directly from the list (not via the iterator's remove()) triggers a ConcurrentModificationException because the iterator's modCount check fails. The exception is thrown at the next iteration attempt after the removal.

Answer

The code compiles and runs without output.

Answer

[A, C]

Answer

[A, B]

Question 19

A developer is working on a high-performance trading application that processes market data. The system needs to maintain a sorted list of order IDs (Long values) that are frequently inserted and removed. The current implementation uses a TreeSet<Long> to store the order IDs. The application is experiencing performance degradation under high load, and profiling shows that the TreeSet operations are the bottleneck. The developer considers replacing the TreeSet with a data structure that offers O(log n) insertion and removal but also supports O(log n) indexed access (e.g., get by index) for batch processing. Which of the following should the developer choose to improve performance while maintaining the sorted order and adding indexed access?

Accepted Answer

No standard Java Collections class fulfills all requirements; consider a custom implementation.. No standard Java Collections class provides O(log n) insertion, removal, and O(log n) indexed access while maintaining sorted order. TreeSet offers O(log n) insertion/removal but lacks indexed access; ArrayList provides O(1) indexed access but requires O(n log n) sorting after each insertion; PriorityQueue offers O(log n) insertion/removal but only O(1) peek access, not indexed access. A custom data structure like an order statistic tree (e.g., a balanced binary search tree with subtree sizes) is needed to meet all requirements.

Answer

Replace with TreeMap<Long, Boolean> and use the key set for iteration and indexed access via keySet().toArray().

Answer

Replace with PriorityQueue<Long> and use poll() for removal and toArray() for indexed access.

Answer

Replace with ArrayList<Long> and use Collections.sort() after each insertion.

Question 20

A developer needs to filter a list of transactions where the amount is greater than 100 and collect the results into a new list. Which approach is best practice for readability and performance?

Accepted Answer

transactions.stream().filter(t -> t.getAmount() > 100).collect(Collectors.toList()). It uses the Stream API's `filter` method to declaratively select transactions with an amount greater than 100, and `collect(Collectors.toList())` to gather results into a new list. This approach is both readable and performant, leveraging lazy evaluation and internal iteration for efficient processing.

Answer

List result = new ArrayList<>(); for(Transaction t : transactions) { if(t.getAmount() > 100) result.add(t); }

Answer

transactions.stream().filter(t -> t.getAmount() > 100).toArray()

Answer

transactions.removeIf(t -> t.getAmount() <= 100)