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

Question 1

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

Accepted Answer

It returns a fixed-size list backed by the original array.. `Arrays.asList()` returns a fixed-size list backed by the original array, meaning the list's size cannot be changed (no add or remove operations allowed). Option E is correct because any modification to the returned list (e.g., setting an element) directly modifies the underlying array, and vice versa, as the list is a view of the array.

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 2

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)). `Arrays.asList(1,2,3)` returns a fixed-size `List`, and passing it to the `ArrayList` constructor creates a new, mutable `ArrayList` containing the same elements. This is a standard way to initialize an `ArrayList` with known values.

Answer

new ArrayList<>(10, 20, 30)

Answer

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

Question 3

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

Accepted Answer

It allows null values.. HashMap allows null values; you can store null as a value for any key, including null keys. This is explicitly permitted by the HashMap specification, which does not restrict value types.

Answer

It uses red-black trees for collision resolution.

Answer

It guarantees insertion order.

Answer

It is thread-safe.

Question 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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

Accepted Answer

It implements the List interface. ArrayList implements the List interface, which is a core part of the Java Collections Framework. This allows ArrayList to be used polymorphically wherever a List is expected, providing ordered, index-based access to elements.

Answer

It implements the Set interface

Answer

It implements the Queue interface

Answer

It is synchronized

Question 12

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"))). `Collections.unmodifiableList()` wraps a mutable list in an unmodifiable view, preventing any structural modifications. Option D is correct because `List.copyOf()` creates an immutable list from an existing collection, throwing `NullPointerException` if any element is null. Both produce lists that cannot be modified after creation.

Answer

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

Answer

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

Answer

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