1Z0-829 Practice Test 30 — 15 Questions

Question 1

A retail application applies a 5% sales tax to a price stored as a BigDecimal. The developer writes:

BigDecimal price = new BigDecimal("19.99");
BigDecimal taxRate = new BigDecimal("0.05");
BigDecimal tax = price.multiply(taxRate);

What is the value of tax.toString()?

Accepted Answer

0.9995. BigDecimal multiplication is exact and its resulting scale equals the sum of the operand scales. Multiplying 19.99 (scale 2) by 0.05 (scale 2) yields an unscaled value of 9995 with scale 4, which prints as 0.9995. No rounding mode applies unless the code explicitly requests one through setScale or a MathContext.

Answer

An ArithmeticException is thrown because the result cannot be represented exactly.

Answer

1.0

Answer

0.9995 with a trailing rounding error of 0.0000000000000001

Question 2

A developer is using the jdeps tool to analyze a non-modular JAR file to prepare for modularization. The JAR contains classes that use internal APIs from the JDK. Which jdeps option should the developer use to identify dependencies on internal APIs?

Accepted Answer

jdeps --jdk-internals myapp.jar. The jdeps tool includes a dedicated option --jdk-internals (or -jdkinternals) that scans class files for references to JDK internal APIs. This is essential when migrating to Java 17, as internal APIs like sun.misc.Unsafe are encapsulated and may cause warnings or errors. The other options perform different analyses: listing module dependencies, generating module descriptors, or specifying module paths. Only --jdk-internals directly reports internal API usage.

Answer

jdeps --list-deps myapp.jar

Answer

jdeps --module-path mods --add-modules java.base myapp.jar

Answer

jdeps --generate-module-info myapp.jar

Question 3

A Java 17 application must persist sensitive configuration objects to disk. The security team requires that deserialization of these objects be restricted to only classes in the `com.example.config` package and its subpackages, rejecting all others. Which approach best meets this requirement?

Accepted Answer

Create a custom `ObjectInputFilter` that checks the class name against `com.example.config.*` and rejects any class outside that package, then set it via `ObjectInputFilter.Config.setSerialFilter()`.. The `ObjectInputFilter` mechanism is the standard, centralized way to control which classes are allowed during deserialization. By implementing a filter that checks the class name against the allowed package and setting it as the JVM-wide serialization filter, the application ensures that any attempt to deserialize a class outside `com.example.config` is rejected. This directly fulfills the security team's requirement and is the recommended practice for mitigating deserialization vulnerabilities in Java 17.

Answer

Use a `SecurityManager` with a policy file that grants `SerializablePermission` only to classes in `com.example.config`.

Answer

Encrypt the serialized bytes with a secret key and decrypt them before deserialization.

Answer

Override `readObject` in each class to validate the class name before calling `defaultReadObject`.

Question 4

A developer is writing a method that takes a `java.util.List<String>` and returns a single comma-separated String of all elements in uppercase. The method must be implemented as a single stream pipeline using `Collectors.joining`. Which pipeline correctly produces the required result?

Accepted Answer

list.stream().map(String::toUpperCase).collect(Collectors.joining(",")). The joining collector with a delimiter is specifically designed to concatenate stream elements into a single String with separators. Combining map(String::toUpperCase) with Collectors.joining(",") transforms each element and inserts commas between them, producing the exact format required. The other options either omit the delimiter, misuse the joining overloads, or use reduce incorrectly, so they do not satisfy the method's contract.

Answer

list.stream().map(String::toUpperCase).collect(Collectors.joining())

Answer

list.stream().collect(Collectors.joining(",", String::toUpperCase, String::toUpperCase))

Answer

list.stream().map(String::toUpperCase).reduce(",", String::concat)

Question 5

A developer writes the following method to classify a transaction amount:

```java
public static String classify(int amount) {
    return switch (amount) {
        case 0 -> "zero";
        case 100, 200 -> "round";
        default -> {
            if (amount < 0) {
                yield "negative";
            }
            yield "other";
        }
    };
}
```

Which statement about this method is correct?

Accepted Answer

The method compiles and returns "negative" for amount = -50, "round" for amount = 200, and "other" for amount = 7.. The switch expression is exhaustive because of the default arm, and the block-bodied default yields on every path. Negative amounts take the inner branch and yield 'negative', the multi-label case handles 100 and 200 with 'round', and any other value reaches the trailing yield and returns 'other'. The method compiles and behaves exactly as described.

Answer

The method fails to compile because a switch expression cannot use a block body with yield inside a default arm.

Answer

The method fails to compile because case 100, 200 uses a comma-separated label, which is invalid in switch expressions.

Answer

The method compiles but throws an exception at runtime for amount = -50 because the default block has no return statement.

Question 6

A development team is packaging a Java 17 application as a modular JAR. The module descriptor includes 'requires transitive java.logging;'. A client module that requires the application module wants to use java.util.logging.Logger directly. What is the effect of the 'transitive' modifier in this scenario?

Accepted Answer

The client module automatically reads the java.logging module without declaring 'requires java.logging' itself.. The 'requires transitive' directive establishes an implied readability relationship: any module that reads the application module also reads java.logging. Consequently, the client module can use java.util.logging.Logger without an explicit requires clause. The other options incorrectly limit the scope of transitive or confuse exports with readability.

Answer

The client module must still declare 'requires java.logging' to access Logger, because transitive only affects compilation of the application module.

Answer

The 'transitive' modifier makes java.logging available only to the application module's own packages, not to client modules.

Answer

The client module can access Logger only if it also exports a package that contains a public API using Logger.

Question 7

A developer is implementing a value-based class `Temperature` that must be usable as a key in a `HashMap`. The class declares a single `private final int celsius` field. Which implementation of `equals` and `hashCode` is correct and consistent for this class?

Accepted Answer

public boolean equals(Object o) { return o instanceof Temperature && ((Temperature)o).celsius == this.celsius; } public int hashCode() { return Objects.hash(celsius); }. A correct equals method must handle null and incompatible types by returning false, and must compare the relevant state. Objects.hash produces a hash code consistent with equals. Overloading equals with a non-Object parameter fails to override, and comparing hash codes alone is unreliable due to collisions. Only the implementation that uses instanceof, casts safely, and compares the field satisfies the contract.

Answer

public boolean equals(Object o) { Temperature t = (Temperature) o; return t.celsius == this.celsius; } public int hashCode() { return celsius; }

Answer

public boolean equals(Temperature t) { return t.celsius == this.celsius; } public int hashCode() { return Objects.hash(celsius); }

Answer

public boolean equals(Object o) { return o.hashCode() == this.hashCode(); } public int hashCode() { return celsius; }

Question 8

A developer writes a method that must label each processed parcel with a route code derived from its weight bracket. The code is:

```java
int bracket = 3;
String route = switch (bracket) {
    case 1 -> "LOCAL";
    case 2, 3 -> "REGIONAL";
    default -> "NATIONAL";
};
System.out.println(route);
```

What is printed?

Accepted Answer

REGIONAL. A switch expression with arrow labels performs strict constant matching against the selector; the first matching label wins and no fall-through exists. Because the grouped label lists both 2 and 3, the selector value 3 selects the arm yielding REGIONAL. Grouping constants in one label is legal and is the idiomatic way to share a single result across several values.

Answer

LOCAL

Answer

NATIONAL

Answer

Compilation fails because two constants appear in a single case label.

Question 9

A developer writes a stream pipeline that should short-circuit and stop processing as soon as it finds a negative number in a large list. The code is: `list.stream().filter(n -> n < 0).findFirst()`. A colleague claims the entire list is always processed. Which statement accurately describes the behavior?

Accepted Answer

The pipeline may stop early because findFirst is a short-circuiting terminal operation.. The terminal operation findFirst is short-circuiting, so once the filter yields a negative number, the stream terminates without processing remaining elements. Sequential streams process in encounter order, so the first negative number found ends the pipeline. The colleague's claim is incorrect because it overlooks the short-circuiting terminal operation, which is the key to the pipeline's early termination.

Answer

The pipeline processes the entire list because findFirst must scan all elements to determine the first.

Answer

The pipeline stops early only if the stream is parallel and ordered.

Answer

The pipeline processes the entire list because filter is not a short-circuiting operation.

Question 10

A team packages a library as a multi-release JAR named util.jar. The archive contains a base version of com.acme.util.Parser compiled for Java 11 and a Java 17-specific version under META-INF/versions/17/com/acme/util/Parser.class. The manifest declares Multi-Release: true. A Java 17 application places util.jar on the class path. Which class does the JVM load when com.acme.util.Parser is first referenced?

Accepted Answer

The Java 17-specific version, because the runtime selects the highest versioned entry not exceeding the current runtime version.. A multi-release JAR with Multi-Release: true lets the runtime choose versioned classes under META-INF/versions. The selection rule picks the highest version directory not exceeding the running Java version, so Java 17 loads the version 17 class over the base class. This works on the class path as well as the module path, and only one variant is ever defined per class name.

Answer

The base version, because multi-release behavior applies only when the JAR is on the module path.

Answer

Both versions are loaded, and the base version wins for the first reference while the versioned one is used by reflection.

Answer

The versioned entry is ignored because its package is not listed in the manifest's Multi-Release-Packages attribute.

Question 11

A developer writes a class `Report` and wants instances to be safely usable as keys in a `HashMap`. The class has two fields, `id` (int) and `title` (String), that together define logical equality. Which pair of method overrides is required to satisfy the general contract for hash-based collections?

Accepted Answer

Override equals(Object) and hashCode().. Hash-based collections depend on both equals() and hashCode() to maintain their internal bucket structure. Overriding equals() alone breaks the requirement that equal objects share a hash code, while overriding hashCode() alone leaves identity-based equality in place. Together, these overrides allow logically equal Report instances to be found and deduplicated correctly, which is the fundamental requirement for using a class as a HashMap key.

Answer

Override equals(Object) only.

Answer

Override compareTo() and hashCode().

Answer

Override toString() and clone().

Question 12

A developer is writing a method that must read a file and may throw `IOException`. The method should also handle a custom checked exception `DataFormatException` that extends `Exception`. The developer writes the following catch clauses:

```java
try {
    readFile();
} catch (IOException | DataFormatException e) {
    log(e);
}
```

Which two statements are true about this multi-catch usage? (Choose two.)

Accepted Answer

The variable `e` is implicitly final and cannot be reassigned inside the catch block.. In a multi-catch clause, the exception parameter is implicitly final, preventing reassignment. Also, the clause handles all listed exception types, so any of them thrown in the try block is caught, satisfying the compiler's checked exception requirements. The types must not be in a subclass relationship, but they can be unrelated checked exceptions. This allows concise handling of multiple exception types with shared logic.

Answer

The catch clause is invalid because `DataFormatException` is a checked exception and cannot be combined with `IOException`.

Answer

The catch clause is valid only if `DataFormatException` is a subclass of `IOException`.

Answer

The exception parameter `e` has the type of the least common superclass of `IOException` and `DataFormatException`, which is `Exception`.

Question 13

A developer writes a while loop to print numbers from 1 to 5. The loop condition is while (count <= 5). Inside the loop, they increment count after printing. What is the output?

Accepted Answer

1 2 3 4 5. With count initialized to 1 and the condition count <= 5, the loop prints the value of count and then increments it. The sequence of printed values is 1, 2, 3, 4, 5. After printing 5, count becomes 6, and the loop condition fails, so the loop terminates. Thus, the output is the numbers 1 through 5.

Answer

1 2 3 4 5 6

Answer

0 1 2 3 4 5

Answer

1 2 3 4

Question 14

A company is developing a plugin system where third-party developers can provide implementations of an interface `Plugin`. The system must ensure that all plugins implement a method `void execute()`. Additionally, the system wants to provide a utility method `static void log(String message)` that logs to a central location, and it should be available to all plugins without requiring them to implement it. Which interface design correctly meets these requirements?

Accepted Answer

Define `Plugin` as an interface with an abstract method `void execute()` and a static method `static void log(String message)`.. The interface should declare `execute()` as abstract to force implementation, and `log()` as static to provide a utility method accessible via the interface name. This combination ensures all plugins implement `execute` while having a centralized logging utility without adding to their contract. Default methods would make `execute` optional or `log` overridable, which is not desired.

Answer

Define `Plugin` as an interface with a default method `void execute()` and a static method `static void log(String message)`.

Answer

Define `Plugin` as an interface with an abstract method `void execute()` and a default method `default void log(String message)`.

Answer

Define `Plugin` as an abstract class with an abstract method `void execute()` and a static method `static void log(String message)`.

Question 15

A developer needs to serialize an object of class Employee to a file. The class has a field of type Department, which is not serializable. The developer wants to avoid NotSerializableException while still persisting the department name. Which approach is correct?

Accepted Answer

Mark the Department field as transient and implement writeObject and readObject in Employee to manually write and read the department name.. When a serializable class contains a non-serializable field, the field must be marked transient to avoid NotSerializableException. To persist part of that field's data, the class can implement writeObject and readObject to manually write and read the desired information, such as the department name as a String. This approach maintains serializability while handling the non-serializable component gracefully.

Answer

Make the Department class implement Serializable and ensure all its fields are serializable.

Answer

Implement Externalizable in Employee and override writeExternal and readExternal to write only the necessary fields.

Answer

Use the transient keyword on the Department field and rely on the default serialization to skip it, but the department name will be lost.