1Z0-829 Practice Test 18 — 15 Questions

Question 1

Which two statements are true about records in Java? (Choose two.)

Accepted Answer

Records provide a canonical constructor that initializes all components.. Option A is correct because a record automatically receives a canonical constructor whose parameter list matches the declared record components and which assigns each component to its corresponding private final field. Option E is correct because records are implicitly final, so they cannot be extended by another class. Option B is incorrect because records cannot be declared abstract. Option C is incorrect because a record cannot extend any other class; it implicitly extends java.lang.Record. Option D is incorrect because a record cannot declare additional instance fields beyond the components listed in its header.

Answer

Records can be abstract.

Answer

Records can extend other classes.

Answer

Records can have instance fields that are not part of the record component list.

Question 2

In a JAAS login module, after the login() method returns true, which method must be called to commit the authentication and add principals to the Subject?

Accepted Answer

commit(). In a JAAS login module, after the `login()` method returns `true`, the `commit()` method must be called to associate the authenticated principals and credentials with the `Subject`. The `commit()` method is responsible for adding the successfully authenticated principals to the Subject, making them available for subsequent authorization checks. This is part of the two-phase authentication protocol defined by the `javax.security.auth.spi.LoginModule` interface.

Answer

login()

Answer

initialize()

Answer

abort()

Question 3

A developer places a non-modular JAR file on the module path. What type of module does this JAR become?

Accepted Answer

Automatic module. When a non-modular JAR is placed on the module path, the Java module system automatically derives a module from it, known as an automatic module. This is because the JAR lacks a module-info.class, so the system infers a module name from the JAR filename (e.g., using the Main-Class attribute or the JAR's name) and exports all packages, giving it access to all other modules. Option C is correct because the JAR becomes an automatic module, not a named or unnamed module.

Answer

Open module

Answer

Named module

Answer

Unnamed module

Question 4

Which THREE are benefits of using the NIO.2 API over the java.io API?

Accepted Answer

Simplified recursive file operations using FileVisitor.. The NIO.2 API introduces the `FileVisitor` interface, which simplifies recursive file operations by allowing you to implement methods like `preVisitDirectory`, `visitFile`, and `visitFileFailed` that are automatically called during a tree walk. This eliminates the need for manual recursion and boilerplate code required in the `java.io` API, making directory traversal more efficient and less error-prone.

Answer

Better performance for all I/O operations compared to java.io.

Answer

Automatic file compression when writing.

Question 5

Order the steps to properly handle resources using try-with-resources in Java.

Accepted Answer

Step 1: Declare and initialize resources in the try-with-resources parentheses. Step 2: Use the resources in the try block. Step 3: Resources are automatically closed in reverse order of declaration.. try-with-resources ensures each resource is closed at the end of the statement. Resources are closed in the opposite order they were created.

Answer

Step 1: Use resources in try block. Step 2: Declare resources in try-with-resources. Step 3: Resources are closed in declaration order.

Answer

Step 1: Declare resources in try-with-resources. Step 2: Close resources manually in a finally block. Step 3: Use resources in try block.

Answer

Step 1: Use resources in try block. Step 2: Declare resources in try-with-resources. Step 3: Resources are closed automatically in declaration order.

Question 6

Which of the following is a best practice when creating a custom exception class?

Accepted Answer

Extend RuntimeException for an unchecked exception.. Extending RuntimeException is the standard way to create a custom unchecked exception in Java. Unchecked exceptions do not require explicit handling via try-catch or throws clauses, making them suitable for programming errors like invalid arguments or illegal states. This aligns with Java's exception hierarchy where RuntimeException and its subclasses are unchecked.

Answer

Implement the Exception interface.

Answer

Extend Error to indicate a serious system error.

Answer

Extend Throwable directly to create a new exception type.

Question 7

Which THREE statements are true about the Boolean class? (Choose three.)

Accepted Answer

The parseBoolean(String) method returns false if the string is null or not equal to "true" (case-insensitive).. The `Boolean.parseBoolean(String)` method returns `false` for any input that is not exactly equal to `"true"` (case-insensitive), including `null`. This is specified in the Java API documentation and is a common way to safely parse boolean strings without throwing a NullPointerException.

Answer

The Boolean constructor is the preferred way to create a Boolean object.

Answer

Boolean has three possible values: true, false, and null.

Question 8

A company uses serialization to transfer objects between microservices. To prevent deserialization attacks, they want to restrict which classes can be deserialized. Which approach should be used in Java 17?

Accepted Answer

Use ObjectInputFilter with a custom filter. Java 17 provides the `ObjectInputFilter` API (introduced in Java 9) as the standard mechanism to restrict which classes can be deserialized. By setting a custom filter via `ObjectInputStream.setObjectInputFilter()` or a system-wide `jdk.serialFilter` property, you can whitelist or blacklist classes based on patterns, effectively preventing deserialization attacks without modifying the serialization stream itself.

Answer

Override resolveClass in ObjectInputStream

Answer

Use SecurityManager with a policy file

Answer

Implement Externalizable and control fields

Question 9

Which TWO statements about method references are true? (Choose two.)

Accepted Answer

Constructor references use the syntax Class::new.. Option A is correct because constructor references in Java use the exact syntax ClassName::new (e.g., Supplier s = Foo::new;), which is a valid shorthand for a lambda that invokes the constructor. Option D is correct because a method reference is essentially a more concise form of a lambda expression, so it can be assigned to any compatible functional interface target type, provided the referenced method's signature matches the single abstract method. Option B is false because array constructor references are supported using the syntax Type[]::new (e.g., IntFunction f = int[]::new;). Option C is false because instance method references use the form instance::method or ClassName::instanceMethod, and do not require the static keyword. Option E is false because method references can freely refer to methods declared in the same class, such as this::helper or ClassName::helper.

Answer

Array constructor references are not supported.

Answer

Instance method references always use the keyword static.

Answer

Method references cannot refer to methods declared in the same class.

Question 10

A financial services company runs a Java 17 Spring Boot application that processes real-time stock trades. The application uses a class `TradeProcessor` containing a method `void process(Trade trade)`. This method is invoked by multiple threads concurrently. The `Trade` class is immutable and has fields like `String symbol`, `int quantity`, `double price`. The `TradeProcessor` method updates a shared `HashMap<String, Double>` that tracks the average price per symbol. The update logic is: retrieve the current average for the symbol, compute a new average, and put it back. During high-load testing, the average prices are occasionally incorrect. The development team suspects a race condition. Which course of action should be taken to fix the issue with minimal performance impact?

Accepted Answer

Replace `HashMap` with `ConcurrentHashMap` and use the `compute` method to atomically update the average.. `ConcurrentHashMap` provides thread-safe atomic operations like `compute`, which allows you to atomically update the average price per symbol without external synchronization. This avoids the race condition where two threads read the same old average, compute a new one, and overwrite each other's result. Using `compute` ensures the read-modify-write sequence is performed atomically, with minimal performance overhead compared to synchronizing the entire method.

Answer

Use an `AtomicReference` to wrap the `HashMap`.

Answer

Synchronize the entire `process` method.

Answer

Change the `HashMap` to `Hashtable`.

Question 11

A developer writes a method that processes a grade and returns a message using a switch expression. The code is:

```java
public static String getMessage(int grade) {
    return switch (grade) {
        case 90, 80 -> "Excellent";
        case 70, 60 -> "Good";
        case 50 -> "Pass";
        default -> "Fail";
    };
}
```

Which statement is correct about this code?

Accepted Answer

The code compiles and runs correctly, returning the appropriate message.. The switch expression uses the arrow form with a list of constants per case, which is valid syntax in Java 14+. The arrow form does not require a 'yield' statement when the right side is a single expression or block; here, each case yields a string literal directly. The 'default' clause is mandatory in a switch expression to cover all possible values, and it is correctly included.

Answer

The code does not compile because the switch expression must be enclosed in parentheses.

Answer

The code does not compile because the arrow form requires a 'yield' statement.

Answer

The code does not compile because 'default' is not allowed in a switch expression.

Question 12

Which design pattern is best suited for creating a family of related objects without specifying their concrete classes?

Accepted Answer

Abstract Factory. The Abstract Factory pattern is designed to create families of related or dependent objects without specifying their concrete classes. It provides an interface for creating families of products, ensuring that the products from one family are used together, which is a core requirement of the question.

Answer

Builder

Answer

Singleton

Answer

Factory Method

Question 13

A developer has written a Java class that uses external libraries packaged as JAR files. The application runs correctly when launched from an IDE but fails with a ClassNotFoundException when run from the command line using `java -cp`. What is the most likely cause?

Accepted Answer

The JAR files are not listed in the classpath argument.. When running a Java application from the command line with `java -cp`, the classpath must explicitly include all JAR files and directories containing the required classes. If the external library JARs are not listed in the `-cp` argument, the class loader cannot find them, resulting in a `ClassNotFoundException`. IDEs typically manage the classpath automatically, which is why the application works there but fails from the command line.

Answer

The classpath is missing the directory containing the class files.

Answer

The JAR files are not in the module path.

Answer

The Java command should use java -jar instead.

Question 14

A method uses an enhanced for loop to iterate over a list of strings and prints each string. The code is:

```java
List<String> list = List.of("A", "B", "C");
for (String s : list) {
    if (s.equals("B")) {
        break;
    }
    System.out.print(s);
}
```

What is the result?

Accepted Answer

A. The enhanced for loop iterates over the list, and when it encounters the string "B", the break statement immediately exits the loop. Therefore, only "A" is printed before the loop terminates. Option C is correct because the output is just "A".

Answer

The code throws a ConcurrentModificationException.

Answer

ABC

Answer

AB

Question 15

A method returns a List<Integer>. The caller wants to ensure the list cannot be modified. Which is the best approach?

Accepted Answer

return Collections.unmodifiableList(list);. `Collections.unmodifiableList()` returns a read-only view of the specified list. Any attempt to modify the returned list (e.g., via `add`, `remove`, `set`) will throw an `UnsupportedOperationException`. This is the standard, recommended approach in the Java Collections Framework to provide an unmodifiable wrapper without copying the underlying data.

Answer

return Arrays.asList(list.toArray());

Answer

return new ArrayList<>(list);

Answer

return (List<Integer>) list.clone();