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

Question 1

Which of the following collections maintains elements in the order they were inserted?

Accepted Answer

LinkedHashSet. LinkedHashSet maintains a doubly-linked list running through all of its entries, which defines the iteration ordering as the order in which elements were inserted into the set. This is specified in the Java documentation for LinkedHashSet, making it the only collection among the options that guarantees insertion order.

Answer

None of the above

Answer

PriorityQueue

Answer

HashSet

Answer

TreeSet

Question 2

Given: TreeSet set = new TreeSet<>(List.of(3,1,2)); set.add(2); System.out.println(set); What is the output?

Accepted Answer

[1,2,3]. E is correct because TreeSet maintains elements in their natural sorted order (ascending for integers). The list [3,1,2] is sorted to [1,2,3], and adding 2 again has no effect since TreeSet does not allow duplicates. The output is [1,2,3].

Answer

[1,2]

Answer

[1,3,2]

Answer

[3,1,2]

Answer

UnsupportedOperationException

Question 3

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 4

What does the following code print? List list = new ArrayList<>(List.of(1,2,3)); list.replaceAll(x -> x * 2); System.out.println(list);

Accepted Answer

[2,4,6]. The `replaceAll` method on a `List` applies the given `UnaryOperator` to each element, replacing it with the result. Here, `x -> x * 2` multiplies each integer by 2, so the list becomes `[2, 4, 6]`. Option B is correct because the code compiles and runs, producing that output.

Answer

[2,3,4]

Answer

Compilation fails

Answer

[1,4,9]

Answer

[1,2,3]

Question 5

Which of the following creates an immutable map with two entries?

Accepted Answer

Map.of("a",1,"b",2). `Map.of()` returns an immutable map containing exactly the key-value pairs provided as arguments. This factory method was introduced in Java 9 and creates a fixed-size, unmodifiable map with the two entries "a"→1 and "b"→2.

Answer

new HashMap<>(Map.of("a",1,"b",2))

Answer

Collections.emptyMap()

Answer

None of the above

Answer

new HashMap<>()

Question 6

Given: Set set = new HashSet<>(List.of(1,2,3)); List list = new ArrayList<>(set); Collections.sort(list); System.out.println(list); What is the output?

Accepted Answer

[1,2,3]. The code creates a HashSet from a List of 1, 2, 3, then copies it into an ArrayList. HashSet does not guarantee order, but Collections.sort() sorts the list in natural ascending order (1, 2, 3). The output is [1,2,3], making option C correct.

Answer

[3,2,1]

Answer

Compilation fails

Answer

[1,2]

Answer

[1,3,2]

Question 7

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 8

Which of the following correctly converts an array of strings to a List?

Accepted Answer

Arrays.asList(array) returns a fixed-size list backed by the array.. `Arrays.asList(array)` returns a fixed-size list backed by the original array, meaning changes to the list (like `set`) reflect in the array, but structural modifications (like `add` or `remove`) throw `UnsupportedOperationException`. This is the standard, exam-relevant way to convert an array to a List in Java.

Answer

Collections.toList(array) converts the array.

Answer

List.of(array) returns a mutable list.

Answer

Arrays.asList(array) returns a new ArrayList with a copy of the elements.

Question 9

Given ArrayList numbers = new ArrayList<>(List.of(1,2,3,4)); Which statement will insert element 10 at index 2?

Accepted Answer

numbers.add(2,10);. The `ArrayList.add(int index, E element)` method inserts the specified element at the given index, shifting existing elements to the right. Here, `numbers.add(2,10)` inserts 10 at index 2, resulting in the list [1,2,10,3,4].

Answer

numbers.add(10,2);

Answer

numbers.set(2,10);

Answer

numbers.insert(2,10);

Question 10

A TreeSet<String> is used to store a list of employee names. The set currently contains "Alice", "Bob", "Charlie". What is the output after calling set.add("Bob")?

Accepted Answer

false. A TreeSet implements the Set interface, which does not allow duplicate elements. When calling add("Bob") on a TreeSet that already contains "Bob", the add method returns false, indicating that the element was not added, and the set remains unchanged.

Answer

Exception

Answer

The set becomes ["Alice","Bob","Bob","Charlie"]

Answer

true

Question 11

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 12

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 13

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 14

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 15

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