1Z0-829 Practice Test 12 — 15 Questions

Question 1

A developer is building a file synchronization tool that runs on multiple threads. Multiple threads may read and write to the same file concurrently. The developer wants to ensure that a thread does not read a file while another thread is writing to it, and that concurrent reads are allowed. Which locking mechanism should be used?

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

Accepted Answer

Use java.nio.channels.FileLock with shared lock for reading and exclusive lock for writing.. Java.nio.channels.FileLock provides a platform-independent mechanism for locking files, supporting shared locks for concurrent reads and exclusive locks for writes. This ensures that a thread cannot read a file while another thread is writing to it, while allowing multiple threads to read simultaneously, which matches the requirement exactly.

Answer

Use a ReentrantReadWriteLock in Java with the file as a resource.

Answer

Use synchronized blocks on the File object.

Answer

Use a Semaphore with permits equal to the number of threads.

Question 2

A company's Java 17 application processes large log files and stores word counts. Initially, they used a TreeMap to maintain sorted word counts. After adding 10 million entries, insertion performance became unacceptably slow. The team switched to a HashMap for fast insertions, but now they need to produce sorted reports. They are considering two approaches: (1) Keep the HashMap and, when a sorted report is needed, extract all entries into an ArrayList> and sort it using Collections.sort with a comparator, or (2) Use a ConcurrentSkipListMap instead. The application is single-threaded, and reports are requested infrequently. What is the best course of action?

Accepted Answer

Use HashMap and sort with Collections.sort when needed. The application is single-threaded and reports are infrequent, so the overhead of sorting a HashMap's entries only when needed is acceptable and avoids the continuous insertion cost of a TreeMap. HashMap provides O(1) insertions, and sorting an ArrayList of 10 million entries with Collections.sort (which uses TimSort, O(n log n)) is efficient for occasional use, making this the best balance of performance and simplicity.

Answer

Use ConcurrentSkipListMap

Answer

Use LinkedHashMap and convert to sorted list when needed

Answer

Revert to TreeMap because it always keeps data sorted

Question 3

A development team is working on a Java 17 application that must be packaged as a custom runtime image for deployment on a Linux server without a JDK installed. The application uses `java.base`, `java.logging`, and `java.sql` modules, and also requires the `jdk.crypto.cryptoki` module for hardware security module (HSM) integration. The team wants to minimize the image size while ensuring all necessary modules are included. They run `jlink --add-modules java.base,java.logging,java.sql,jdk.crypto.cryptoki --output myapp-runtime`. The resulting image runs the application but fails at startup with a `ClassNotFoundException` for `javax.crypto.spec.SecretKeySpec`. Which action should the team take to resolve the issue?

Accepted Answer

Add `--bind-services` to the jlink command to include service provider modules.. The `jdk.crypto.cryptoki` module is a service provider module that provides cryptographic services via the Java Cryptography Architecture (JCA). When using `jlink`, service provider modules are not automatically included unless `--bind-services` is specified, because `jlink` only includes modules directly referenced in the module graph. The `javax.crypto.spec.SecretKeySpec` class is part of `java.base`, but the actual provider implementation that makes it available at runtime is in `jdk.crypto.cryptoki`; without `--bind-services`, the service linkage is missing, causing the `ClassNotFoundException`.

Answer

Manually add the `java.security.jgss` module to the `--add-modules` list.

Answer

Use the `--list-modules` option with jlink to verify which modules are included, then add any missing ones.

Answer

Add `ALL-MODULE-PATH` to the `--add-modules` list to include all available modules.

Question 4

A developer is converting legacy for loops to streams. The legacy code: List list = new ArrayList<>(); for (String s : strings) { if (s.length() > 5) { list.add(s.length()); } } They write: List list = strings.stream() .filter(s -> s.length() > 5) .map(s -> s.length()) .collect(Collectors.toList()); But it doesn't compile. The error is: 'cannot find symbol: method collect(Collector>)'. What is the likely issue?

Accepted Answer

The map operation returns an IntStream, which does not have a collect method. Use map(s -> s.length()).boxed().collect(...) or mapToInt(...).boxed().. The issue is that `map(s -> s.length())` on a `Stream` returns an `IntStream`, not a `Stream`. The `IntStream` interface does not have a `collect(Collector)` method; it only has `collect(Supplier, BiConsumer, BiConsumer)`. To use `Collectors.toList()`, you must convert the `IntStream` back to a `Stream` via `.boxed()`, or use `mapToInt(...).boxed()`, or use `map(s -> (Integer) s.length())` to keep a `Stream`.

Answer

The lambda in filter is incorrectly written; it should be s.length > 5.

Answer

The stream should be made unordered to allow the collector to function.

Answer

Use parallelStream() to enable the collect method.

Question 5

A web server logs user sessions. Each session has a unique session ID (String) and a last access time (long). The system needs to evict sessions that have been inactive for more than 30 minutes. The current implementation uses a HashMap<String, Long> to store session IDs and last access times. A scheduled task iterates over all entries and removes those where currentTime - lastAccess > 30 minutes. However, this iteration is becoming slow as the number of sessions grows (millions). The developer wants to improve the eviction performance without affecting the O(1) put and get operations. Which approach should be taken?

Accepted Answer

Use LinkedHashMap<String, Long> with access-order=true and override removeEldestEntry() to evict entries older than 30 minutes.. LinkedHashMap with access-order=true and a custom removeEldestEntry() method provides O(1) amortized put/get operations while automatically evicting the least-recently accessed entry when a condition is met. By overriding removeEldestEntry() to check if the eldest entry's last access time is older than 30 minutes, the eviction happens during put operations without requiring a separate iteration over all entries, thus solving the performance issue.

Answer

Use PriorityQueue<Session> ordered by last access time and update the time when accessed.

Answer

Use ConcurrentHashMap<String, Long> and use parallel streams to remove expired entries.

Answer

Use TreeMap<String, Long> sorted by last access time and poll the first entry if too old.

Question 6

Which TWO statements about Java interfaces are true? (Choose two.)

Accepted Answer

Interfaces can contain static methods with a body.. Since Java 8, interfaces can contain static methods with a body. These static methods belong to the interface itself and are not inherited by implementing classes, allowing utility methods to be defined directly within the interface.

Answer

An interface can extend at most one other interface.

Answer

Fields in an interface can be declared as protected.

Answer

Default methods are used to prevent method overriding.

Question 7

A Java application packaged as a JAR file with a manifest containing `Main-Class: com.example.Main` is correctly run using `java -jar app.jar`. However, when run with `java -cp app.jar com.example.Main`, it throws a `NoClassDefFoundError` for a class `com.example.helper.Util`. What is the most likely cause?

Accepted Answer

The JAR's manifest Class-Path entry is not being honored when using -cp.. When using `java -jar`, the JVM reads the manifest's `Class-Path` entry to locate dependencies. However, when using `-cp` (or `-classpath`), the manifest's `Class-Path` is ignored; the classpath is determined solely by the `-cp` argument. Since `com.example.helper.Util` is not on the explicit classpath, a `NoClassDefFoundError` occurs. This is a fundamental difference in how the JVM resolves classpaths between the two launch modes.

Answer

The Util class is missing from the JAR.

Answer

The -jar option automatically adds the JAR's dependencies to the classpath.

Answer

The main class name is misspelled.

Question 8

Which two statements are true about the peek method of the Stream API? (Choose two.)

Accepted Answer

It is primarily used for debugging purposes.. The `peek` method is designed as a debugging aid to observe elements as they flow through a stream pipeline. It performs the provided action on each element without modifying them, making it ideal for logging or printing intermediate states.

Answer

It can be used to modify the elements of the stream.

Answer

It is a terminal operation.

Answer

It can be used to transform the elements into a new value.

Question 9

Which TWO access modifiers can be applied to a top-level class in Java? (Choose two.)

Accepted Answer

package-private (no modifier). In Java, a top-level class can only have two access modifiers: public or package-private (no modifier). Package-private is the default access level when no modifier is specified, allowing the class to be accessible only within its own package. This is defined by the Java Language Specification (JLS §8.1.1).

Answer

static

Answer

protected

Answer

private

Question 10

Match each Java 17 feature to its description.

Accepted Answer

Sealed Classes: A feature that allows a class or interface to restrict which other classes or interfaces may extend or implement it.. These are key features introduced or enhanced in recent Java versions including 17.

Answer

Enhanced NullPointerExceptions: A feature that allows a class to restrict which subclasses can implement it.

Answer

Switch Expressions: A preview feature that allows testing an expression against a pattern using switch.

Question 11

Refer to the exhibit. A security policy file is configured as shown. The application in app.jar tries to read a file named "${user.home}/data/db.properties". What is the result?

Accepted Answer

Access is allowed because app.jar has AllPermission.. The security policy grants AllPermission to app.jar, which supersedes any specific file permissions. AllPermission implies every possible permission, including read access to any file, regardless of path restrictions. Therefore, the application can read '${user.home}/data/db.properties' without denial.

Answer

Access is denied because the FilePermission for data files is missing.

Answer

Access is denied because app.jar's AllPermission is not sufficient.

Answer

Access is allowed because the first grant includes read permission for logs/-, which covers data.

Question 12

A developer uses a parallel stream to process a large collection and wants to collect results into a List while preserving encounter order. Which of the following collectors will guarantee order preservation?

Accepted Answer

collect(ArrayList::new, List::add, List::addAll). The custom collector using `ArrayList::new`, `List::add`, and `List::addAll` explicitly specifies an insertion-ordered collection (`ArrayList`) and uses the combiner `List::addAll`, which preserves the encounter order when merging partial results from parallel streams. The `Collectors.toList()` and `Collectors.toUnmodifiableList()` do not guarantee order preservation in parallel streams, as their internal implementations may use non-ordered structures like `HashSet` during accumulation.

Answer

collect(Collectors.toUnmodifiableList())

Answer

collect(Collectors.toList())

Answer

collect(Collectors.toMap(Function.identity(), v->v))

Answer

collect(Collectors.toCollection(TreeSet::new))

Question 13

A financial trading system uses a Java application to process market data. The core algorithm uses nested loops to compare price arrays. The developer uses a labeled continue statement to skip certain combinations. After a code review, the team suspects the algorithm has a bug that causes incorrect results. The developer writes a unit test and discovers that the labeled continue sometimes skips more iterations than intended. The code is: outer: for (int i = 0; i < prices1.length; i++) { for (int j = 0; j < prices2.length; j++) { if (prices1[i] < prices2[j]) continue outer; // process combination } } The developer intended that if any price in prices1 is less than a price in prices2, the entire row (i) should be skipped. However, the algorithm skips rows even when the condition is not met for all j. What is the most likely cause?

Accepted Answer

The condition for continuing is not correctly evaluated.. The developer intended to skip the i-th row only if for every j, prices1[i] < prices2[j]. However, the condition currently uses an inequality that triggers on any j, causing rows to be skipped prematurely. The bug is that the condition is not correctly evaluating the intended logic; it should check that the condition holds for all j, not just one. Therefore, the correct answer is C.

Answer

A break statement is missing after processing a combination.

Answer

The label outer is placed on the inner loop, not the outer loop.

Answer

The continue outer statement should be a break outer.

Question 14

Which THREE statements are true about the enhanced for loop in Java?

Accepted Answer

The enhanced for loop internally uses an iterator for collections.. The enhanced for loop (for-each) over a collection internally uses an Iterator obtained from the collection's iterator() method. This is specified in the Java Language Specification (JLS 14.14.2) and is the mechanism that allows sequential access to each element without exposing the iterator directly.

Answer

If the underlying collection is modified during iteration, the loop will continue without error.

Answer

The loop variable must be declared final in the loop header.

Question 15

A Java application processes a list of orders. Each order has a status: NEW, PROCESSING, SHIPPED, or DELIVERED. The code must print a message based on the status:
- If NEW: "Order received"
- If PROCESSING: "Order in progress"
- If SHIPPED: "Order shipped"
- If DELIVERED: "Order delivered"
- For any other status: "Unknown status"

The developer writes the following code using a switch expression:

String message = switch (status) {
    case NEW -> "Order received";
    case PROCESSING -> "Order in progress";
    case SHIPPED -> "Order shipped";
    case DELIVERED -> "Order delivered";
    default -> "Unknown status";
};
System.out.println(message);

What is the correct course of action to ensure the code compiles and runs correctly?

Accepted Answer

No change needed; the code compiles and runs as expected.. The switch expression shown is syntactically valid and complete. It uses the arrow syntax with all enum constants covered and includes a default branch to handle any other status, so it compiles and runs as expected. Switch expressions can yield values and work with enum types, making the code correct as written.

Answer

Add a default branch to handle any other status.

Answer

Use if-else if statements because switch cannot be used with enum types.

Answer

Change the switch expression to a switch statement because switch expressions cannot yield values.