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

Question 1

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

Question 2

Which of the following will compile without error and produce an unmodifiable list containing three elements?

Accepted Answer

List.of("A","B","C"). `List.of("A","B","C")` returns an unmodifiable list exactly as required. In Java 9+, `List.of` returns an immutable list; any attempt to modify it throws `UnsupportedOperationException`. Option A, `Arrays.asList`, returns a fixed-size list backed by an array that allows modification via `set()`, so it is not unmodifiable. Option B, `new ArrayList<>(List.of(...))`, creates a mutable ArrayList. Option D, `Collections.unmodifiableList`, returns an unmodifiable view, but the underlying ArrayList is still mutable; modifications to the original list affect the view, so it does not guarantee immutability. Therefore, only C meets the criteria.

Answer

Arrays.asList("A","B","C")

Answer

new ArrayList<>(List.of("A","B","C"))

Answer

Collections.unmodifiableList(new ArrayList<>(List.of("A","B","C")))

Answer

None of the above

Question 3

A developer needs to iterate over an ArrayList of integers and remove all elements that are less than 10. Which approach is best to avoid ConcurrentModificationException?

Accepted Answer

Use list.removeIf() with a lambda expression.. `list.removeIf()` is a built-in method introduced in Java 8 that safely removes elements from a collection based on a predicate, handling all iteration and modification internally without throwing ConcurrentModificationException. It uses an internal iterator that properly coordinates structural modifications, making it the most concise and reliable approach for this task.

Answer

Use a for loop with index and list.remove(index) decrementing index.

Answer

Use an Iterator with iterator.remove().

Answer

Use a for-each loop with list.remove().

Question 4

Which TWO statements about Arrays.asList() are true? (Select two.)

Accepted Answer

It returns a fixed-size list backed by the original array.. Option D is correct because Arrays.asList() returns a fixed-size List backed directly by the specified array, so structural modifications like add() or remove() throw UnsupportedOperationException. Option E is correct because the returned list is a view over the original array, so set() operations on the list write through to the underlying array elements. Option A is wrong because the returned list is fixed-size and does not support adding or removing elements. Option B is wrong because Arrays.asList() does not copy elements into a new ArrayList; it returns a java.util.Arrays$ArrayList view. Option C is wrong as stated because Arrays.asList() itself does not produce a mutable list; only wrapping it in new ArrayList<>(Arrays.asList(...)) creates a separate mutable ArrayList, which is not what the option claims.

Answer

It supports adding and removing elements.

Answer

It returns a new ArrayList with a copy of the elements.

Answer

It can be used to convert an array to a mutable list if wrapped with new ArrayList<>().

Question 5

Which THREE of the following are valid ways to create a new ArrayList<Integer>? (Select three.)

Accepted Answer

new ArrayList<>(Arrays.asList(1,2,3)). Option A is correct because the ArrayList(Collection c) constructor accepts the List returned by Arrays.asList(1,2,3), copying its elements into the new ArrayList. Option C is correct because List.of(1,2,3) returns an immutable List, which is also a Collection and can be passed to the same ArrayList(Collection) constructor. Option E is correct because new ArrayList() creates an empty ArrayList, and the int constructor ArrayList(int initialCapacity) can be used with 10 to pre-size the backing array, which is a valid way to create an ArrayList. Option B is invalid because ArrayList has no constructor taking three separate integer arguments. Option D is invalid because Arrays.asList returns a fixed-size List backed by the array, not an ArrayList, so the cast to ArrayList throws a ClassCastException at runtime.

Answer

new ArrayList<>(10, 20, 30)

Answer

(ArrayList<Integer>) Arrays.asList(1,2,3)

Question 6

Which TWO are valid ways to create an immutable list in Java 17? (Choose two.)

Accepted Answer

Collections.unmodifiableList(new ArrayList<>(List.of("a", "b"))). Option C is correct because Collections.unmodifiableList returns an unmodifiable view of the backing list, so any attempt to modify it (add, set, remove) throws UnsupportedOperationException, making it effectively immutable in Java 17. Option D is correct because List.copyOf creates an unmodifiable copy of the given collection; the resulting list rejects all mutating operations with UnsupportedOperationException and is a true immutable snapshot. Option A is not correct because Arrays.asList returns a fixed-size list backed by the array — set() is allowed, so it is not immutable. Option B is not correct because List.of(List.of("a", "b")) creates an immutable list containing a nested immutable list, but the question asks for valid ways to create an immutable list, and this option is a nested-list construction rather than a standard idiom for creating an immutable list of the given elements; more importantly, it is not among the marked correct answers. Option E is not correct because new ArrayList<>(...) creates a mutable ArrayList whose elements can be added, removed, or replaced.

Answer

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

Answer

List.of(List.of("a", "b"))

Answer

new ArrayList<>(List.of("a", "b"))

Question 7

A company's Java 17 application processes large log files and stores word counts. Initially, they used a TreeMap to maintain sorted word counts. After adding 10 million entries, insertion performance became unacceptably slow. The team switched to a HashMap for fast insertions, but now they need to produce sorted reports. They are considering two approaches: (1) Keep the HashMap and, when a sorted report is needed, extract all entries into an ArrayList> and sort it using Collections.sort with a comparator, or (2) Use a ConcurrentSkipListMap instead. The application is single-threaded, and reports are requested infrequently. What is the best course of action?

Accepted Answer

Use HashMap and sort with Collections.sort when needed. The application is single-threaded and reports are infrequent, so the overhead of sorting a HashMap's entries only when needed is acceptable and avoids the continuous insertion cost of a TreeMap. HashMap provides O(1) insertions, and sorting an ArrayList of 10 million entries with Collections.sort (which uses TimSort, O(n log n)) is efficient for occasional use, making this the best balance of performance and simplicity.

Answer

Use ConcurrentSkipListMap

Answer

Use LinkedHashMap and convert to sorted list when needed

Answer

Revert to TreeMap because it always keeps data sorted

Question 8

A developer is writing a method that takes a Collection and returns a List containing the same elements in sorted order. The method should not modify the original collection. The developer tries the following code: public List sortCollection(Collection col) { return col.stream().sorted().collect(Collectors.toList()); } The code compiles and runs, but the team lead says it is not optimal. What improvement should be made?

Accepted Answer

Return an unmodifiable list using collect(Collectors.toUnmodifiableList()). The current code creates a mutable list via `Collectors.toList()`, but the method contract does not require mutability. Using `Collectors.toUnmodifiableList()` returns an unmodifiable list, which is more memory-efficient and thread-safe, and it aligns with the principle of returning immutable collections when modification is not needed. This improvement does not affect sorting correctness but optimizes the result for immutability.

Answer

Use parallelStream() for better performance

Answer

Use a TreeSet and then convert to List

Answer

Convert the collection to an ArrayList first, then call Collections.sort() on it

Question 9

A developer is implementing a cache that stores recent user sessions. The cache should maintain the most recently accessed session at the end, and when the cache reaches its maximum size (1000), it should remove the least recently accessed session (i.e., the oldest). The developer chooses a LinkedList to store sessions, adding new sessions at the end and removing from the front. However, performance is poor because searching for an existing session to update its position requires O(n) linear scan. Which collection should replace the LinkedList to improve performance while maintaining the removal order?

Accepted Answer

LinkedHashSet. LinkedHashSet (C) maintains insertion order (which can be used to represent access order if reinserted on access) and provides O(1) average-time complexity for add, remove, and contains operations. By removing and re-adding a session upon access, it moves to the end, and the oldest (first inserted) can be removed from the front when the size exceeds 1000, solving the O(n) scan problem of LinkedList.

Answer

TreeSet

Answer

HashSet

Answer

ArrayList

Question 10

A Java 17 application uses a HashMap> to group error messages by error code. The map may contain up to 5000 error codes, and each list may contain up to 1000 messages. The application frequently retrieves the list for a given error code and iterates over it. The lists are rarely modified after initial population. The current performance is acceptable, but the team wants to reduce memory footprint. The developer suggests replacing the inner List with an array (String[]), but then iteration would require conversion. Another developer suggests using a TreeMap instead of HashMap to save memory because TreeMap uses less memory per entry? Actually TreeMap has more overhead. Actually HashMap typically has lower overhead than TreeMap. The correct approach: Since lists are rarely modified, consider using List.of to create immutable lists that can be shared? Or use ArrayList with initial capacity to reduce resizing. But the stem says 'reduce memory footprint'. Option C: Use ArrayList with initial capacity to reduce internal array resizing overhead. Option A: Use TreeMap - wrong because TreeMap uses more memory per entry due to tree nodes. Option B: Use array of arrays - not type-safe. Option D: Use LinkedList - higher memory overhead per element. So best is to use ArrayList with proper sizing to minimize wasted space.

Accepted Answer

Use ArrayList<String> with initial capacity set to expected list size. Using an ArrayList with an initial capacity set to the expected list size eliminates the overhead of repeated internal array resizing (which wastes memory by leaving unused capacity). Since the lists are rarely modified after initial population, this approach minimizes wasted space without sacrificing iteration performance, unlike the other options.

Answer

Replace ArrayList with LinkedList

Answer

Replace HashMap with TreeMap

Answer

Replace List<String> with String[]

Question 11

You are developing a high-frequency trading application that processes a stream of market data ticks. Each tick is an immutable object containing timestamp, price, and volume. The ticks arrive in real time and must be stored in a collection for later analysis. The collection is accessed by multiple threads: one producer thread adds ticks, and multiple consumer threads periodically iterate to compute moving averages. The system must minimize latency for the producer and ensure that consumers see a consistent snapshot of data without interfering with ongoing writes. You initially used a synchronized ArrayList, but profiler results show high contention and poor throughput. You consider the following approaches. Which one best addresses the requirements?

Accepted Answer

Use a ConcurrentLinkedDeque for writes and have consumers obtain a consistent snapshot by calling toArray() on the deque. The toArray() operation is O(n) but provides a point-in-time view without blocking the producer.. ConcurrentLinkedDeque allows lock-free, non-blocking writes (ideal for low-latency producers) and calling toArray() provides a consistent, immutable snapshot of the deque at that instant without blocking concurrent modifications. This satisfies the requirement for multiple consumers to see a consistent view while the producer continues writing with minimal latency.

Answer

Replace ArrayList with CopyOnWriteArrayList, which provides thread-safety without explicit synchronization and allows concurrent iteration while modifications occur.

Answer

Use a ConcurrentLinkedDeque and have consumers acquire a read lock when iterating, while the producer uses a write lock. This provides fine-grained locking and reduces contention.

Answer

Maintain two synchronized ArrayLists. The producer writes to one list while consumers read from the other. Periodically, swap references using an AtomicReference. This allows lock-free reads after the swap.

Question 12

A developer is designing a method that returns an immutable list of strings from an array. Which approach best follows current Java best practices?

Accepted Answer

Return List.of(array). `List.of(array)` returns an immutable list that is null-hostile and structurally immutable, as specified by the Java Platform Module System (JPMS) and the `List` interface since Java 9. This approach aligns with current best practices by providing a concise, safe, and predictable immutable collection without the overhead of wrapping or defensive copying.

Answer

Return new ArrayList<>(Arrays.asList(array))

Answer

Return Collections.unmodifiableList(Arrays.asList(array))

Answer

Return Arrays.asList(array)