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

Question 1

An application needs to maintain a set of unique customer IDs (type String) and frequently check if an ID is already present. The set is expected to contain up to 100,000 IDs. The current implementation uses a TreeSet, but performance tests show that the contains() operation is slower than desired. The developer considers switching to a HashSet. However, the business requires that when iterating the set, IDs must appear in sorted order. The developer proposes to convert the HashSet to a sorted list each time iteration is needed. Iteration occurs rarely (once per hour). What is the best approach?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Use HashSet and sort when iteration is needed. The primary performance bottleneck is the contains() operation, which is O(log n) for TreeSet but O(1) average for HashSet. Since iteration with sorted order is required only once per hour, the cost of sorting the HashSet into a list (O(n log n)) is negligible compared to the frequent contains() checks. This trade-off optimizes for the dominant use case while still meeting the sorted iteration requirement.

Answer

Use ConcurrentSkipListSet

Answer

Use LinkedHashSet

Answer

Keep the TreeSet because it maintains sorted order

Question 2

Which two statements are true about the java.util.Comparator and java.lang.Comparable interfaces? (Choose two.)

Accepted Answer

Comparator can be used to sort a list in multiple ways.. Option B is correct because Comparator is an external, strategy-style interface whose compare(T o1, T o2) method can be supplied in many different implementations (or lambdas), allowing the same list to be sorted by different criteria such as name, age, or salary via Collections.sort(list, comparator) or list.sort(comparator). Option D is correct because Comparable defines the natural ordering of a class through its single abstract method compareTo(T o), which is used implicitly by sorting methods like Collections.sort(list) and Arrays.sort(array) when no Comparator is provided. Option A is wrong because Comparator's compare method returns an int (negative, zero, or positive), not a boolean. Option C is wrong because implementing Comparable requires overriding compareTo, not equals; while it is strongly recommended that compareTo be consistent with equals, overriding equals is not a requirement of the interface. Option E is wrong because Comparator resides in the java.util package, whereas Comparable is in java.lang.

Answer

Comparator's compare method returns a boolean.

Answer

A class implementing Comparable must override equals().

Answer

Comparator is in java.lang package.

Question 3

A financial application processes transactions as List objects. The application runs on a server with limited memory (2 GB heap). The development team observes that after processing a large number of transactions (over 10 million), heap usage spikes to near 1.8 GB and garbage collection pauses become frequent (over 5 seconds). The Transaction class is defined as public record Transaction(LocalDateTime timestamp, double amount, String category) {}. The current processing code reads all transactions from a database result set into an ArrayList using a loop with list.add(). Then the list is sorted by timestamp using Collections.sort(list, Comparator.comparing(Transaction::timestamp)). The sorted list is then iterated multiple times to generate various reports. The code runs in a single-threaded context. Which change would most effectively reduce peak memory usage while preserving the sorted report output?

Accepted Answer

Collect transactions into an array (Transaction[]) and sort using Arrays.sort().. Using an array (Transaction[]) with Arrays.sort() avoids the per-element overhead of ArrayList's internal Object[] and the additional memory consumed by the ArrayList object itself (e.g., capacity tracking, modCount). In a memory-constrained environment with 10 million transactions, the ArrayList wrapper adds roughly 40–80 MB of overhead (object header, internal array pointer, size, capacity fields), whereas a plain array has only the object header and the contiguous element references. This reduction in memory footprint directly lowers peak heap usage and reduces GC pause frequency.

Answer

Use a TreeMap> to group by timestamp, then flatten on iteration.

Answer

Use a SortedSet<Transaction> (java.util.TreeSet) with a comparator to store transactions in sorted order.

Answer

Use a parallel stream with .sorted() and collect to a ConcurrentLinkedDeque.

Question 4

A developer needs a collection that stores unique elements in the order they were inserted and allows fast O(1) membership tests. Which implementation should be used?

Accepted Answer

LinkedHashSet. The requirement is for a collection that preserves insertion order, enforces uniqueness, and provides fast membership tests. LinkedHashSet is the only standard implementation that combines these three characteristics, making it the appropriate choice for this scenario.

Answer

TreeSet

Answer

ArrayList

Answer

HashSet

Question 5

A developer is writing a method that must return a List containing only the elements of an input List that start with the letter "A", without modifying the original list. The developer writes: List result = input.stream() .filter(s -> s.startsWith("A")) .collect(Collectors.toList()); input.clear(); return result; What is the result of calling this method?

Accepted Answer

The method returns a new list containing the filtered elements, and the original list is emptied.. The stream pipeline filters the input and collects matching elements into a new list before the original list is cleared. Because the collected list is independent, clearing the source does not empty the result. The method returns the filtered list, and the original list is emptied. No exception occurs because Collectors.toList() yields a mutable list and the source supports clear().

Answer

The method returns a list that is backed by the original list and becomes empty after clear() is called.

Answer

The method throws UnsupportedOperationException because Collectors.toList() returns an unmodifiable list.

Answer

The method returns an empty list because the stream is lazy and clear() is called before terminal operation.

Question 6

A developer writes the following code in a Java 17 application: List list = new ArrayList<>(List.of("a", "b")); List copy = List.copyOf(list); list.add("c"); System.out.println(copy.size()); What is printed?

Accepted Answer

2. List.copyOf produces an unmodifiable copy of the source collection's current elements. Mutating the original ArrayList afterward does not alter the copy, so the copy retains the two strings it was given. The call to add on the original list succeeds because the original remains mutable, and the size printed for the copy stays at two.

Answer

An UnsupportedOperationException is thrown at runtime.

Answer

3

Answer

A NullPointerException is thrown at runtime.

Question 7

A developer needs to store a collection of unique integers and frequently check whether a specific integer is already present. The collection must not allow duplicates. Which concrete class from the java.util package is most appropriate for this requirement?

Accepted Answer

HashSet. A Set is designed to hold unique elements, and HashSet offers constant-time performance for add and contains operations on average. This makes it ideal for frequently checking membership while preventing duplicates. ArrayList and LinkedList allow duplicates, and TreeMap is a map, not a set, so it is not the right abstraction for a collection of unique integers.

Answer

ArrayList

Answer

TreeMap

Answer

LinkedList

Question 8

A developer is reviewing code that uses Java 17 collections. Which two statements about the java.util.ArrayDeque class are correct? (Choose two.)

Accepted Answer

It can be used as a LIFO stack and as a FIFO queue.. ArrayDeque is a resizable-array implementation of the Deque interface. It prohibits null elements and supports both stack (LIFO) and queue (FIFO) operations through its Deque methods. It is not a List, is not thread-safe, and does not maintain sorted order. These characteristics make it a versatile and efficient choice for many single-threaded scenarios.

Answer

It implements the List interface.

Answer

It is thread-safe for concurrent use by multiple threads without external synchronization.

Answer

It maintains its elements in sorted order.

Question 9

A developer uses a TreeMap<String, Integer> to store configuration settings. The map is created with a custom Comparator that sorts keys by length, then alphabetically. What is the behavior when two keys have the same length but different characters?

Accepted Answer

The map treats them as distinct keys and stores both entries.. TreeMap uses the supplied Comparator to determine key ordering and equality. If the Comparator returns a non-zero value, the keys are considered distinct regardless of equals. Since the custom Comparator sorts by length then alphabetically, keys of equal length but different characters are distinct, so both entries are stored. This is the correct behavior.

Answer

The map throws a ClassCastException when the second key is inserted.

Answer

The map replaces the first entry because the keys are considered equal by the Comparator.

Answer

The map throws an IllegalArgumentException because the Comparator is inconsistent with equals.

Question 10

A developer is using a Deque to implement a stack. The developer writes the following code: Deque stack = new ArrayDeque<>(); stack.push("A"); stack.push("B"); stack.push("C"); System.out.println(stack.pop()); System.out.println(stack.peek()); What is printed?

Accepted Answer

C then B. Deque.push inserts at the head, and Deque.pop removes from the head, so the last element pushed ("C") is the first popped. After popping "C", the head becomes "B", which peek returns without removal. Therefore, the output is "C" followed by "B". This is standard stack LIFO behavior using a Deque.

Answer

C then A

Answer

B then C

Answer

A then B

Question 11

A developer uses a TreeMap<String, Integer> and inserts keys "10", "2", "1", and "apple". The developer then iterates over the map's keySet and prints each key. In what order are the keys printed?

Accepted Answer

"1", "10", "2", "apple". TreeMap sorts keys by natural ordering, and for String that means lexicographic comparison by Unicode values. Digits sort before letters, and among digit strings the comparison is character by character, so "1" precedes "10", which precedes "2". The keySet reflects this sorted order, producing "1", "10", "2", "apple".

Answer

The insertion order: "10", "2", "1", "apple"

Answer

A ClassCastException is thrown when "apple" is inserted.

Answer

"1", "2", "10", "apple"

Question 12

A developer writes the following code: List<String> list = List.of("a", "b", "c"); list.set(0, "z"); What is the result?

Accepted Answer

The code compiles but throws UnsupportedOperationException at runtime.. The List.of factory method returns an unmodifiable list. The set method is part of the List interface, so the code compiles, but the implementation throws UnsupportedOperationException at runtime. This is consistent with other unmodifiable collections such as those returned by Collections.unmodifiableList and Set.of.

Answer

The code does not compile because List.of returns an immutable list that has no set method.

Answer

The code compiles and runs, but the set operation is silently ignored.

Answer

The code compiles and runs, and the list becomes ["z", "b", "c"].

Question 13

A developer is using a HashMap to count occurrences of words. The developer writes: Map counts = new HashMap<>(); counts.put("apple", 1); counts.put("banana", 2); counts.compute("apple", (k, v) -> v + 1); counts.computeIfAbsent("cherry", k -> 0); counts.computeIfPresent("banana", (k, v) -> null); System.out.println(counts); What is the result?

Accepted Answer

{apple=2, cherry=0}. The compute method updates apple to 2. computeIfAbsent adds cherry with value 0 because the function returns 0. computeIfPresent removes banana because the remapping function returns null, which causes removal. The final map contains apple=2 and cherry=0. The other options incorrectly include banana, show null for cherry, or omit cherry.

Answer

{apple=2, cherry=null}

Answer

{apple=2}

Answer

{apple=2, banana=2, cherry=0}

Question 14

A method declares a parameter of type List and receives an ArrayList. Inside the method, the developer writes list.add(42); and then Integer first = list.get(0);. Which statement describes the outcome?

Accepted Answer

The add call compiles, but the get call assigned to Integer fails to compile.. A lower-bounded wildcard permits writing Integer values because every allowed type is a supertype of Integer. Reads, however, are typed as Object since the exact element type is unknown beyond the lower bound. The add compiles, but assigning the retrieved Object to Integer without a cast does not.

Answer

The add call fails to compile because the list might be a List<Number>.

Answer

Both statements compile and run without error.

Answer

Neither statement compiles because the wildcard makes the list unusable.

Question 15

A developer is working with a Map> and needs to compute values for keys that may not be present. Which two methods from the Map interface are best suited for this task? (Choose two.)

Accepted Answer

merge. computeIfAbsent is designed for lazy initialization when a key is absent, and merge is designed for combining a new value with an existing one or inserting if absent. Both are ideal for handling maps where keys may not be present, especially when dealing with collections as values.

Answer

computeIfPresent

Answer

putIfAbsent

Answer

replaceAll