1Z0-829 Practice Test 13 — 15 Questions

Question 1

Given the following code fragment:
```java
int x = 0;
for (int i = 0; i < 4; i++) {
    x++;
}
System.out.println(x);
```
What is the result?

Accepted Answer

4. The loop runs four times (i = 0, 1, 2, 3), incrementing x each time. Therefore, x becomes 4, so the output is 4. Option B is correct.

Answer

9

Answer

3

Answer

5

Question 2

Which THREE practices are recommended for effective exception handling? (Choose three.)

Accepted Answer

Throw exceptions early, catch them late, but handle them at the appropriate level.. Option A is correct because the recommended pattern is to detect and throw an exception as soon as the error condition is detected (throw early), let it propagate up the call stack (catch late), and only handle it at the layer that has enough context to recover or translate it meaningfully. Option C is correct because try-with-resources automatically invokes close() on any AutoCloseable resource at the end of the block, eliminating the boilerplate and error-prone manual close() in a finally block and correctly handling suppressed exceptions. Option E is correct because catching specific exception types (e.g., IOException, SQLException) allows precise, targeted handling and avoids accidentally swallowing unrelated runtime errors that a broad catch (Exception) would mask. Option B is not recommended because custom exceptions should carry meaningful context (messages, cause, relevant fields) to aid diagnosis, not be defined without additional context. Option D is not recommended because catching everything at the highest level and logging generically loses the specific handling each layer should perform and produces vague, hard-to-diagnose logs.

Answer

Define custom exceptions without providing any additional context.

Answer

Catch exceptions at the highest level of the application and log them generically.

Question 3

Given: List<String> words = List.of("apple", "banana", "cherry");
var result = words.stream().filter(s -> s.length() > 5).collect(Collectors.toUnmodifiableList());
What happens if another thread tries to add to result?

Accepted Answer

UnsupportedOperationException at runtime.. B is correct because `Collectors.toUnmodifiableList()` returns an unmodifiable list, and any attempt to modify it (e.g., via `add()`) throws an `UnsupportedOperationException`. The stream pipeline itself is safe and compiles fine; the issue is the mutability of the resulting collection.

Answer

Compilation error because var cannot be used with streams.

Answer

The thread successfully adds the element.

Answer

NullPointerException.

Question 4

Which three of the following statements about the switch expression in Java 17 are correct?

Accepted Answer

A switch expression with arrow syntax does not require break.. Option A is correct because arrow-syntax switch expressions (case X -> value) do not fall through, so no break statement is needed to terminate a branch. Option B is correct because colon-syntax switch expressions (case X: ... yield value;) use the yield statement to produce the expression's value, since a plain value expression is not allowed in that form. Option E is correct because a switch expression must be exhaustive: every possible input value must be handled, either by covering all constants (e.g., all enum constants or all sealed subtypes) or by providing a default branch. Option C is wrong because switch expressions work perfectly well with enum types, which are in fact a common and recommended use case. Option D is wrong because a default branch is not strictly required when the compiler can determine that all possible values are already covered, such as with an exhaustive enum or sealed hierarchy.

Answer

A switch expression cannot be used with an enum type.

Answer

A switch expression must include a default branch even if all cases are covered.

Question 5

A developer runs 'jdeps -s --module-path lib myapp.jar' and gets output: 'myapp.jar -> java.base, myapp.jar -> java.sql, myapp.jar -> notfound'. What does the 'notfound' entry indicate?

Accepted Answer

The application has a dependency on a package that is not provided by any module on the module path.. The 'notfound' entry in the jdeps -s output indicates that the application has a dependency on a package that is not provided by any module on the module path. The -s (summary) flag shows module-level dependencies, and when a required module cannot be located among the specified modules or the JDK's built-in modules, jdeps reports it as 'notfound'. This means the dependency cannot be resolved at analysis time, typically because the required module is missing from the module path.

Answer

The dependency is resolved but its module name is not printed due to a summary flag.

Answer

The jar file is missing or corrupt.

Answer

There is a cyclic dependency among modules.

Question 6

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

Accepted Answer

Is stateless. Option A is correct because a well-designed lambda should be stateless: it must not rely on or mutate shared mutable state, so it can be executed safely in parallel streams and reused without side effects. Option D is correct because lambdas may only capture variables from the enclosing scope that are final or effectively final (assigned once), which prevents unsafe mutation of captured locals and keeps the lambda's behavior predictable. Option B is wrong because a lambda body cannot throw checked exceptions that are not declared by the functional interface's abstract method; only unchecked exceptions are allowed freely. Option C is wrong because a lambda parameter name may not shadow a local variable of the enclosing method, which is a compile-time error. Option E is wrong because modifying an enclosing method's local variable inside a lambda is illegal since captured locals must be effectively final.

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 7

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

Accepted Answer

The resource class must implement AutoCloseable.. The try-with-resources statement requires that each resource implements the AutoCloseable interface (or its subinterface Closeable). This interface defines the close() method, which is automatically invoked by the JVM when the try block completes, ensuring proper resource management without explicit finally blocks.

Answer

The resource variable must be declared as final.

Answer

A try-with-resources statement cannot have a finally block.

Answer

Resources are closed before the try block executes.

Question 8

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 9

Which statement about TreeSet is true when using a custom Comparator that does not define equals() consistently with compare()?

Accepted Answer

TreeSet considers two elements equal if the comparator returns 0.. TreeSet uses the compare() method of the provided Comparator (or the natural ordering's compareTo()) to determine element equality. When a custom Comparator returns 0 for two elements, TreeSet treats them as duplicates and does not add the second element, regardless of what equals() returns. This is specified in the Java Collections Framework documentation and is critical for maintaining the Set contract.

Answer

TreeSet uses equals() to determine duplicates.

Answer

TreeSet uses hashCode() for ordering.

Answer

TreeSet throws IllegalArgumentException if equals() is inconsistent.

Question 10

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 11

A developer is writing a utility to validate user input. The method receives an integer `score` and must assign a letter grade based on the following rules:

- If `score` is 90 or above, grade is 'A'.
- If `score` is between 80 and 89 (inclusive), grade is 'B'.
- If `score` is between 70 and 79 (inclusive), grade is 'C'.
- Otherwise, grade is 'F'.

They implement the logic using a traditional switch statement, but the code fails to compile. Which of the following is the most likely cause of the compilation error?

Accepted Answer

The case labels use relational operators (e.g., `case score >= 90:`).. The compilation error occurs because traditional switch statements require case labels to be constant expressions, such as literals or final variables. Relational expressions like `score >= 90` are not constant and cannot be used as case labels. To implement range-based grading, an if-else chain is appropriate, or a switch expression with pattern matching (if using preview features). The other options do not cause this specific error.

Answer

The switch statement is missing a break statement after each case.

Answer

The switch statement is missing a default case.

Answer

The switch statement uses a boolean expression as its selector.

Question 12

A payroll application running on Java 17 must apply a 7.5% raise to a base salary of 45230.55 and store the result with exact decimal precision, never losing a cent to binary rounding. The computation is performed repeatedly in a loop and must remain deterministic. Which declaration and computation best satisfies these requirements?

Accepted Answer

BigDecimal base = new BigDecimal("45230.55"); BigDecimal raised = base.multiply(new BigDecimal("1.075")).setScale(2, RoundingMode.HALF_UP);. Exact monetary math requires representing decimal literals as strings so no binary approximation enters the pipeline, then applying an explicit scale and rounding mode to control the final fractional digits. Multiplying two BigDecimals without a context produces an exact product, and setScale with HALF_UP gives deterministic cent behavior. Approaches that begin from double values or that misuse significant-digit precision cannot guarantee cent accuracy.

Answer

BigDecimal base = new BigDecimal("45230.55"); BigDecimal raised = base.multiply(new BigDecimal("1.075"), new MathContext(2));

Answer

BigDecimal base = new BigDecimal(45230.55); BigDecimal raised = base.multiply(new BigDecimal(1.075));

Answer

double base = 45230.55; double raised = base * 1.075; BigDecimal result = BigDecimal.valueOf(raised);

Question 13

A developer writes a try-with-resources statement that opens two `AutoCloseable` resources: `r1` then `r2`. The try block throws an exception, and then `r2.close()` throws an exception, followed by `r1.close()` throwing an exception. Which exception is propagated to the caller?

Accepted Answer

The exception from the try block, with the close exceptions added as suppressed exceptions.. In try-with-resources, the exception thrown in the try block is the primary exception. If closing resources also throws exceptions, those are added as suppressed exceptions to the primary one. The resources are closed in reverse order of their declaration, so r2 closes before r1, but both close exceptions are suppressed on the try block's exception.

Answer

A new exception is thrown that combines all three exceptions.

Answer

The exception from r1.close(), with the others as suppressed.

Answer

The exception from r2.close(), with the others as suppressed.

Question 14

An application stores durations as text such as "PT2H30M" and must convert them into a java.time.Duration. Which statement about parsing this text with Duration.parse is true?

Accepted Answer

Duration.parse accepts the ISO-8601 format produced by Duration.toString, so "PT2H30M" becomes a duration of two hours and thirty minutes.. Duration.parse consumes the same ISO-8601 text format that Duration.toString produces, using the mandatory P and T designators with H and M standing for hours and minutes. A bare time portion is valid, the PT prefix cannot be omitted, and the return type is always Duration, not Period, regardless of which designators appear.

Answer

Duration.parse returns a Period when the input contains an M designator, because M can mean months.

Answer

Duration.parse accepts "2H30M" without the PT prefix and treats it as two hours and thirty minutes.

Answer

Duration.parse requires a date component and throws DateTimeParseException when only the time portion is present.

Question 15

A developer writes a method that declares `throws SQLException`. Inside a `try` block, it calls `connection.prepareStatement(sql)`. The developer adds a `catch (IOException e)` block after the `try` to handle potential errors. What is the result when compiling this code with Java 17?

Accepted Answer

Compilation fails because IOException is not thrown in the try block and is not a supertype of SQLException.. A catch clause for a checked exception is only allowed if that exception (or a subtype) can be thrown in the corresponding try block. Since the try block only declares SQLException, catching IOException is invalid and causes a compilation error. The compiler verifies exception reachability at compile time.

Answer

Compilation fails because SQLException must be caught before IOException.

Answer

Compilation succeeds because catch blocks can handle any exception type regardless of what is thrown.

Answer

Compilation succeeds but a warning is issued about the unused catch block.