1Z0-829 Practice Test 22 — 15 Questions

Question 1

Which of the following correctly describes the behavior of the following code? List<String> 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 2

Which is true about CopyOnWriteArrayList?

Accepted Answer

Modifications are expensive as they create a new array.. CopyOnWriteArrayList is a thread-safe variant of ArrayList where all mutative operations (add, set, remove, etc.) are implemented by making a fresh copy of the underlying array. This design makes modifications expensive because each modification requires copying the entire array, but it provides safe iteration without locking. Option C correctly identifies that modifications are expensive due to the array copy.

Answer

It is not thread-safe.

Answer

Iterators reflect concurrent modifications.

Answer

It is optimized for frequent modifications.

Question 3

What will be the result of the following code?
Object[] arr = new Integer[5];
arr[0] = "String";

Accepted Answer

ArrayStoreException at runtime. The code creates an array of type `Integer[]` referenced by an `Object[]` variable. At runtime, the array's actual component type is `Integer`, so attempting to store a `String` violates the array's type constraint and throws an `ArrayStoreException`.

Answer

Successfully stores "String"

Answer

Compilation error

Answer

ClassCastException

Question 4

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

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 6

Which of the following correctly sorts an array of integers (int[] arr) in descending order?

Accepted Answer

Integer[] boxed = Arrays.stream(arr).boxed().toArray(Integer[]::new); Arrays.sort(boxed, Collections.reverseOrder()); arr = Arrays.stream(boxed).mapToInt(i->i).toArray();. Option A is correct because it demonstrates the proper technique for sorting a primitive int array in descending order. The `Arrays.sort()` method does not accept a `Comparator` for primitive arrays, so the array must first be boxed into an `Integer[]` using `Arrays.stream(arr).boxed().toArray(Integer[]::new)`. After sorting with `Collections.reverseOrder()`, the result is unboxed back to `int[]` via `mapToInt(i->i).toArray()`. This approach correctly leverages the `Comparator` interface, which only works with object types.

Answer

Arrays.sort(arr, Collections.reverseOrder());

Answer

None of the above, because primitive arrays cannot be sorted in descending order.

Answer

Arrays.sort(arr, (a,b) -> b - a);

Answer

Arrays.parallelSort(arr, (a,b) -> b - a);

Question 7

Given the code snippet: List list = new ArrayList<>(List.of("A","B","C")); list.add("D"); System.out.println(list.size()); What is the result?

Accepted Answer

4. Option C is correct because the code creates an ArrayList from a fixed-size list returned by List.of() using the ArrayList constructor, which creates a new mutable list containing the elements "A", "B", "C". The subsequent call to list.add("D") successfully appends the element, resulting in a list of size 4. The ArrayList constructor copies the elements, so the original immutable list is not modified.

Answer

5

Answer

UnsupportedOperationException

Answer

Compilation fails

Answer

3

Question 8

Which TWO of the following will sort a List<String> in natural (ascending) order?

Accepted Answer

list.sort(Comparator.naturalOrder());. Option A is correct because `Comparator.naturalOrder()` returns a comparator that imposes the natural (ascending) ordering on `String` objects, which is lexicographic order based on Unicode values. The `List.sort()` method accepts this comparator and sorts the list in place, making it a concise and idiomatic way to sort a list in ascending order.

Answer

list.sort((a,b) -> b.compareTo(a));

Answer

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

Answer

Arrays.sort(list);

Question 9

Given the above Java version, which of the following is NOT a standard Java 17 feature?

Accepted Answer

Pattern matching for switch (preview). Option D is correct because pattern matching for switch is a preview feature in Java 17, not a standard feature. It was introduced as a preview under JEP 406 and requires the --enable-preview flag to be used. Standard features in Java 17 are finalized and do not require any preview flags.

Answer

All of the above are standard

Answer

Sealed classes

Answer

Text blocks

Answer

Records

Question 10

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 11

Which TWO of the following statements about the Collections framework are true?

Accepted Answer

Collections.unmodifiableList returns an unmodifiable view of the list.. Option B is correct because `Collections.unmodifiableList()` returns a view of the specified list that cannot be modified. Any attempt to modify the returned list (e.g., add, remove, set) will throw an `UnsupportedOperationException`. This is a standard method in the Java Collections Framework to provide read-only access to a list.

Answer

Collections.checkedList performs type checking at compile time.

Answer

List.of returns a mutable list.

Answer

Arrays.asList returns a mutable list of variable size.

Question 12

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 13

Refer to the exhibit. What is the output?

Accepted Answer

true. Option D is correct because the code uses `Boolean.valueOf(true)` which returns the `Boolean` constant `Boolean.TRUE`, and `Boolean.TRUE` is a singleton object that is `==` to itself. The `==` operator compares object references, not values, so the comparison `Boolean.valueOf(true) == Boolean.TRUE` evaluates to `true` because both refer to the same cached `Boolean` instance from the `Boolean` class's static final fields.

Answer

compile error

Answer

null

Answer

false

Question 14

What is the output of the above code?

Accepted Answer

[a, c]. The code uses `List.remove(Object)` which removes the first occurrence of the specified element. After removing "b" from the list [a, b, c], the list becomes [a, c]. Option B is correct because the output is [a, c].

Answer

[a, b]

Answer

[a, b, c]

Answer

[b, c]

Answer

Compilation fails