1Z0-829 Practice Test 15 — 15 Questions

Question 1

A developer has a Stream<String> named words and writes the following pipeline:

String out = words
    .filter(w -> w.length() > 3)
    .findFirst()
    .orElse("none");

Later the same Stream reference words is passed to a second pipeline. What is the result?

Accepted Answer

The second pipeline throws IllegalStateException because a stream cannot be reused after a terminal operation has been invoked on it.. A Stream instance is consumed by its terminal operation and cannot be reused. Calling a second pipeline on the same reference triggers IllegalStateException when that pipeline's terminal operation runs. The fix is to obtain a fresh stream, for example by calling words' source collection's stream method again or by using a Supplier>.

Answer

The second pipeline compiles but returns an empty Optional because the stream is automatically reset to its initial state.

Answer

The second pipeline only fails if it is a parallel stream; sequential streams may be reused any number of times.

Answer

The second pipeline executes normally and re-reads the original source because Stream is backed by the collection and can be re-traversed.

Question 2

A developer writes the following code: var list = new ArrayList<>(List.of(3, 1, 2)); Collections.sort(list); System.out.println(list); What is the output?

Accepted Answer

[1, 2, 3]. The ArrayList constructor creates a mutable copy of the elements from the immutable list. Collections.sort then sorts this mutable list in place using natural ordering. The output is the sorted list [1, 2, 3]. The immutability of the original List.of result does not affect the new ArrayList.

Answer

An UnsupportedOperationException is thrown at runtime.

Answer

[3, 1, 2]

Answer

Compilation fails because List.of returns an immutable list that cannot be sorted.

Question 3

A team is designing a logging framework. The framework's core method log(String message) may throw a checked LogException if the logging system fails. The team wants to allow callers to choose whether to handle the exception or declare it as thrown. Which declaration of the log method satisfies this requirement?

Accepted Answer

public void log(String message) throws LogException { ... }. It declares the checked exception LogException in the throws clause, which forces callers to either handle it with a try-catch or propagate it by declaring throws in their own method. This satisfies the requirement that callers can choose how to deal with the exception, as checked exceptions must be acknowledged at compile time.

Answer

public void log(String message) { ... }

Answer

public void log(String message) throws Error { ... }

Answer

public void log(String message) throws RuntimeException { ... }

Question 4

A developer writes a method that must remove all even numbers from a List<Integer> while iterating. Which TWO approaches correctly avoid a ConcurrentModificationException? (Choose two.)

Accepted Answer

Use an Iterator<Integer> obtained from the list and call iterator.remove() after each matching next().. Iterator.remove and Collection.removeIf both remove elements through the iterator's own mechanism, which keeps the modification count consistent and prevents the fail-fast check from firing. The enhanced for loop offers no access to that iterator, and plain index-based removal without index adjustment skips elements. Clearing the whole list is simply incorrect for selective removal.

Answer

Iterate with the enhanced for loop and call list.clear() after the loop finishes.

Answer

Use a traditional index-based for loop and call list.remove(i) each time an even element is found, without adjusting the index.

Answer

Iterate with an enhanced for loop and call list.remove(n) whenever the current element is even.

Question 5

A developer writes the following pipeline to find the first even number greater than 100 in an infinite stream:

Optional<Integer> result = Stream.iterate(1, n -> n + 1)
    .filter(n -> n % 2 == 0 && n > 100)
    .findFirst();

What happens when this code runs?

Accepted Answer

It returns Optional.of(102) because findFirst short-circuits the infinite stream once the filter matches.. Stream.iterate with a seed and unary operator produces an infinite sequential ordered stream. Because filter is lazy and findFirst is a short-circuiting terminal operation, the pipeline evaluates elements on demand and stops at the first match. The first even number greater than 100 is 102, so the result is Optional.of(102). The other options incorrectly claim hanging, an exception, or a bounded prefix, none of which apply when a short-circuiting operation is present.

Answer

It returns Optional.empty() because findFirst only examines a bounded prefix of the stream by default.

Answer

It hangs indefinitely because Stream.iterate creates an infinite stream and findFirst cannot determine when to stop.

Answer

It throws IllegalStateException because an infinite stream cannot be used with a terminal operation.

Question 6

A developer is packaging a Java 17 application as a modular JAR. The module descriptor contains `exports com.acme.api;` but does not contain `opens com.acme.api;`. Another module wants to use reflection to access private fields of a class in com.acme.api at runtime. What is the result?

Accepted Answer

The reflective access to private fields fails with an InaccessibleObjectException unless the package is opened.. Strong encapsulation in the Java Platform Module System means that `exports` only exposes public types and their public members. Reflective access to private fields requires the package to be opened with the `opens` directive. Without it, the runtime throws InaccessibleObjectException, even if the module reads the target module.

Answer

The reflective access fails at compile time because private fields cannot be referenced from another module.

Answer

The reflective access succeeds because exports also allows deep reflection.

Answer

The reflective access succeeds only if the other module declares `requires transitive com.acme.api;`.

Question 7

Which THREE of the following variable declarations are valid in Java 17?

Accepted Answer

List list = new ArrayList();. Option A is valid because List is a wildcard type that can reference an ArrayList; the wildcard makes the assignment compatible with any parameterized List. Option C is valid because List accepts a List, since Number is a supertype of Integer and satisfies the lower-bounded wildcard constraint. Option D is valid because List accepts a List, since Integer is a subtype of Number and satisfies the upper-bounded wildcard constraint. Option B is invalid because generics are invariant: List

Answer

List<Object> list = new ArrayList<String>();

Answer

List list = new ArrayList();

Question 8

A developer writes a method `readConfig()` that declares `throws IOException`. In the method body, the developer writes `throw new IOException("missing")`. Which statement is true about this code?

Accepted Answer

The code compiles because `IOException` is declared in the method signature.. Declaring a checked exception in a method's `throws` clause authorizes the method body to throw that exception without catching it. The compiler only requires that every checked exception be either handled locally or declared for propagation. Since `IOException` is declared, the `throw` statement is valid and the code compiles.

Answer

The code fails to compile because `IOException` must be caught inside the method.

Answer

The code compiles only if `readConfig()` also declares `throws RuntimeException`.

Answer

The code fails to compile because `IOException` is a checked exception and cannot be instantiated directly.

Question 9

A developer is using a parallel stream to compute the sum of squares of a large list of integers:

int sum = list.parallelStream()
    .mapToInt(n -> n * n)
    .sum();

The developer notices that the result is sometimes incorrect when the list contains null values. Which statement best explains the behavior?

Accepted Answer

The pipeline throws a NullPointerException when it encounters a null, regardless of whether the stream is sequential or parallel.. The lambda n -> n * n performs unboxing of the Integer element to int. If an element is null, unboxing throws NullPointerException. This occurs in both sequential and parallel streams because the mapping function is applied to each element. The sum reduction itself is safe for parallel execution. To handle nulls, the developer must add an explicit filter such as filter(Objects::nonNull) before mapToInt.

Answer

The mapToInt operation runs in parallel but the lambda captures a shared variable, causing a data race that corrupts the sum.

Answer

The parallel stream silently skips null elements, so the sum is computed only over non-null values, leading to inconsistent results.

Answer

The sum operation is not thread-safe, so concurrent updates to the accumulator cause lost updates and incorrect totals.

Question 10

A Java 17 application must log diagnostic information when an exception occurs and also guarantee that a lock is released. Which TWO statements correctly describe the behavior of `try`, `catch`, and `finally` blocks in this context? (Choose two.)

Accepted Answer

A `finally` block executes even if the `try` block contains a `return` statement.. The `finally` block is guaranteed to execute whenever the `try` statement is exited, whether by normal completion, `return`, or an exception thrown in the `try` or `catch`. This makes it reliable for releasing locks and logging. Multi-catch and the `try`/`finally` form without `catch` are also valid, but the two correct statements here concern the guaranteed execution of `finally`.

Answer

A `try` block must always be followed by at least one `catch` block.

Answer

A `catch` block can catch multiple unrelated exception types only by using separate `catch` clauses.

Answer

The `finally` block cannot access variables declared inside the `try` block.

Question 11

Which TWO are valid ways to obtain a Stream from a List<String> named 'list'? (Choose two.)

Accepted Answer

list.stream(). Option A, list.stream(), is correct because Collection (and thus List) defines the default method stream() that returns a sequential Stream of the list's elements. Option E, list.parallelStream(), is also correct because Collection defines parallelStream(), which returns a possibly parallel Stream backed by the list. Option B, Stream.of(list), is wrong because it creates a Stream> containing the list as a single element, not a Stream. Option C, Arrays.stream(list.toArray()), is wrong because list.toArray() returns Object[], so Arrays.stream yields a Stream

Answer

Stream.of(list)

Answer

Arrays.stream(list.toArray())

Answer

new Stream<>(list)

Question 12

A Java 17 method declares `throws Exception` and is called inside a lambda passed to `Stream.forEach`. The lambda body calls this method. What is the compilation result?

Accepted Answer

Compilation fails because the lambda body cannot throw a checked exception not declared by the functional interface.. A lambda must be compatible with the functional interface it implements. `Consumer.accept` declares no checked exceptions, so a lambda body cannot propagate a checked exception such as `Exception`. The call to the `throws Exception` method must be wrapped in a `try`/`catch` inside the lambda, or the exception must be handled through a different design. Otherwise, compilation fails.

Answer

Compilation succeeds because `Stream.forEach` declares `throws Exception` in its signature.

Answer

Compilation fails because `Stream.forEach` cannot be used with lambdas that call methods.

Answer

Compilation succeeds because lambdas can throw any exception regardless of the functional interface.

Question 13

A developer is writing a utility that must walk a large directory tree and compute the total size of all regular files, without following symbolic links. The utility must be efficient and handle files that may be deleted concurrently. Which approach is most appropriate?

Accepted Answer

Use Files.walkFileTree with a SimpleFileVisitor that overrides visitFile and visitFileFailed, accumulating sizes for regular files.. Files.walkFileTree with a SimpleFileVisitor provides controlled, efficient traversal with per-file error handling via visitFileFailed. It does not follow symbolic links by default, satisfying the no-follow requirement. The visitor can check BasicFileAttributes.isRegularFile() before summing sizes, and exceptions from concurrent deletion are caught in visitFileFailed, allowing the walk to continue. Other approaches lack this combination of efficiency, error resilience, and precise control.

Answer

Use File.listFiles recursively and sum lengths of files where isFile() returns true.

Answer

Use Files.walk to obtain a Stream<Path> and call Files.size on each path, catching exceptions.

Answer

Use Files.find with a depth limit and a BiPredicate that filters regular files, then sum sizes.

Question 14

A program reads user input as a string and needs to parse it into an integer, handling invalid input gracefully. Which code snippet correctly uses try-catch to parse and prints the result or 'Invalid number'?

Accepted Answer

try { int num = Integer.parseInt(input); System.out.println(num); } catch (NumberFormatException e) { System.out.println("Invalid number"); }. It uses `Integer.parseInt(input)` which throws a `NumberFormatException` for invalid input, and the catch block specifically catches that exception to print 'Invalid number'. This is the standard, idiomatic Java approach for parsing integers with error handling, as it directly addresses the requirement without unnecessary overhead or false positives.

Answer

try { int num = Integer.valueOf(input).intValue(); System.out.println(num); } catch (Exception e) { System.out.println("Invalid number"); }

Answer

int num = Integer.parseInt(input); System.out.println(num);

Answer

if (input.matches("\d+")) { int num = Integer.parseInt(input); System.out.println(num); } else { System.out.println("Invalid number"); }

Question 15

A developer needs to inspect the structure of a modular JAR named app.jar to confirm which modules it requires and which packages it exports. Which command should the developer run to display the module descriptor of app.jar?

Accepted Answer

jar --describe-module --file app.jar. The jar tool includes a describe-module mode that reads module-info.class from an archive and prints its directives. Using --file to name the archive lets the developer inspect requires, exports, opens, uses, and provides without extracting anything. Other tools either expect class files, perform dependency analysis, or require a module name resolved from the module path rather than a direct path to the JAR.

Answer

jdeps --module-path app.jar --list-modules

Answer

java --module-path app.jar --describe-module app

Answer

javap -v app.jar