1Z0-829 Practice Test 24 — 15 Questions

Question 1

Given: int i=0; outer: while(i<3) { for(int j=0; j<3; j++) { if(j==1) break outer; } i++; } What is the value of i after the outer loop?

Accepted Answer

0. (0) because the `break outer` statement immediately terminates the outer `while` loop when `j` equals 1 during the first iteration of the inner `for` loop. Since `i` is incremented only after the inner loop completes, and the inner loop never finishes its first iteration, `i` remains 0.

Answer

1

Answer

2

Answer

3

Question 2

A developer wants to count how many strings in a list have length greater than 5. Which is the correct implementation?

Accepted Answer

list.stream().filter(s -> s.length() > 5).count(). The Stream API provides the `filter` method to select elements matching a predicate, and `count` returns the number of elements in the resulting stream. This directly counts strings with length greater than 5 without needing any intermediate mapping or collection.

Answer

list.stream().mapToLong(s -> s.length() > 5).sum()

Answer

list.stream().count(s -> s.length() > 5)

Answer

list.stream().collect(Collectors.counting(s -> s.length() > 5))

Question 3

A developer needs to compile and execute a Java application on a server. Which of the following environments is sufficient to perform both tasks?

Accepted Answer

JDK only. The JDK (Java Development Kit) includes both the javac compiler for compiling source code into bytecode and the java runtime launcher (JRE) for executing that bytecode. The JRE alone provides only the runtime environment (JVM, core libraries) and cannot compile Java source files. Therefore, the JDK is sufficient for both compiling and executing, while the JRE is not.

Answer

Both JDK and JRE

Answer

Neither JDK nor JRE

Answer

JRE only

Question 4

A developer creates a module `com.example.app` that requires `java.sql` and `com.example.util`. The module is compiled and packaged into a JAR. When launching the application with `java --module-path app.jar:lib --module com.example.app`, it fails with `java.lang.module.ResolutionException: Module com.example.util not found`. What is the most likely cause?

Accepted Answer

The module `com.example.util` is not in the module path.. The error `Module com.example.util not found` indicates that the module system cannot locate `com.example.util` on the module path. Since the command specifies `--module-path app.jar:lib`, the JAR for `com.example.util` must be present in the `lib` directory (or another directory on that path). If it is missing or not in the correct location, the module resolution fails. Option B correctly identifies that the module is simply not on the module path.

Answer

The module `com.example.util` is an automatic module and requires specific flags.

Answer

The module `com.example.util` is a named module but not exported.

Answer

The module `com.example.util` is on the classpath and not visible to module system.

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

A developer needs to filter a list of transactions where the amount is greater than 100 and collect the results into a new list. Which approach is best practice for readability and performance?

Accepted Answer

transactions.stream().filter(t -> t.getAmount() > 100).collect(Collectors.toList()). It uses the Stream API's `filter` method to declaratively select transactions with an amount greater than 100, and `collect(Collectors.toList())` to gather results into a new list. This approach is both readable and performant, leveraging lazy evaluation and internal iteration for efficient processing.

Answer

List result = new ArrayList<>(); for(Transaction t : transactions) { if(t.getAmount() > 100) result.add(t); }

Answer

transactions.stream().filter(t -> t.getAmount() > 100).toArray()

Answer

transactions.removeIf(t -> t.getAmount() <= 100)

Question 7

Given the following Java code:

```java
for (int i = 0; i <= 2; i++) {
    for (int j = i; j <= i+2; j++) {
        if (j <= 3) {
            System.out.print(j + " ");
        }
    }
}
```

What is the output?

Accepted Answer

0 1 2 1 2 3 2 3. The program uses nested for loops. The outer loop iterates i from 0 to 2 (inclusive). For each i, the inner loop iterates j from i to i+2 (inclusive), but due to a condition that prevents printing values greater than 3, the inner loop effectively prints j only up to 3. Thus, for i=0 it prints 0,1,2; for i=1 it prints 1,2,3; for i=2 it prints 2,3. Combined on one line, the output is '0 1 2 1 2 3 2 3', which corresponds to option B.

Answer

0 1 2 1 2 3 2 3 4

Answer

0 1 2 1 2 3 2 3 4 5

Answer

0 1 2 1 2 3 2 3 3 4

Question 8

A method contains a try-with-resources statement that uses two resources: a FileInputStream and a BufferedInputStream. The FileInputStream constructor throws a FileNotFoundException. Which statement about resource closing is true?

Accepted Answer

No resources are closed because the FileInputStream constructor failed before any resource was opened.. In a try-with-resources statement, resources are closed only if they have been successfully initialized. If the FileInputStream constructor throws a FileNotFoundException, the resource is never created, so the try-with-resources statement does not attempt to close it. The BufferedInputStream is never constructed because the exception occurs before its declaration is reached, so no resources are opened and none need to be closed. Therefore, option C is correct.

Answer

The BufferedInputStream is closed if it was successfully created, but the FileInputStream is not.

Answer

Both resources are closed even if the FileInputStream constructor throws an exception.

Answer

The programmer must explicitly close the resources in a finally block.

Question 9

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 10

Which TWO statements about the try-with-resources statement are true? (Choose two.)

Accepted Answer

Resources declared in the try-with-resources block are closed automatically.. Option C is correct because the defining purpose of try-with-resources is that any resource declared in the try header is automatically closed when the try block exits, whether normally or via an exception, without requiring an explicit finally block. Option D is correct because when multiple resources are declared, the compiler generates closing logic that closes them in the reverse order of declaration (last declared, first closed), which matters when resources depend on one another. Option A is not strictly true because resources need only implement AutoCloseable (Closeable is a narrower subinterface), so the statement is too restrictive. Option B is false because resource variables declared in the try header are implicitly final and cannot be reassigned inside the try block. Option E is false because multiple resources are separated by semicolons, not commas.

Answer

The resources must implement the Closeable interface.

Answer

Resources can be reassigned inside the try block.

Answer

Multiple resources are separated by commas.

Question 11

Which TWO statements about the Stream API are correct? (Choose two.)
A. A stream can be traversed multiple times.
B. The peek() method is an intermediate operation.
C. The findFirst() method returns an Optional.
D. The collect() method is an intermediate operation.
E. The map() method returns a stream of the same type.

Accepted Answer

The peek() method is an intermediate operation.. Option B is correct because peek() is an intermediate operation in the java.util.stream API: it returns a new Stream, is lazy, and is typically used for debugging to inspect elements as they flow through the pipeline. Option C is correct because findFirst() is a short-circuiting terminal operation that returns Optional, wrapping the first element of the stream or an empty Optional if the stream is empty. Option A is incorrect because a stream is single-use: once a terminal operation is invoked, the stream is consumed and any attempt to traverse it again throws IllegalStateException. Option D is incorrect because collect() is a terminal operation that triggers pipeline execution and reduces the stream into a result container such as a List or Set, not an intermediate operation. Option E is incorrect because map() is a stateless intermediate operation that transforms each element via a Function and returns a Stream whose element type may differ from the source stream's type.

Answer

A stream can be traversed multiple times.

Answer

The collect() method is an intermediate operation.

Answer

The map() method returns a stream of the same type.

Question 12

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 13

A developer is writing a method that reads a file and processes its content. The method must ensure that if an IOException occurs during reading, the method throws a custom ApplicationException that wraps the original IOException, and that any resources opened are closed properly. Which approach correctly implements this requirement?

Accepted Answer

try (BufferedReader reader = Files.newBufferedReader(path)) { ... } catch (IOException e) { throw new ApplicationException(e); }. It uses a try-with-resources statement, which automatically closes the BufferedReader (which implements AutoCloseable) when the block exits, whether normally or exceptionally. The catch clause then catches any IOException and wraps it in a custom ApplicationException, satisfying both the resource-closing and exception-wrapping requirements without manual cleanup.

Answer

try { ... } catch (IOException e) { System.err.println(e); } finally { reader.close(); }

Answer

catch (Exception e) { throw new ApplicationException(e); } finally { reader.close(); }

Answer

try { ... reader.close(); } catch (IOException e) { throw new ApplicationException(e); }

Question 14

Given an exception chain where a custom exception is created with a cause, which method is used to set the cause after construction?

Accepted Answer

initCause(Throwable). `initCause(Throwable)` is the method provided by the `Throwable` class to set the cause of an exception after the exception has been constructed. This is useful when the exception must be created without a cause (e.g., via a no-arg constructor) and the cause is determined later. The cause can only be set once; a second call will throw an `IllegalStateException`.

Answer

The cause can only be set via constructor.

Answer

setCause(Throwable)

Answer

addSuppressed(Throwable)

Question 15

Which TWO of the following are terminal operations on a stream? (Choose two.)

Accepted Answer

forEach. forEach (A) is a terminal operation because it consumes each element of the stream and returns void, triggering the pipeline's execution and closing the stream. reduce (C) is also terminal: it performs a reduction on the stream's elements (e.g., using an identity and BinaryOperator or an Optional-returning variant) and produces a single result, thereby ending the stream. By contrast, distinct (B), filter (D), and map (E) are intermediate operations—they return a new lazy stream and only build up the pipeline, so they do not execute it or produce a final result on their own.

Answer

distinct

Answer

filter

Answer

map