1Z0-829 Practice Test 36 — 15 Questions

Question 1

You are designing a logging framework for a microservices application. The framework must support multiple output destinations (console, file, database) and allow new destinations to be added without modifying existing code. Additionally, each destination should be able to format the log message differently. The team prefers composition over inheritance. Which design pattern should you recommend?

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

Accepted Answer

Observer pattern where the logger is the subject and each output destination is an observer. Formatting can be handled by each observer using a separate strategy.. The Observer pattern is correct because it decouples the logger (subject) from multiple output destinations (observers), allowing new destinations to be added without modifying existing code. Each observer can independently apply its own formatting logic, which aligns with the composition-over-inheritance principle and the requirement for per-destination formatting. This pattern directly supports the dynamic addition of observers at runtime, fulfilling the extensibility goal.

Answer

Template Method pattern where the logger defines the skeleton of logging, and subclasses override formatting and output steps.

Answer

Decorator pattern to wrap log messages with formatting, and add destinations by nesting decorators.

Answer

Factory Method pattern to create log messages, and each destination implements a different factory.

Question 2

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 3

A developer writes: ArrayList list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); Object[] arr = list.toArray(); arr[0] = "one"; What happens?

Accepted Answer

Compiles and runs, but arr[0] becomes "one". The `ArrayList.toArray()` method returns an `Object[]` array, not an `Integer[]`. Since the reference variable `arr` is declared as `Object[]`, the assignment is valid. Assigning a `String` to `arr[0]` is allowed because `Object[]` can hold any object type. No compilation or runtime error occurs because the array's runtime type is `Object[]`, and the assignment is type-safe at compile time and runtime.

Answer

Cannot cast String to Integer at runtime

Answer

Compilation error because toArray returns Integer[]

Answer

Runtime error

Question 4

A financial services company has a microservice that processes trade confirmations. The service receives a stream of Trade objects (with fields: id (long), symbol (String), quantity (int), price (double)) and needs to compute the total value (quantity * price) for each symbol, but only for trades with quantity > 0 and price > 0. The result should be a Map mapping symbol to total value. The current implementation uses a for loop with manual aggregation, but it is error-prone and difficult to parallelize. The team decides to refactor using the Stream API. The DataSource provides a Stream trades(). The code must be efficient and handle large datasets. Which approach best meets these requirements?

Accepted Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).collect(Collectors.groupingBy(Trade::symbol, Collectors.summingDouble(t -> t.quantity() * t.price()))). It uses `Collectors.groupingBy` with a downstream `Collectors.summingDouble` collector, which is the idiomatic and efficient way to group trades by symbol and sum their computed values (quantity * price) after filtering out invalid trades. This approach is concise, leverages the Stream API's built-in parallelization support, and avoids manual accumulation or mutable state issues.

Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).collect(Collectors.toMap(Trade::symbol, t -> t.quantity() * t.price(), Double::sum))

Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).collect(Collectors.toMap(Trade::symbol, t -> t.quantity() * t.price(), (v1, v2) -> v1 + v2))

Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).reduce(new HashMap<>(), (map, t) -> { map.merge(t.symbol(), t.quantity() * t.price(), Double::sum); return map; }, (m1, m2) -> { m1.putAll(m2); return m1; })

Question 5

A developer writes a class `Employee` with a private field `salary`. Which approach correctly allows subclasses to access `salary` directly without breaking encapsulation?

Accepted Answer

Change `salary` to protected.. The `protected` access modifier allows direct access to the `salary` field by subclasses (via inheritance) while still preventing access from unrelated classes outside the package. This strikes the balance between encapsulation (restricting access to the class hierarchy) and the requirement for subclass direct access.

Answer

Use package-private access (no modifier).

Answer

Make `salary` public.

Answer

Keep `salary` private and add a public getter method.

Question 6

Which TWO of the following are terminal operations on a stream? (Choose two.)

Accepted Answer

forEach. `forEach` is a terminal operation that consumes the stream, applying the provided action to each element and producing a side effect without returning a new stream. Option C is correct because `reduce` is a terminal operation that combines stream elements into a single result using an associative accumulation function, terminating the stream pipeline.

Answer

distinct

Answer

filter

Answer

map

Question 7

A developer is designing a loop to iterate through an array of integers and stop processing when the value -1 is encountered. Which loop construct should be used?

Accepted Answer

for(int i : array) { if(i == -1) break; }. The `break` statement immediately terminates the loop when the value -1 is encountered, which is exactly what the requirement specifies. In Java, `break` exits the innermost loop or switch statement, making it the appropriate control flow mechanism for stopping iteration upon a condition.

Answer

for(int i : array) { if(i == -1) exit; }

Answer

for(int i : array) { if(i == -1) return; }

Answer

for(int i : array) { if(i == -1) continue; }

Question 8

A developer is migrating a classpath-based application to modules. They have two JARs on the classpath that both contain a package with the same name, com.example.util. When they move both JARs to the module path, they encounter a module resolution error. What is the most likely cause?

Accepted Answer

Named modules cannot have split packages. In the Java module system, a package can be defined in at most one module on the module path. When both JARs contain com.example.util, moving them to the module path creates a split package, which is illegal for named modules. The module system enforces this to ensure reliable configuration and encapsulation, resulting in a module resolution error.

Answer

The --add-exports option is missing

Answer

The JARs need to be merged into one module

Answer

Automatic modules cannot have split packages

Question 9

A developer needs to process a stream of integers and collect the results into a Map> where keys are the integers themselves and values are lists containing the number and its square. Which collector should be used?

Accepted Answer

Collectors.toMap(Function.identity(), i -> Arrays.asList(i, i * i), (v1, v2) -> v1, HashMap::new). It uses the four-argument overload of `Collectors.toMap()`: a key mapper (`Function.identity()`), a value mapper (a lambda that creates a `List` containing the number and its square), a merge function (`(v1, v2) -> v1`) to handle duplicate keys (which won't occur here since keys are unique integers), and a `HashMap::new` supplier to ensure the map type is explicitly `HashMap`. This satisfies the requirement of producing a `Map>` where each key maps to a list of the number and its square.

Answer

Collectors.toMap(Function.identity(), i -> Arrays.asList(i, i * i), (v1, v2) -> v1)

Answer

Collectors.groupingBy(Function.identity(), Collectors.mapping(i -> i * i, Collectors.toList()))

Answer

Collectors.toMap(Function.identity(), i -> i * i)

Question 10

Which TWO are secure coding practices for Java I/O that help prevent resource leaks and unauthorized access? (Choose two.)

Accepted Answer

Mark sensitive fields in a Serializable class as transient to prevent serialization.. Marking sensitive fields as transient prevents them from being serialized, which mitigates the risk of exposing confidential data through serialization streams. This is a secure coding practice that directly addresses unauthorized access to sensitive information during I/O operations.

Answer

Use Scanner instead of BufferedReader when reading untrusted input.

Answer

Always use BufferedReader for reading text files to improve performance.

Answer

Grant FilePermission in the security policy to restrict file access for untrusted code.

Question 11

You are a DevOps engineer at a software house. Your team is preparing a Java 17 application for deployment. The application is modular and consists of 12 modules. They have been using the 'jlink' tool to create a custom runtime image for Linux. The image works fine on the development machines. However, when deployed to a minimal Docker container based on Alpine Linux, the application fails with: 'Error: Could not find or load main class com.example.Main'. The main class is declared in the module 'com.example.app' and the module-path is correctly set within the image. The image's bin directory contains the launcher scripts generated by jlink. The Docker container has only the bare minimum libraries. You have verified that the 'modules' file exists in the lib directory and contains 'com.example.app'. What is the most likely cause?

Accepted Answer

The launcher script in the image has a bash shebang and Alpine uses ash, causing the script to fail to execute properly.. The jlink tool generates launcher scripts with a bash shebang (#!/bin/bash) by default. Alpine Linux uses ash (a BusyBox shell) instead of bash, and if bash is not installed in the minimal container, the script fails to execute properly, resulting in the 'Could not find or load main class' error even though the module path and modules file are correct.

Answer

The main class is not exported by the module, so the launcher cannot find it.

Answer

The Alpine container is missing the glibc compatibility layer, causing the JVM to fail loading native libraries.

Answer

The module path in the launcher script does not include the application module.

Question 12

A financial application processes transactions as List objects. The application runs on a server with limited memory (2 GB heap). The development team observes that after processing a large number of transactions (over 10 million), heap usage spikes to near 1.8 GB and garbage collection pauses become frequent (over 5 seconds). The Transaction class is defined as public record Transaction(LocalDateTime timestamp, double amount, String category) {}. The current processing code reads all transactions from a database result set into an ArrayList using a loop with list.add(). Then the list is sorted by timestamp using Collections.sort(list, Comparator.comparing(Transaction::timestamp)). The sorted list is then iterated multiple times to generate various reports. The code runs in a single-threaded context. Which change would most effectively reduce peak memory usage while preserving the sorted report output?

Accepted Answer

Collect transactions into an array (Transaction[]) and sort using Arrays.sort().. Using an array (Transaction[]) with Arrays.sort() avoids the per-element overhead of ArrayList's internal Object[] and the additional memory consumed by the ArrayList object itself (e.g., capacity tracking, modCount). In a memory-constrained environment with 10 million transactions, the ArrayList wrapper adds roughly 40–80 MB of overhead (object header, internal array pointer, size, capacity fields), whereas a plain array has only the object header and the contiguous element references. This reduction in memory footprint directly lowers peak heap usage and reduces GC pause frequency.

Answer

Use a TreeMap> to group by timestamp, then flatten on iteration.

Answer

Use a SortedSet<Transaction> (java.util.TreeSet) with a comparator to store transactions in sorted order.

Answer

Use a parallel stream with .sorted() and collect to a ConcurrentLinkedDeque.

Question 13

Given the following code snippet:

```java
outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break outer;
        }
        System.out.print(i + "-" + j + " ");
    }
}
```

What is the output?

Accepted Answer

0-0 0-1 0-2 1-0. The labeled `break outer;` statement exits the outer loop entirely when `i == 1` and `j == 1`. Before that condition is met, the inner loop prints pairs for `i=0` (all j values 0,1,2) and for `i=1` with `j=0`. When `i=1` and `j=1`, the break occurs, so `1-1` is never printed, and the outer loop stops, preventing any further iterations.

Answer

0-0 0-1 0-2 1-0 1-1 1-2

Answer

0-0 0-1 0-2 1-0 2-0 2-1 2-2

Answer

0-0 0-1 0-2 1-0 1-1

Question 14

Which TWO are characteristics of a multi-release JAR (MR-JAR)?

Accepted Answer

The root of the JAR contains classes for the oldest supported version.. In a multi-release JAR (MR-JAR), the root of the JAR contains the classes compiled for the oldest supported Java version. This ensures backward compatibility: when the JAR is run on an older JVM that does not understand the META-INF/versions directory, it will use the classes from the root. The JVM automatically selects the appropriate versioned class from the META-INF/versions/<version>/ directory based on the major version of the running Java runtime.

Answer

The version directory must be named with the full version string like "9.0.4".

Answer

It can only contain a single version of each class.

Answer

It is created using the jlink tool.

Question 15

A company needs to process a stream of orders and filter out orders that are not in the 'SHIPPED' status. Then they want to collect the order IDs into a list. Which of the following correctly uses lambda expressions to achieve this?

Accepted Answer

orders.stream().filter(o -> o.getStatus().equals("SHIPPED")).map(Order::getId).collect(Collectors.toList()). It first filters the stream to include only orders with status 'SHIPPED' using a lambda expression that calls equals() on the status string, then maps each order to its ID using a method reference, and finally collects the IDs into a list. This correctly uses lambda expressions and the Stream API to achieve the requirement.

Answer

orders.stream().filter(o -> o.getStatus() != "SHIPPED").map(Order::getId).collect(Collectors.toList())

Answer

orders.stream().map(Order::getId).filter(id -> id.equals("SHIPPED")).collect(Collectors.toList())

Answer

orders.stream().filter(Order::getStatus).map(o -> o.getId()).collect(Collectors.toList())