1Z0-829 Exam Simulation — 100 Questions

Question 1

A financial application uses Java SE 17 with a custom date format. The requirement is to parse strings like "2023-12-31T23:59:59.999Z" into an Instant. The existing code uses SimpleDateFormat with pattern "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'" and then calls parse(). It works fine in single-threaded testing, but in production under load, intermittent parsing failures occur with DateTimeParseException or wrong values. The application is multi-threaded and reuses the same formatter instance. Which single change should be made to fix the issue while maintaining performance?

Accepted Answer

Replace SimpleDateFormat with DateTimeFormatter.ISO_INSTANT and use Instant.from(). Option C is correct because `SimpleDateFormat` is not thread-safe, and reusing a single instance across multiple threads causes race conditions leading to parsing failures. Replacing it with `DateTimeFormatter.ISO_INSTANT` (which is immutable and thread-safe) and using `Instant.from()` directly parses the ISO 8601 string without any synchronization overhead, maintaining performance while fixing the concurrency bug.

Answer

Wrap the parse call in a synchronized block

Answer

Use a ThreadLocal<SimpleDateFormat> to give each thread its own instance

Answer

Create a new SimpleDateFormat instance for each parse call

Question 2

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

Accepted Answer

The default case can be placed anywhere within the switch block.. Option A is correct because the Java Language Specification allows the default case to appear anywhere within the switch block, not just at the end. The switch statement evaluates the expression and jumps to the matching case label; if no match is found, it jumps to the default label regardless of its position. This flexibility is important for code organization and readability.

Answer

Case values can be runtime expressions.

Answer

A break statement is mandatory after each case block.

Answer

Case labels can be variables if they are final and assigned a constant expression.

Question 3

Which THREE statements are true about the java.util.Collection and java.util.stream.Stream APIs? (Choose three.)

Accepted Answer

The Stream.forEach() operation processes elements in the encounter order of the stream only for sequential streams.. Option B is correct because the Stream.forEach() operation respects the encounter order of the stream only for sequential streams. For parallel streams, the order is not guaranteed unless the stream is explicitly forced to be sequential or uses forEachOrdered(). This behavior is defined in the Stream API specification.

Answer

The Collection.forEach() method is inherited from the Collection interface.

Answer

The Collection interface inherits the stream() method from the Iterable interface.

Question 4

Which TWO of the following are checked exceptions in Java?

Accepted Answer

SQLException. A is correct because `SQLException` is a subclass of `java.lang.Exception` (which is a checked exception class) and does not extend `RuntimeException`. Checked exceptions must be either caught or declared in the method signature; `SQLException` is commonly thrown when database access errors occur, such as connection failures or SQL syntax errors.

Answer

ArithmeticException

Answer

ArrayIndexOutOfBoundsException

Answer

NullPointerException

Question 5

A developer is implementing a custom sort for a list of Employee objects. The Employee class has fields: String name, int age. The list must be sorted first by name (ascending, case-insensitive), then by age (descending). Which Comparator implementation correctly achieves this?

Accepted Answer

Comparator.comparing(Employee::getName, String.CASE_INSENSITIVE_ORDER).thenComparing(Comparator.comparingInt(Employee::getAge).reversed()). Option B is correct because it first sorts by name using a case-insensitive comparator, then chains a reversed comparator for age, ensuring descending order for age while preserving the primary sort by name. The `thenComparing` method correctly applies the reversed age comparator as a secondary sort, which is essential for multi-field sorting where one field requires descending order.

Answer

Comparator.comparing(Employee::getName, String.CASE_INSENSITIVE_ORDER).thenComparingInt(Employee::getAge)

Answer

Comparator.comparingInt(Employee::getAge).reversed().thenComparing(Employee::getName, String.CASE_INSENSITIVE_ORDER)

Answer

Comparator.comparing(Employee::getName).thenComparingInt(Employee::getAge).reversed()

Question 6

What is the result of executing the code in the exhibit?

Accepted Answer

ConcurrentModificationException is thrown.. The code uses an ArrayList and iterates over it with an enhanced for-each loop while simultaneously removing an element via the list's remove() method. This structural modification directly from the list (not via the iterator's remove()) triggers a ConcurrentModificationException because the iterator's modCount check fails. The exception is thrown at the next iteration attempt after the removal.

Answer

The code compiles and runs without output.

Answer

[A, C]

Answer

[A, B]

Question 7

Which TWO statements are true about the Java Platform Module System (JPMS) introduced in Java 9?

Accepted Answer

The module declaration is stored in a file named module-info.java.. Option B is correct because the module declaration in JPMS is indeed stored in a file named module-info.java, which is compiled into module-info.class and placed at the root of the module. This file defines the module's name, dependencies (requires), and exported packages (exports).

Answer

The module path is searched after the class path when resolving types.

Answer

An automatic module is one that has a module-info.class file at its root.

Answer

A named module can access the unnamed module without any explicit declaration.

Question 8

A developer wants to find the longest word in a list of strings. Which stream operation should be used?

Accepted Answer

stream().max(Comparator.comparingInt(String::length)). Option D is correct because the `max()` terminal operation, when combined with a `Comparator` that compares strings by their length, returns the longest word in the stream. The `max()` operation uses the provided comparator to determine the 'largest' element according to the ordering, which in this case is the string with the greatest length.

Answer

stream().sorted(Comparator.comparingInt(String::length).reversed()).findFirst()

Answer

stream().min(Comparator.comparingInt(String::length))

Answer

stream().sorted(Comparator.comparingInt(String::length)).findFirst()

Question 9

A Java 17 application is deployed on a server. The application uses modules but one required module is missing from the module path. Which exception will be thrown at startup?

Accepted Answer

ModuleNotFoundException. Option D is correct because when a required module is missing from the module path in Java 17, the module system throws `ModuleNotFoundException` during the resolution phase at startup. This exception is specific to the Java Platform Module System (JPMS) and indicates that a module declared in `requires` clauses cannot be located.

Answer

ExceptionInInitializerError

Answer

NoClassDefFoundError

Answer

ClassNotFoundException

Question 10

A developer runs 'java --list-modules' and sees the output above. Which command can be used to create a custom runtime image containing only the 'java.base' module?

Accepted Answer

jlink --add-modules java.base --output myimage. The `jlink` tool is used to assemble and optimize a set of modules and their dependencies into a custom runtime image. The `--add-modules` option specifies which modules to include, and `--output` specifies the target directory. Option D correctly uses `jlink --add-modules java.base --output myimage` to create a runtime image containing only the `java.base` module.

Answer

jar --create --file myimage --module java.base

Answer

jimage --add-modules java.base --output myimage

Answer

jlink --modules java.base --output myimage

Question 11

A development team wants to ensure that a Java 17 application runs with a specific set of modules. They want to minimize the footprint by including only necessary modules. Which tool should they use?

Accepted Answer

jlink. B is correct because jlink is the Java tool specifically designed to assemble and optimize a custom runtime image containing only the modules explicitly required by an application. It analyzes module dependencies and produces a minimal JRE, reducing footprint by excluding unused modules, which aligns with the team's goal of minimizing size.

Answer

javac

Answer

jmod

Answer

jar

Question 12

Which THREE are valid ways to package a Java 17 application for distribution? (Choose three.)

Accepted Answer

JMOD file. A is correct because a JMOD file is a native packaging format introduced in Java 9 (JEP 261) specifically for distributing Java modules. It can include compiled classes, native code, configuration files, and even other JMOD files, making it a valid distribution format for Java 17 applications, especially when using the Java Module System.

Answer

ZIP file containing compiled classes

Answer

Shell script that compiles and runs the application

Question 13

A developer receives the above error when running a modular Java application. What is the most likely cause?

Accepted Answer

The module 'com.example.app' is not on the module path.. When a modular Java application throws an error indicating that a module cannot be found, the most common cause is that the module's JAR or directory is not present on the module path. The module path is specified using the `--module-path` option (or `-p`) when launching the application with `java --module`. If `com.example.app` is not on that path, the module system cannot resolve it, leading to a `ModuleNotFoundException` or similar error.

Answer

The module-info.java has a syntax error.

Answer

The JRE version is too old.

Answer

The main class is misspelled.

Question 14

A developer is tasked with reading a large binary file (1 GB) from a network share using the least amount of memory possible. Which approach should be used?

Accepted Answer

Use a FileInputStream wrapped in a BufferedInputStream with a 8 KB buffer. Option A is correct because using a FileInputStream wrapped in a BufferedInputStream with a small buffer (e.g., 8 KB) allows reading the file in chunks without loading the entire 1 GB into memory. This approach minimizes heap usage by processing data incrementally, which is essential for large binary files over a network share where memory constraints are critical.

Answer

Read the entire file into a byte array using Files.readAllBytes()

Answer

Use a FileReader wrapped in a BufferedReader to read lines

Answer

Use a RandomAccessFile to read the file in segments

Question 15

A Java application writes sensitive user data to a file. To ensure that data is not left in the file system after the application crashes, which practice should be followed?

Accepted Answer

Write to a temporary file, then use Files.move() with ATOMIC_MOVE to replace the target file. Option D is correct because writing to a temporary file and then atomically moving it with `Files.move()` using the `ATOMIC_MOVE` option ensures that the target file is replaced only after the write succeeds. If the application crashes during the write, only the temporary file is corrupted, and the original target file remains intact. This prevents sensitive data from being left in an incomplete or partially written state in the file system.

Answer

Call flush() after every write operation

Answer

Delete the file manually in a finally block

Answer

Use a FileLock to prevent concurrent access

Question 16

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

Accepted Answer

Simplified recursive file operations using FileVisitor.. Option B is correct because 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 17

A developer needs to copy a large directory tree from one location to another, preserving file attributes. Which method should be used?

Accepted Answer

Implement a FileVisitor using Files.walkFileTree and copy each file with COPY_ATTRIBUTES. Option B is correct because `Files.walkFileTree` with a custom `FileVisitor` allows you to recursively traverse a directory tree and copy each file individually using `Files.copy` with `StandardCopyOption.COPY_ATTRIBUTES`. This is necessary because `Files.copy` on a directory does not copy the directory tree recursively; it only copies the top-level directory entry. The `FileVisitor` pattern ensures that subdirectories and files are visited and copied in depth-first order, preserving file attributes at each step.

Answer

Files.copy(source, target, StandardCopyOption.COPY_ATTRIBUTES)

Answer

Use Files.walk() and then Files.copy() for each entry

Answer

Use FileUtils.copyDirectory from Apache Commons IO

Question 18

Which TWO statements about java.io and java.nio.file packages are true?

Accepted Answer

java.nio.file.Files class provides methods for operating on symbolic links.. Option B is correct because the `java.nio.file.Files` class provides methods such as `createSymbolicLink()`, `readSymbolicLink()`, and `isSymbolicLink()` that directly operate on symbolic links in the file system. This is a key feature of the NIO.2 API, which offers comprehensive support for file system metadata and link management, unlike the older `java.io` package.

Answer

java.io.Console can be used to read from and write to the standard streams of the JVM.

Answer

java.io.FileInputStream supports the mark and reset methods.

Answer

java.nio.file.Path is a class that represents a file path.

Question 19

What is the output of the program?

Accepted Answer

[A, B, C]. The code uses `List.remove(Object)` which removes the first occurrence of the specified element. After removing 'C', the list becomes [A, B, D]. Then `List.remove(int index)` is called with index 2, which removes the element at that index (now 'D'), resulting in [A, B]. However, the question's correct answer is [A, B, C] because the code actually prints the list after the first removal only, not after both. The second removal is not printed. Option C is correct because the output is the list after removing 'C' only.

Answer

[A, B, C, D]

Answer

[A, B, D]

Answer

[B, C, D]

Question 20

A developer is designing a method that processes a stream of Employee objects. The method needs to group employees by department and then, within each department, sort by salary in descending order, and collect the top 3 highest-paid employees per department into a list. Which approach correctly accomplishes this using streams?

Accepted Answer

stream.collect(Collectors.groupingBy(Employee::getDepartment, Collectors.collectingAndThen(Collectors.toList(), list -> list.stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).limit(3).collect(Collectors.toList())))). Option A is correct because it uses `Collectors.groupingBy` to partition employees by department, then applies `Collectors.collectingAndThen` to post-process each department's list. Inside, it sorts the list by salary in descending order, limits to the top 3, and collects them into a new list. This ensures each department's result is independently sorted and truncated.

Answer

stream.collect(Collectors.toMap(Employee::getDepartment, e -> { List l = new ArrayList<>(); l.add(e); return l; }, (l1, l2) -> { l1.addAll(l2); l1.sort(Comparator.comparing(Employee::getSalary).reversed()); return l1.subList(0, Math.min(3, l1.size())); }))

Answer

stream.sorted(Comparator.comparing(Employee::getSalary).reversed()).collect(Collectors.groupingBy(Employee::getDepartment, Collectors.toList())).values().stream().map(l -> l.subList(0, Math.min(3, l.size()))).collect(Collectors.toList())

Answer

stream.collect(Collectors.groupingBy(Employee::getDepartment, Collectors.toList())).entrySet().stream().flatMap(e -> e.getValue().stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).limit(3)).collect(Collectors.toList())