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

Question 1

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()). Option B is correct because 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 2

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.. Option B is correct because 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 3

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 4

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.. Option A is correct because 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 5

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()). Option A is correct because 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)

Question 6

Which TWO statements about the java.util.Collections class are true?

Accepted Answer

Collections.synchronizedList(List) returns a synchronized list backed by the specified list.. Option D is correct because Collections.synchronizedList(List) returns a synchronized (thread-safe) list backed by the specified list. This method wraps the provided list in a synchronized wrapper, ensuring that all access to the underlying list is serialized when accessed through the returned list. It does not create a new independent list but provides a view that synchronizes all method calls.

Answer

Collections.sort(List) returns a new sorted list.

Answer

Collections.reverse(List) returns a new reversed list.

Answer

Collections.shuffle(List) returns a new shuffled list.

Question 7

Arrange the steps to create and use a generic method in Java.

Question 8

Match each Java collection class to its underlying data structure.

Question 9

A developer needs to sort a List of Employee objects by salary (double) in descending order. Which approach is correct and efficient?

Accepted Answer

Collections.sort(list, (e1, e2) -> Double.compare(e2.getSalary(), e1.getSalary()));. Option C is correct because it uses `Collections.sort()` with a custom `Comparator` that performs an in-place sort of the original list, which is both efficient (no new list created) and correctly orders by salary descending via `Double.compare(e2.getSalary(), e1.getSalary())`. This avoids the overhead of stream pipeline creation and collection, and directly mutates the list as required.

Answer

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

Answer

list.stream().sorted((e1, e2) -> Double.compare(e2.getSalary(), e1.getSalary())).collect(Collectors.toList());

Answer

Collections.sort(list);

Question 10

What is the result of the following code?
List<String> list = List.of("A", "B");
list.add("C");
System.out.println(list);

Accepted Answer

An exception is thrown at runtime. The `List.of()` factory method returns an immutable list. Calling `add()` on an immutable list throws an `UnsupportedOperationException` at runtime, so the code does not compile or run successfully. Option C is correct because the exception is thrown when the `add` method is invoked.

Answer

[A, B, C]

Answer

[A, B]

Answer

Compilation error

Question 11

Which of the following correctly describes the behavior of the following code? List list = new ArrayList<>(); list.add("A"); list.add("B"); for (String s : list) { if (s.equals("A")) { list.remove(s); } } System.out.println(list);

Accepted Answer

ConcurrentModificationException is thrown. The code uses an enhanced for-each loop to iterate over an ArrayList while calling `list.remove(s)` when the element equals "A". This modifies the list structurally during iteration, which causes the iterator (used internally by the for-each loop) to detect the concurrent modification and throw a `ConcurrentModificationException` at runtime. The exception is thrown because the iterator's `modCount` check fails when the list is modified outside of the iterator's own `remove` method.

Answer

Compilation error

Answer

[B]

Answer

[A, B] unchanged

Question 12

When should LinkedList be preferred over ArrayList?

Accepted Answer

Frequent insertions and deletions at arbitrary positions. LinkedList is preferred over ArrayList when frequent insertions and deletions occur at arbitrary positions because LinkedList uses a doubly-linked list structure, allowing O(1) time for insertions/deletions once the node is located, whereas ArrayList requires shifting elements (O(n)) due to its underlying array. This makes D correct for scenarios with heavy modification in the middle of the list.

Answer

Frequent random access by index

Answer

Fast iteration over all elements

Answer

Minimal memory overhead

Question 13

Given:
String[] array = {"A", "B"};
List<String> list = Arrays.asList(array);
list.set(0, "C");
array[1] = "D";
What is the content of the list?

Accepted Answer

[C, D]. Option B is correct because `Arrays.asList()` returns a fixed-size list backed by the original array. Modifications to the list via `set()` directly affect the backing array, and modifications to the array elements are reflected in the list. After `list.set(0, "C")`, the first element of both the list and the array becomes "C". After `array[1] = "D"`, the second element of both becomes "D". Thus the list content is [C, D].

Answer

[A, D]

Answer

[A, B]

Answer

[C, B]

Question 14

Which statement about TreeSet is true when using a custom Comparator that does not define equals() consistently with compare()?

Accepted Answer

TreeSet considers two elements equal if the comparator returns 0.. TreeSet uses the compare() method of the provided Comparator (or the natural ordering's compareTo()) to determine element equality. When a custom Comparator returns 0 for two elements, TreeSet treats them as duplicates and does not add the second element, regardless of what equals() returns. This is specified in the Java Collections Framework documentation and is critical for maintaining the Set contract.

Answer

TreeSet uses equals() to determine duplicates.

Answer

TreeSet uses hashCode() for ordering.

Answer

TreeSet throws IllegalArgumentException if equals() is inconsistent.