1Z0-829 Practice Test 5 — 25 Questions

Question 1

Order the steps to handle checked exceptions in a method that throws IOException.

Accepted Answer

1. Locate the code that throws IOException. 2. Enclose the code in a try block. 3. Add a catch block for IOException. 4. Provide exception handling code in the catch block.. Checked exceptions must be either caught or declared in the method signature. Unhandled checked exceptions cause compilation errors.

Answer

1. Locate the code that throws IOException. 2. Add a catch block for IOException. 3. Enclose the code in a try block. 4. Add a finally block.

Answer

1. Locate the code that throws IOException. 2. Add a finally block. 3. Add a try block. 4. Add a catch block.

Answer

1. Locate the code that throws IOException. 2. Continue writing code without any exception handling. 3. Assume the program will not throw IOException. 4. Compile and ignore errors.

Question 2

Refer to the exhibit. What is the most likely cause of this exception?

Accepted Answer

The file contains non-object data (e.g., text) instead of a serialized Java object.. A `java.io.StreamCorruptedException` with the message 'invalid stream header: 546F6D' indicates that the input stream does not begin with the expected magic number `0xACED` (the standard Java serialization stream header). The hex value `546F6D` corresponds to the ASCII string 'Tom', which is plain text, not serialized object data. This occurs when a file containing non-object data (e.g., text) is read by `ObjectInputStream`.

Answer

The serialized object was tampered with after serialization.

Answer

The serial version UIDs of the class and stream do not match.

Answer

The stream's magic number is wrong due to a network error.

Question 3

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 4

Given a try-with-resources statement where both the try block and the close method of the resource throw exceptions, which of the following is true about exception handling?

Accepted Answer

The try block exception is the primary exception; the close exception is suppressed.. In a try-with-resources statement, if both the try block and the resource's close() method throw exceptions, the exception from the try block is the primary exception, and any exception thrown by close() is added as a suppressed exception. This is defined by Java's try-with-resources semantics (JLS §14.20.3.2), ensuring the primary exception is not masked by resource cleanup failures.

Answer

The exception from the close method is the primary exception.

Answer

Both exceptions are thrown simultaneously, causing a multi-catch.

Answer

The close method exception is ignored if the try block succeeds.

Question 5

A team is migrating a large legacy application from Java 8 to Java 17. The application consists of multiple JAR files that are placed on the classpath. Some of these JAR files have been updated to include module-info.class files, making them named modules. After migration, the application throws `IllegalAccessError` for several deep reflection calls that used to work in Java 8. The team has added `--add-opens` JVM flags to open the required packages, but the error persists. The application also uses a third-party library that is not modularized and is placed on the classpath. The team notices that the `--add-opens` flags are being ignored for packages in the modularized JARs. What is the most likely reason?

Accepted Answer

The modularized JARs are being loaded from the classpath, so they become unnamed modules, and `--add-opens` does not apply to unnamed modules.. When a JAR file containing a module-info.class is placed on the classpath instead of the module path, it is treated as an unnamed module. The `--add-opens` JVM flag only applies to named modules (those on the module path) and has no effect on unnamed modules. Since the modularized JARs are loaded from the classpath, they become unnamed modules, and the `--add-opens` flags are ignored, causing the `IllegalAccessError` to persist.

Answer

The `--add-opens` flags are being overridden by other JVM flags.

Answer

The application does not have a module-info.java file for its own code.

Answer

The classpath is deprecated and ignored in Java 17, so all JARs are treated as modules.

Question 6

A company uses jlink to create a custom runtime image. They want to reduce the image size by removing debug information. Which jlink option or plugin should they use?

Accepted Answer

--strip-debug. The `--strip-debug` option in jlink removes debug information from the custom runtime image, including line numbers, local variable tables, and source file references, which significantly reduces the image size. This is the correct option for stripping debug information, as it directly targets the removal of debugging metadata from the generated image.

Answer

--compress=2

Answer

--no-header-files

Answer

--bind-services

Question 7

A company processes financial transactions. Each transaction is represented by a Transaction object with fields: amount (double), currency (String), and type (String). The requirement is to compute the total amount of all transactions of type 'SALE' in USD. The transactions are stored in a List<Transaction>. Which code correctly accomplishes this using streams?

Accepted Answer

transactions.stream().filter(t -> t.type().equals("SALE") && t.currency().equals("USD")).mapToDouble(Transaction::amount).sum(). Ly filters transactions to only those with type 'SALE' and currency 'USD', then maps each to its amount as a double, and sums them using sum(). This satisfies the requirement exactly: total amount of 'SALE' transactions in USD.

Answer

transactions.stream().mapToDouble(Transaction::amount).filter(t -> t.type().equals("SALE")).sum()

Answer

transactions.stream().filter(t -> t.type().equals("SALE")).filter(t -> t.currency().equals("USD")).mapToDouble(Transaction::amount).sum()

Answer

transactions.stream().map(Transaction::amount).reduce(0.0, (a, b) -> a + b)

Question 8

Which of the following creates an immutable map with two entries?

Accepted Answer

Map.of("a",1,"b",2). `Map.of()` returns an immutable map containing exactly the key-value pairs provided as arguments. This factory method was introduced in Java 9 and creates a fixed-size, unmodifiable map with the two entries "a"→1 and "b"→2.

Answer

new HashMap<>(Map.of("a",1,"b",2))

Answer

Collections.emptyMap()

Answer

None of the above

Answer

new HashMap<>()

Question 9

Consider the following code snippet:

try {
    // some code
} catch (IOException e) {
    // handle
} catch (FileNotFoundException e) { // Line X
    // handle
}

What will be the result?

Accepted Answer

Compilation fails at Line X with an error about an exception already caught.. In Java, when catching exceptions, the more specific exception subclass must be caught before the more general superclass. FileNotFoundException is a subclass of IOException, so catching IOException first makes the catch for FileNotFoundException unreachable, causing a compilation error at Line X.

Answer

The code compiles and runs without issues.

Answer

The code compiles but throws a ClassCastException at runtime.

Answer

The code compiles but the second catch never executes.

Question 10

Which TWO statements about the switch statement in Java are true?

Accepted Answer

A break statement is optional.. In a Java switch statement, the break statement is optional. If omitted, execution falls through to the next case (fall-through behavior), which can be intentional or lead to bugs. This is a core feature of the switch construct, not a requirement.

Answer

A switch statement can be used as an expression in all cases.

Answer

The switch expression can be of type long.

Answer

The case values can be variables.

Question 11

A developer is implementing a cache that stores recent user sessions. The cache should maintain the most recently accessed session at the end, and when the cache reaches its maximum size (1000), it should remove the least recently accessed session (i.e., the oldest). The developer chooses a LinkedList to store sessions, adding new sessions at the end and removing from the front. However, performance is poor because searching for an existing session to update its position requires O(n) linear scan. Which collection should replace the LinkedList to improve performance while maintaining the removal order?

Accepted Answer

LinkedHashSet. LinkedHashSet (C) maintains insertion order (which can be used to represent access order if reinserted on access) and provides O(1) average-time complexity for add, remove, and contains operations. By removing and re-adding a session upon access, it moves to the end, and the oldest (first inserted) can be removed from the front when the size exceeds 1000, solving the O(n) scan problem of LinkedList.

Answer

TreeSet

Answer

HashSet

Answer

ArrayList

Question 12

A Java developer is building a modular application that uses only the `java.base` and `java.sql` modules. The application runs correctly with a full JDK 17 installation. The developer wants to distribute a minimal runtime image to reduce download size for end users. They have the application module JAR file and all dependencies are modular. The developer runs the command `jlink --module-path $JAVA_HOME/jmods:app --add-modules app --output myimage` but receives an error: "Error: java.sql module not found". What is the most likely cause of this error?

Accepted Answer

The `--add-modules` option was not specified for `java.sql`, so it is not included in the runtime image.. `jlink` only includes modules explicitly specified with `--add-modules` (plus their transitive dependencies) in the runtime image. The command only specifies `--add-modules app`, so `java.sql` is not included unless `app` requires it. Since the error says 'java.sql module not found', the most likely cause is that `java.sql` was not listed in `--add-modules` and is not a transitive dependency of `app`.

Answer

The `--add-modules` option can only be used with root modules, but `java.sql` is not a root module.

Answer

The `java.sql` module is not a standard JDK module and must be compiled separately.

Answer

The module path is missing the application's output directory.

Question 13

In a large enterprise application, a concurrent caching system is implemented using a ConcurrentHashMap that is accessed by multiple threads concurrently. The cache performs atomic operations on individual keys, but some operations require updates on multiple keys. To ensure consistency, the code acquires intrinsic locks on the keys using synchronized blocks. Over time, the system has been experiencing intermittent deadlocks. During post-mortem analysis, it was found that thread A holds a lock on key X and is waiting for key Y, while thread B holds a lock on key Y and is waiting for key X. The development team needs to redesign the locking strategy to eliminate these deadlocks while maintaining high throughput and minimizing code changes. They consider the following proposals: replacing ConcurrentHashMap with Collections.synchronizedMap, using a single ReentrantLock for all cache operations, always acquiring locks on keys in a consistent global order, or using a Lock with tryLock and a timeout and releasing all locks if timeout expires. Based on best practices in concurrent programming and considering the requirements to avoid deadlocks and maintain performance, which approach should they choose?

Accepted Answer

Use a Lock with tryLock and a timeout, and release all locks if timeout expires.. Using tryLock with a timeout allows threads to back off and release all acquired locks if they cannot obtain all required locks within a specified time, which breaks the circular wait condition that causes deadlocks. This approach maintains high throughput by avoiding coarse-grained locking and minimizes code changes by only modifying the lock acquisition logic, not the underlying ConcurrentHashMap structure.

Answer

Use a single ReentrantLock for all cache operations.

Answer

Replace ConcurrentHashMap with Collections.synchronizedMap.

Answer

Always acquire locks on keys in a consistent global order.

Question 14

Order the steps to compile and run a simple Java program from the command line.

Accepted Answer

Write the Java source code in a .java file, then compile with javac to produce a .class file, then run the class using java.. javac produces .class files; java runs the main method of the specified class. The classpath may need to be set if dependencies exist.

Answer

Write the Java source code in a .java file, then run with java, then compile with javac.

Answer

Compile with javac, then write the Java source code in a .java file, then run with java.

Answer

Run with java, then compile with javac, then write the Java source code in a .java file.

Question 15

A data analytics platform processes user activity logs. Each log entry is a LogRecord with fields: userId (int), action (String), timestamp (long). The requirement is to find the top 3 most active users (by count of actions) in the last hour. The logs are stored in a List<LogRecord> logs. The current solution sorts all records by userId and counts manually, but it's slow. The team decides to use streams with parallel processing. Which code correctly identifies the top 3 users?

Accepted Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.<Long, Long>comparingByValue().reversed()).limit(3).collect(Collectors.toList()). It first filters logs to only those within the last hour, then groups by userId and counts actions, sorts the resulting map entries by count in descending order, limits to the top 3, and collects the result. This uses parallelStream() for performance and correctly applies the required logic.

Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByKey()).limit(3).collect(Collectors.toList())

Answer

logs.parallelStream().collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue().reversed()).limit(3).collect(Collectors.toList())

Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::action, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue().reversed()).limit(3).collect(Collectors.toList())

Question 16

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?

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 17

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 18

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 19

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 20

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.