1Z0-829 Practice Test 28 — 15 Questions

Question 1

A financial trading application uses Java 17 and processes millions of transactions per second. It uses a custom checked exception `TradeException extends Exception` for business rule violations. Recently, the transaction processing service began throwing a `RuntimeException` that wraps a `TradeException`, but the error logs only show the wrapper's message and stack trace, missing the original `TradeException` details. The logging framework prints the exception and its cause chain. The development team needs to ensure that the original `TradeException` message and stack trace are always logged. What is the most appropriate course of action?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Modify the exception wrapping code to pass the original TradeException as a cause to the RuntimeException constructor.. Passing the original `TradeException` as the cause argument to the `RuntimeException` constructor (e.g., `new RuntimeException(message, cause)`) preserves the full cause chain. The logging framework, which prints the exception and its cause chain, will then output both the wrapper's stack trace and the original `TradeException`'s message and stack trace, ensuring complete visibility.

Answer

Catch the RuntimeException in the main processing loop and print the cause's message using getCause().getMessage().

Answer

Modify the TradeException class to extend RuntimeException.

Answer

Override the getMessage() method in TradeException to return the original message.

Question 2

Which TWO approaches are recommended to secure Java I/O operations? (Choose two.)

Accepted Answer

Use try-with-resources to ensure proper resource closure.. Try-with-resources automatically closes each resource declared in its header when the block exits, whether normally or via exception. This eliminates the risk of resource leaks from forgotten or improperly handled close() calls, which is a fundamental security and reliability requirement for I/O operations.

Answer

Use BufferedInputStream to wrap FileInputStream for better performance.

Answer

Use Serializable interface for all data objects.

Answer

Use FileLock to prevent concurrent write access.

Question 3

Given the code snippet:
int x = 10;
if (x > 5) {
    System.out.print("A");
} else if (x > 7) {
    System.out.print("B");
} else {
    System.out.print("C");
}
What is the output?

Accepted Answer

A. The if-else chain evaluates conditions sequentially. Since x=10 satisfies x > 5, the first block executes and prints 'A'. The else if and else branches are skipped entirely because the first condition was true. Thus, only 'A' is output.

Answer

C

Answer

ABC

Answer

B

Question 4

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 5

What is the result of executing the code in the exhibit?

Accepted Answer

ConcurrentModificationException is thrown.. The code uses an ArrayList and iterates over it with an enhanced for-each loop while simultaneously removing an element via the list's remove() method. This structural modification directly from the list (not via the iterator's remove()) triggers a ConcurrentModificationException because the iterator's modCount check fails. The exception is thrown at the next iteration attempt after the removal.

Answer

The code compiles and runs without output.

Answer

[A, C]

Answer

[A, B]

Question 6

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.. The try-with-resources statement automatically closes each resource declared in the resource specification after the try block completes, whether normally or abruptly. This is the primary purpose of the construct: to ensure reliable resource cleanup without requiring an explicit finally block.

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 7

Refer to the exhibit. Which of the following best describes the effective permissions granted to the application?

Accepted Answer

The application can read and write files under /data/ and connect to any socket.. The exhibit shows a Java security policy granting the application `java.net.SocketPermission` with `connect,resolve` actions and `java.io.FilePermission` with `read,write` actions on `/data/-`. This means the application can connect to any socket (since the target name is `*`) and read/write any file under `/data/`. Option B correctly captures both permissions.

Answer

The application can connect to any network socket.

Answer

The application can only read files under /data/ and connect to sockets.

Answer

The application can read and write any file under /data/.

Question 8

Which THREE statements about exception handling are true? (Choose three.)

Accepted Answer

Multi-catch syntax uses the pipe symbol (|) between exception types.. Java's multi-catch syntax allows a single catch block to handle multiple exception types by separating them with the pipe symbol (|). This reduces code duplication when different exceptions require the same handling logic.

Answer

The variable in a catch clause is effectively final only when using multi-catch syntax.

Answer

A finally block is mandatory in a try-with-resources statement.

Question 9

Which THREE of the following are valid ways to create a Stream<String>? (Choose three.)

Accepted Answer

Arrays.stream(new String[]{"a", "b"}). `Arrays.stream(T[])` returns a `Stream` from an array. Passing `new String[]{"a", "b"}` creates a `Stream` directly, as the method is overloaded for object arrays.

Answer

"ab".chars()

Answer

new Stream<String>()

Question 10

Refer to the exhibit. What is the output?

Accepted Answer

88.33333333333333. The code creates an IntStream with values 85, 92, and 88, then calls average() to compute the arithmetic mean. This returns an OptionalDouble, and orElse(0.0) extracts the value. The sum 85+92+88 = 265, divided by 3 gives 88.33333333333333, which matches option B exactly. No integer division occurs because average() always returns a double.

Answer

88.0

Answer

85.0

Answer

85.75

Question 11

A Java application is developed using Java SE 17. It uses only standard Java APIs and no external libraries. The application runs without errors in the development environment. When deploying to a production server, which minimal Java environment is sufficient?

Accepted Answer

Java Runtime Environment (JRE). A Java application compiled into bytecode (`.class` files) requires only the Java Runtime Environment (JRE) to execute. The JRE includes the Java Virtual Machine (JVM), core libraries, and supporting files, but not development tools like the compiler. Since the application is already compiled and uses only standard APIs, no additional tools are needed at runtime.

Answer

Java compiler (javac)

Answer

Java Virtual Machine (JVM) only

Answer

Java Development Kit (JDK)

Question 12

An application built with Java 17 uses a third-party library that internally uses `sun.misc.Unsafe`. The application runs without errors on Java 8 but throws an `IllegalAccessError` on Java 17. What is the most likely reason?

Accepted Answer

Strong encapsulation of JDK internals is enforced by default.. In Java 17, strong encapsulation of JDK internals is enforced by default, meaning that code cannot access internal APIs like `sun.misc.Unsafe` via reflection or direct use unless explicitly opened. The `IllegalAccessError` occurs because the third-party library attempts to use `sun.misc.Unsafe`, which is a JDK internal API that is no longer accessible by default. This change was introduced as part of JEP 403 (Strongly Encapsulate JDK Internals) and finalized in Java 17, whereas Java 8 allowed such access.

Answer

The --illegal-access flag is set to permit.

Answer

The module path does not include the library.

Answer

The library is not in a named module.

Question 13

Given: for(int i=0; i<10; i++) { if(i%2==0) continue; System.out.print(i+" "); } What is the output?

Accepted Answer

1 3 5 7 9. The loop iterates from 0 to 9, and the `continue` statement skips the rest of the loop body when the condition `i % 2 == 0` is true (i.e., for even numbers). Only odd numbers (1, 3, 5, 7, 9) are printed, each followed by a space.

Answer

No output

Answer

0 2 4 6 8

Answer

0 1 2 3 4 5 6 7 8 9

Question 14

Which TWO of the following are characteristics of a well-designed lambda expression? (Choose two.)

Accepted Answer

Is stateless. A well-designed lambda expression should be stateless, meaning it does not depend on or modify mutable state from the enclosing scope. This ensures that the lambda can be safely executed in parallel streams without race conditions or side effects, aligning with the functional programming paradigm promoted by Java streams.

Answer

Throws exceptions that are not declared in the functional interface's abstract method

Answer

Uses the same variable name as a parameter in the enclosing scope (shadowing)

Answer

Modifies local variables of the enclosing method

Question 15

Assuming the code runs in a multithreaded environment, which statement best describes the behavior?

Accepted Answer

It prints the doubled numbers in a non-deterministic order and results may contain missing or duplicate entries.. Using a parallel stream with a stateful lambda (e.g., modifying an external `results` list inside `peek` or `forEach`) introduces data races and non-deterministic behavior. The `peek` operation is not synchronized, so the order of printed doubled numbers is unpredictable, and concurrent modifications to the shared `results` list can cause missing or duplicate entries due to race conditions.

Answer

The code will compile but throw an exception at runtime because of the use of parallel stream with stateful lambda.

Answer

It prints the doubled numbers in order (2, 4, 6, 8) and results contains [1,2,3,4] in that order.

Answer

It may produce a ConcurrentModificationException because results is modified while iterating.