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

Question 1

Which Map implementation guarantees that keys are sorted in their natural order?

Accepted Answer

TreeMap. TreeMap implements the SortedMap interface, which ensures that keys are stored in their natural ordering (as defined by Comparable) or by a provided Comparator. This makes TreeMap the only standard Map implementation that guarantees sorted keys without external sorting.

Answer

Hashtable

Answer

LinkedHashMap

Answer

HashMap

Question 2

Consider: List list = new LinkedList<>(); list.add(10); list.add(20); list.add(0,5); System.out.println(list); What is the output?

Accepted Answer

[5,10,20]. The code creates a LinkedList and adds 10, then 20. The third call `list.add(0,5)` inserts 5 at index 0, shifting existing elements to the right. The resulting list is [5,10,20], so option B is correct.

Answer

[10,5,20]

Answer

[10,20,5]

Answer

[5,10,20] but with type warning

Question 3

A developer writes: ArrayList list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); Object[] arr = list.toArray(); arr[0] = "one"; What happens?

Accepted Answer

Compiles and runs, but arr[0] becomes "one". The `ArrayList.toArray()` method returns an `Object[]` array, not an `Integer[]`. Since the reference variable `arr` is declared as `Object[]`, the assignment is valid. Assigning a `String` to `arr[0]` is allowed because `Object[]` can hold any object type. No compilation or runtime error occurs because the array's runtime type is `Object[]`, and the assignment is type-safe at compile time and runtime.

Answer

Cannot cast String to Integer at runtime

Answer

Compilation error because toArray returns Integer[]

Answer

Runtime error

Question 4

Which statement about Collection interface remove methods is correct?

Accepted Answer

Collection.remove(Object) removes the first occurrence and returns boolean.. The Collection interface's remove(Object) method removes the first occurrence of the specified element from the collection, if present, and returns true if the collection was modified (i.e., the element was found and removed). This behavior is defined in the Java Collections Framework and applies to all implementations of Collection, such as ArrayList and HashSet.

Answer

List.remove(int) removes element at index and returns the removed element.

Answer

Collection.remove(Object) removes all occurrences of the element.

Answer

Both B and C

Question 5

Given: Map map = new HashMap<>(); map.put(1, "one"); map.put(2, "two"); map.entrySet().stream().filter(e -> e.getKey() > 1).forEach(System.out::print); What is output?

Accepted Answer

2=two. The filter(e -> e.getKey() > 1) retains only the entry with key 2, which is "2=two". The forEach(System.out::print) prints that entry without a newline, so the output is "2=two". Option D is correct.

Answer

2=two1=one

Answer

1=one2=two

Answer

No output

Question 6

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

Accepted Answer

It allows null values.. Option A is correct because HashMap permits null values: you can store any number of null values under different keys, and get() returns null for absent keys as well as for keys mapped to null. Option D is correct because HashMap allows exactly one null key (stored in bucket 0), so put(null, value) is legal and get(null) retrieves it. Option B is wrong because HashMap resolves collisions with linked lists (and converts a bucket to a red-black tree only when it exceeds the TREEIFY_THRESHOLD of 8 with capacity ≥ 64), so red-black trees are not its general collision-resolution mechanism. Option C is wrong because HashMap makes no ordering guarantee — use LinkedHashMap for insertion order or TreeMap for sorted order. Option E is wrong because HashMap is not thread-safe; concurrent modification can corrupt it, so you need Collections.synchronizedMap or ConcurrentHashMap.

Answer

It uses red-black trees for collision resolution.

Answer

It guarantees insertion order.

Answer

It is thread-safe.

Question 7

A developer writes the following code using Java 17: List list = new ArrayList<>(); list.add("A"); list.add("B"); list.add(10); What is the result?

Accepted Answer

Compilation error. The code attempts to add an integer (10) to a `List`, which is a compile-time type mismatch. Java's generics enforce type safety at compile time, so adding an `int` (autoboxed to `Integer`) to a `List` results in a compilation error. The code will not compile, and no runtime execution occurs.

Answer

The code compiles and runs successfully

Answer

ClassCastException at runtime

Answer

Compiler warning, but runs with unchecked operation

Question 8

A team uses a TreeSet with a custom Comparable that returns 0 for objects that are not logically equal (e.g., based on one field but objects differ in another). What is the likely outcome when adding such objects?

Accepted Answer

The second object is not added because TreeSet considers it a duplicate. TreeSet uses the compareTo() method of the Comparable interface (or Comparator) to determine ordering and equality. When compareTo() returns 0 for two objects that are not logically equal (e.g., they share the same field used in comparison but differ in other fields), TreeSet treats them as duplicates and does not add the second object. This is because TreeSet relies on the comparison result, not the equals() method, for uniqueness.

Answer

The second object replaces the first

Answer

A ClassCastException is thrown

Answer

Both objects are added and insertion order is preserved

Question 9

A developer creates an unmodifiable list via Collections.unmodifiableList(originalList). Later, originalList is modified by adding an element. Which statement is true?

Accepted Answer

The unmodifiable list reflects the addition. D is correct because `Collections.unmodifiableList()` returns a view-backed unmodifiable list that reflects any changes made to the original list. The unmodifiable list does not create a snapshot; it wraps the original list, so modifications to the original are visible through the unmodifiable wrapper.

Answer

The unmodifiable list remains unchanged

Answer

The unmodifiable list becomes inconsistent

Answer

An UnsupportedOperationException is thrown

Question 10

Given: var list = List.of("A", "B", "C"); list.set(0, "Z"); What is the result?

Accepted Answer

An UnsupportedOperationException is thrown. The `List.of()` method returns an immutable list, meaning its elements cannot be added, removed, or replaced. Calling `set()` on an immutable list throws an `UnsupportedOperationException` at runtime, which is why option B is correct.

Answer

An ArrayIndexOutOfBoundsException is thrown

Answer

The code does not compile because var cannot be used with List.of

Answer

The list is modified to [Z, B, C]

Question 11

Examine the code: List list = new ArrayList<>(); list.add("A"); list.add("B"); for (String s : list) { list.remove(s); } What is the outcome?

Accepted Answer

A ConcurrentModificationException is thrown. The for-each loop internally uses an Iterator to traverse the list. When the list is structurally modified (via `list.remove()`) during iteration without using the iterator's own `remove()` method, the iterator detects a concurrent modification and throws a `ConcurrentModificationException`. This is a fail-fast behavior of the `ArrayList` iterator.

Answer

The loop completes successfully and list becomes empty

Answer

An IllegalStateException is thrown

Answer

The loop completes successfully and list contains [B]

Question 12

A HashMap uses a mutable object as a key. After adding the key-value pair, the key's fields are changed such that its hashCode changes. Which statement is true?

Accepted Answer

The value may not be retrievable using the modified key. When a HashMap uses a mutable object as a key and the key's hashCode changes after insertion, the key is stored in the bucket corresponding to its original hash code. The modified key's new hash code will likely map to a different bucket during retrieval, so the value may not be found. Option B is correct because the value may not be retrievable using the modified key, depending on whether the new hash code leads to the same bucket and whether equals() still matches.

Answer

The value can still be retrieved using the modified key

Answer

The entry is automatically moved to the correct bucket

Answer

An IllegalArgumentException is thrown when modifying the key

Question 13

Consider: List<String> list = Arrays.asList("A", "B", "C"); list.add("D"); What is the result?

Accepted Answer

An UnsupportedOperationException is thrown. The `Arrays.asList()` method returns a fixed-size list backed by the specified array. This list does not support structural modification operations like `add()` or `remove()`. Calling `add()` on such a list throws an `UnsupportedOperationException` at runtime.

Answer

An ArrayIndexOutOfBoundsException is thrown

Answer

The list becomes [A, B, C, D]

Answer

A ClassCastException is thrown

Question 14

Which TWO statements are true about ArrayList in Java 17? (Choose two.)

Accepted Answer

It implements the List interface. Option A is correct because java.util.ArrayList implements the java.util.List interface, giving it ordered, index-based access and allowing duplicates. Option D is correct because ArrayList extends java.util.AbstractList, which provides a skeletal implementation of the List interface and supplies much of the backing behavior for ArrayList. Option B is incorrect because ArrayList does not implement Set, which by contract forbids duplicate elements. Option C is incorrect because ArrayList does not implement Queue; Queue implementations include LinkedList, ArrayDeque, and PriorityQueue. Option E is incorrect because ArrayList is not synchronized; synchronization must be added externally, for example via Collections.synchronizedList, or by using CopyOnWriteArrayList.

Answer

It implements the Set interface

Answer

It implements the Queue interface

Answer

It is synchronized

Question 15

Which THREE statements are true about HashSet in Java 17? (Choose three.)

Accepted Answer

Does not maintain insertion order. Option A is correct because HashSet is backed by a HashMap and does not preserve insertion order; iteration order is unspecified and can change as elements are added or removed. Option D is correct because HashSet offers constant-time (O(1)) average performance for basic operations such as add, remove, and contains, assuming a well-distributed hash function. Option E is correct because HashSet permits at most one null element, since it stores elements as keys in the underlying HashMap and duplicate keys are not allowed. Option B is incorrect because HashSet does not allow duplicate elements; adding an existing element leaves the set unchanged. Option C is incorrect because HashSet is not thread-safe; concurrent modification requires external synchronization or a wrapper such as Collections.synchronizedSet.

Answer

Allows duplicate elements

Answer

Is thread-safe