1Z0-829 Practice Test 20 — 15 Questions

Question 1

A developer needs to iterate over a List<String> and remove elements that are null. Which approach guarantees correct behavior without throwing a ConcurrentModificationException?

Accepted Answer

Use an Iterator explicitly and call its remove() method. Iterator.remove() is the safe and recommended way to remove elements during iteration, avoiding ConcurrentModificationException. Option A is incorrect because using list.remove() inside a for-each loop modifies the list directly while iterating, causing ConcurrentModificationException. Option B is incorrect because Stream.filter() does not modify the original list; it creates a new list, which may not meet the requirement to remove elements from the original. Option C is incorrect because although a decrementing for loop may work, it is error-prone and not the guaranteed approach; it is not the idiomatic Java solution.

Answer

Use a for-each loop and call list.remove() on the current element

Answer

Use a Stream's filter() method and collect the results

Answer

Use a traditional for loop with an index that decrements

Question 2

A Java 17 application uses the Java Platform Module System (JPMS). The module 'com.example.service' exports 'com.example.service.api' and requires 'java.logging'. Another module 'com.example.client' requires 'com.example.service'. The client module cannot access the 'com.example.service.api' package. What is the most likely reason?

Accepted Answer

The 'com.example.service.api' package is not exported by 'com.example.service'.. The stem states that the 'com.example.service' module exports 'com.example.service.api', but the most likely reason the client cannot access the package is that the package is not actually exported in the module's module-info.java. In JPMS, a module must explicitly export a package for it to be accessible to other modules. Without an exports directive, other modules cannot access the package even if they have a 'requires' directive. Option C is incorrect because the stem explicitly states that the client requires the service module. Options A and D are not directly related to the client's inability to access the package.

Answer

The 'com.example.service' module does not use 'requires transitive' for 'java.logging'.

Answer

The 'com.example.client' module does not contain a 'requires com.example.service' directive.

Answer

The 'java.logging' module does not export its packages to 'com.example.service'.

Question 3

Which THREE are valid ways to read the contents of a text file into a String in Java?

Accepted Answer

String content = Files.readString(Path.of("file.txt"));. `Files.readString()` (introduced in Java 11) reads the entire content of a text file into a `String` in one call, handling charset encoding (default UTF-8) and closing the file automatically. It is the simplest and most direct method for this task.

Answer

String content = new FileReader("file.txt").readString();

Answer

String content = Files.readAllLines(Path.of("file.txt"));

Question 4

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 5

Given a list of strings, which of the following will produce a Map<String, Long> counting the occurrences of each string?

Accepted Answer

.collect(Collectors.groupingBy(Function.identity(), Collectors.counting())). `Collectors.groupingBy(Function.identity(), Collectors.counting())` groups each string by itself (using `Function.identity()` as the classifier) and then applies a downstream collector `Collectors.counting()` that counts the number of elements in each group, producing a `Map<String, Long>` where each key is a unique string and the value is its frequency.

Answer

.collect(Collectors.toMap(Function.identity(), String::length))

Answer

.collect(Collectors.groupingBy(Function.identity(), Collectors.summingInt(e->1)))

Answer

.collect(Collectors.toMap(Function.identity(), v->1))

Question 6

Which TWO statements about try-with-resources are correct? (Choose two.)

Accepted Answer

Resources are closed in the reverse order of their declaration.. The Java Language Specification (JLS §14.20.3) mandates that resources declared in a try-with-resources statement are closed in the reverse order of their declaration. This ensures that if a resource depends on another declared earlier, the dependent resource is closed first, preventing resource leaks or inconsistent states.

Answer

Resources are closed in the same order as their declaration.

Answer

Resources declared in try-with-resources must implement the Closeable interface.

Answer

Resources declared earlier in the try clause are closed first.

Question 7

A developer is implementing a method that processes a collection of objects. The objects are instances of various classes that implement a common interface. The developer wants to use a switch expression to perform different actions based on the runtime type of each object. Which approach is correct?

Accepted Answer

Use a switch expression with pattern matching without a default case if all possible types are covered.. Java 17+ switch expressions with pattern matching allow exhaustive type coverage without a default case when all possible subtypes of the sealed interface or hierarchy are explicitly listed. This ensures compile-time safety and eliminates the need for a default branch, aligning with the principle of exhaustive pattern matching.

Answer

Use a series of if-else statements with instanceof.

Answer

Use a switch expression with pattern matching and a default case.

Answer

Use a traditional switch statement with instanceof checks and casting.

Question 8

Refer to the exhibit. What is the output?

Accepted Answer

185. (185). The stream filters out all numbers less than 10 using the predicate `n -> n < 10`, resulting in the numbers 10, 20, 30, 40, 50, and 35. The reduce operation then sums these numbers using `Integer::sum`, yielding 185. The initial value is 0, so the sum is accurate.

Answer

270

Answer

95

Answer

90

Question 9

A developer writes a stream pipeline that uses flatMap and filter but notices that the intermediate streams created by flatMap are never garbage-collected early, causing memory pressure. What is the most effective optimization to reduce memory usage?

Accepted Answer

Move the filter operation before the flatMap operation.. Moving the filter operation before flatMap reduces the number of elements passed to flatMap, thereby reducing the number of intermediate streams created and their memory footprint. Streams are lazy, so filter applied early discards unwanted elements before flatMap ever sees them, which directly lowers memory pressure from intermediate stream objects.

Answer

Replace flatMap with map and collect into a list.

Answer

Use a terminal operation like collect with a custom collector to process elements eagerly.

Answer

Use a parallel stream to process elements concurrently.

Question 10

A developer wants to find the longest word in a list of strings. Which stream operation should be used?

Accepted Answer

stream().max(Comparator.comparingInt(String::length)). The `max()` terminal operation, when combined with a `Comparator` that compares strings by their length, returns the longest word in the stream. The `max()` operation uses the provided comparator to determine the 'largest' element according to the ordering, which in this case is the string with the greatest length.

Answer

stream().sorted(Comparator.comparingInt(String::length).reversed()).findFirst()

Answer

stream().min(Comparator.comparingInt(String::length))

Answer

stream().sorted(Comparator.comparingInt(String::length)).findFirst()

Question 11

Refer to the exhibit. What is the result?

Accepted Answer

IllegalStateException. The code attempts to call `findAny()` on a `Stream` that has already been consumed by a terminal operation (`forEach`). Once a terminal operation is executed on a stream, the stream is closed and cannot be reused. Any subsequent call to a terminal operation on the same stream reference throws `IllegalStateException`. Option C is correct because the second terminal operation violates the single-use contract of streams.

Answer

abc

Answer

NullPointerException

Answer

abcabc

Question 12

What is the output of the following code?

```java
int i = 5;
while (i > 0) {
    System.out.print(i + " ");
    i--;
}
```

Accepted Answer

5 4 3 2 1. The while loop runs as long as i > 0. Starting with i = 5, each iteration prints the current value of i followed by a space, then decrements i by 1. The loop stops when i becomes 0, so the output is '5 4 3 2 1 '.

Answer

The code does not compile because i is not declared final.

Answer

5 4 3 2

Answer

4 3 2 1

Question 13

A stream pipeline filters strings, sorts them, and returns the first match: .filter(s -> s.length() > 3).sorted().findFirst(). This is inefficient because sorted() processes all elements. Which alternative achieves the same result with better performance?

Accepted Answer

.filter(s -> s.length() > 3).min(Comparator.naturalOrder()). `min(Comparator.naturalOrder())` is a terminal operation that finds the smallest element according to natural ordering without sorting the entire stream. It uses a single pass reduction, which is O(n) in time complexity, whereas `sorted().findFirst()` must sort all elements (O(n log n)) before picking the first. This makes `min()` significantly more efficient for this use case.

Answer

.filter(s -> s.length() > 3).sorted().limit(1).findFirst()

Answer

.filter(s -> s.length() > 3).parallel().sorted().findFirst()

Answer

.filter(s -> s.length() > 3).sorted().collect(Collectors.toList()).get(0)