1Z0-829 sample questions

Question 1

A developer has a `List >` and wants to get a `List ` containing all non-empty string values. Which of the following stream pipelines correctly and most efficiently accomplishes this?

Accepted Answer

```java list.stream() .flatMap(Optional::stream) .collect(Collectors.toList()); ```

Answer

```java list.stream() .filter(Optional::isPresent) .map(Optional::get) .collect(Collectors.toList()); ```

Answer

```java list.stream() .map(o -> o.orElse("")) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); ```

Answer

```java list.stream() .map(Optional::get) .collect(Collectors.toList()); ```

Question 2

**Case Study:** A logistics company is modernizing its package tracking system. The system needs to represent different types of packages, each with specific attributes. The requirements are as follows: 1. There are three and only three types of packages: `Standard`, `Express`, and `Fragile`. 2. No other package types should be permissible in the system to ensure strict domain modeling. 3. A `Standard` package has a weight. 4. An `Express` package has a weight and a priority level (an integer). 5. A `Fragile` package has a weight and special handling instructions (a String). 6. All package types should be immutable data carriers. A senior developer proposes using a combination of sealed interfaces and records to model this domain. The goal is to create a type-safe hierarchy that can be effectively processed, for example, in a `switch` expression for calculating shipping costs. Which code implementation best satisfies all the given requirements?

Accepted Answer

```java public sealed interface Package permits Standard, Express, Fragile {} public record Standard(double weight) implements Package {} public record Express(double weight, int priority) implements Package {} public record Fragile(double weight, String instructions) implements Package {} ```

Answer

```java public abstract class Package {} public class Standard extends Package { double weight; } public class Express extends Package { double weight; int priority; } public class Fragile extends Package { double weight; String instructions; } ```

Answer

```java public interface Package {} public final record Standard(double weight) implements Package {} public final record Express(double weight, int priority) implements Package {} public final record Fragile(double weight, String instructions) implements Package {} ```

Answer

```java public enum PackageType { STANDARD, EXPRESS, FRAGILE } public class Package { PackageType type; double weight; int priority; String instructions; } ```

Question 3

A developer is writing a JDBC utility to fetch user data. They need to ensure that the `Connection` and `PreparedStatement` are always closed, even if an exception occurs during result set processing. Which code structure provides the most robust and modern approach to achieve this?

Accepted Answer

A `try-with-resources` statement that declares both the `Connection` and `PreparedStatement` in the resource specification block.

Answer

A `try-catch` block for the main logic, with a `finally` block that contains nested `try-catch` blocks to close each resource individually.

Answer

A `try-finally` block where the `try` block handles all operations and the `finally` block closes the resources in reverse order of their creation.

Answer

A single `try-catch` block where `close()` is called on each resource at the end of the `try` block.

Question 4

True or False: In the Java Platform Module System (JPMS), if module `A` requires module `B` (`requires B;`), and module `B` exports package `p1` (`exports p1;`), then module `A` can access public types in package `p1` by default.

Accepted Answer

True

Answer

False

Question 5

A developer is working with a `java.util.concurrent.ExecutorService` to run asynchronous tasks. After submitting all tasks, the developer wants to shut down the service gracefully, allowing currently executing tasks to finish but rejecting any new tasks. Which method should be called on the `ExecutorService` instance?

Accepted Answer

`shutdown()`

Answer

`shutdownNow()`

Answer

`awaitTermination(long timeout, TimeUnit unit)`

Answer

`close()`

Question 6

Consider the following record definition and its usage. What will be the output of this program?

Accepted Answer

10, 20 true

Answer

10, 20 false

Answer

A compilation error occurs because records cannot have constructors with bodies.

Answer

The code throws an `IllegalArgumentException` at runtime.

Question 7

A developer is serializing an object of class `Employee`. The `Employee` class contains a field for a password, which should not be saved to disk for security reasons. The class also needs to maintain a version UID for compatibility. Which two modifications are necessary to achieve this? (Select TWO)

Accepted Answer

Implement the `java.io.Serializable` interface.

Accepted Answer

Mark the `password` field with the `transient` keyword.

Answer

Mark the `password` field with the `volatile` keyword.

Answer

Add a `private static final long serialVersionUID` field.

Answer

Make the `password` field `private static`.

Question 8

**Case Study:** A logistics company is modernizing its package tracking system. The system needs to represent different types of packages, each with specific attributes. The requirements are as follows: 1. There are three and only three types of packages: `Standard`, `Express`, and `Fragile`. 2. No other package types should be permissible in the system to ensure strict domain modeling. 3. A `Standard` package has a weight. 4. An `Express` package has a weight and a priority level (an integer). 5. A `Fragile` package has a weight and special handling instructions (a String). 6. All package types should be immutable data carriers. A senior developer proposes using a combination of sealed interfaces and records to model this domain. The goal is to create a type-safe hierarchy that can be effectively processed, for example, in a `switch` expression for calculating shipping costs. Which code implementation best satisfies all the given requirements?

Accepted Answer

```java public sealed interface Package permits Standard, Express, Fragile {} public record Standard(double weight) implements Package {} public record Express(double weight, int priority) implements Package {} public record Fragile(double weight, String instructions) implements Package {} ```

Answer

```java public abstract class Package {} public class Standard extends Package { double weight; } public class Express extends Package { double weight; int priority; } public class Fragile extends Package { double weight; String instructions; } ```

Answer

```java public interface Package {} public final record Standard(double weight) implements Package {} public final record Express(double weight, int priority) implements Package {} public final record Fragile(double weight, String instructions) implements Package {} ```

Answer

```java public enum PackageType { STANDARD, EXPRESS, FRAGILE } public class Package { PackageType type; double weight; int priority; String instructions; } ```

Question 9

**Case Study** A software architect is designing a system for a payment gateway. The system must handle different types of payment methods. The core requirement is to have a common `PaymentMethod` type, but restrict implementations to a known, fixed set: `CreditCard`, `PayPal`, and `BankTransfer`. No other developers, now or in the future, should be able to create new, unknown implementations of `PaymentMethod` outside of the core payment module. This strict control is necessary for security and compliance audits. The architect wants to model this domain using the most effective and modern object-oriented features available in Java 17 to enforce this restriction at the compiler level. Which design provides the strongest compile-time safety and best expresses the architect's intent?

Accepted Answer

Define `PaymentMethod` as a `sealed` interface that explicitly `permits` only the `CreditCard`, `PayPal`, and `BankTransfer` classes/records to implement it.

Answer

Define `PaymentMethod` as a public abstract class. Place `CreditCard`, `PayPal`, and `BankTransfer` in the same package and make their constructors package-private.

Answer

Define `PaymentMethod` as a public interface. Implement it with `final` classes for `CreditCard`, `PayPal`, and `BankTransfer`.

Answer

Create an enum `PaymentType` with values `CREDIT_CARD`, `PAYPAL`, `BANK_TRANSFER`, and a factory class that returns instances of corresponding private classes.

Question 10

A developer is building a system that processes different geometric shapes. The following sealed interface is defined:

sealed interface Shape permits Circle, Rectangle {}
final class Circle implements Shape { /* ... */ }
final class Rectangle implements Shape { /* ... */ }

Later, another developer in a different package tries to define a new shape:

// in another package
public final class Triangle implements Shape { /* ... */ }

What is the result of this attempt?

Accepted Answer

The code fails to compile because `Triangle` is not in the `permits` list of the `Shape` interface.

Answer

The code compiles successfully, but will throw a runtime exception if a `Triangle` is instantiated.

Answer

The code compiles successfully, allowing `Triangle` to be a valid subtype of `Shape`.

Answer

The code fails to compile because `Triangle` must be in the same package as `Shape`.

Java SE 17 Developer (OCP) Practice Questions

Create an account to continue.

Create an account to continue.

Related exams