1Z0-829 Practice Test 20 — 15 Questions

Question 1

Arrange the steps to read a file using NIO.2 Files.lines() in Java.

Accepted Answer

1. Create a Path object using Paths.get("file.txt"). 2. Call Files.lines(path) to obtain a Stream<String>. 3. Process the stream using stream operations like forEach, filter, etc. 4. Close the stream by calling close() or using try-with-resources.. Files.lines() returns a Stream that must be closed to release file handles. The stream is lazily populated.

Answer

1. Call Files.lines("file.txt") directly with a string. 2. Create a Path object. 3. Process the stream. 4. Close the stream.

Answer

1. Create a Path object. 2. Process the stream (e.g., apply operations). 3. Call Files.lines(path) to get the stream. 4. Close the stream.

Answer

1. Create a Path object. 2. Call Files.lines(path) to get the stream. 3. Close the stream. 4. Process the stream.

Question 2

A developer has created a modular Java application. They want to distribute a minimal runtime image containing only the required 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 minimal runtime image containing only the modules explicitly required by the application and its transitive dependencies. It links the specified modules and their dependencies into a custom JRE that excludes unused modules, reducing footprint for distribution.

Answer

javac

Answer

jar

Answer

jpackage

Question 3

A financial trading application processes real-time stock data from multiple exchanges. The application reads large binary files (each up to 500 MB) containing trade records, processes them, and writes summary reports to a shared network drive. The development team observes that the application occasionally throws a java.io.IOException: 'The process cannot access the file because it is being used by another process' when writing reports. The application is multi-threaded, and each thread writes to a separate file in the same directory. The team also notices that the application slows down significantly when the network drive is under heavy load. The application runs on Windows servers with Java 17. The code uses FileOutputStream for writing and does not explicitly close streams in some paths. Which course of action should the team take to resolve the issues and improve performance?

Accepted Answer

Switch to using try-with-resources for all FileOutputStream instances and wrap them in BufferedOutputStream with a larger buffer.. The primary issue is resource leaks from not closing FileOutputStream instances, which can cause file locking conflicts on Windows when multiple threads write to separate files in the same directory. Using try-with-resources ensures streams are closed reliably, eliminating the 'file in use' IOException. Wrapping with BufferedOutputStream and a larger buffer reduces the number of write operations to the network drive, mitigating slowdowns under heavy load by batching data and minimizing latency.

Answer

Increase the thread pool size to handle more concurrent writes.

Answer

Use FileChannel with FileLock to synchronize access.

Answer

Write to local temporary files and then copy to the network drive.

Question 4

A team is implementing a parallel stream to process a large dataset. They notice that the operation is slower than expected. Which change is most likely to improve performance?

Accepted Answer

Ensure the stream source is an ArrayList and the operation is stateless and associative.. Parallel stream performance depends on the stream source being efficiently splittable (like an ArrayList, which has O(1) random access and can be split evenly) and the operation being stateless and associative to avoid synchronization overhead and ensure correct results. A poorly splittable source (e.g., LinkedList) or stateful operations can cause contention and reduce parallelism gains.

Answer

Use a sequential stream.

Answer

Use a custom Collector instead of reduce.

Answer

Increase the parallelism level by setting -Djava.util.concurrent.ForkJoinPool.common.parallelism=100.

Question 5

Which TWO secure coding practices should be followed when developing a Java application that handles user input? (Choose two.)

Accepted Answer

Use PreparedStatement for database queries with user input.. Option A is correct because using PreparedStatement with parameterized queries ensures user input is treated as data rather than executable SQL, which prevents SQL injection attacks in Java applications. Option D is correct because validating and sanitizing all user input before processing enforces allowlist-based input constraints and removes or neutralizes dangerous characters, mitigating injection, XSS, and malformed-data attacks. Option B is incorrect because serializing sensitive data without encryption exposes it to interception or unauthorized disclosure, and performance is never a valid reason to skip encryption. Option C is incorrect because granting java.security.AllPermission to the application's codebase disables the Java security manager's protections and gives the code unrestricted access, violating least privilege. Option E is incorrect because java.util.Random is a predictable linear congruential generator and must not be used for security tokens; java.security.SecureRandom should be used instead.

Answer

Serialize sensitive data without encryption for performance.

Answer

Grant java.security.AllPermission to the application's codebase.

Answer

Use java.util.Random for generating session tokens.

Question 6

A developer needs to create a temporary file that will be automatically deleted when the JVM terminates. Which approach correctly achieves this?

Accepted Answer

File.createTempFile("pre", ".txt").deleteOnExit(). `File.createTempFile("pre", ".txt")` creates a temporary file in the default temporary-file directory, and chaining `.deleteOnExit()` registers that file for deletion when the JVM terminates. This combination ensures both the creation of a temporary file and its automatic cleanup upon JVM shutdown, fulfilling the requirement precisely.

Answer

new File("tmp.txt").deleteOnExit()

Answer

Files.createTempDirectory("tmp").toFile().deleteOnExit()

Answer

Files.createTempFile("pre", ".txt")

Question 7

Given: Map map = new HashMap<>(); map.put("A", 1); map.put("B", 2); map.merge("A", 3, (v1, v2) -> v1 + v2); System.out.println(map.get("A")); What is the result?

Accepted Answer

4. (4) because the `merge` method on a Map associates the key "A" with the result of applying the remapping function `(v1, v2) -> v1 + v2` to the current value (1) and the given value (3), producing 1 + 3 = 4. If the key had been absent, the new value would be 3, but since it is present, the function is invoked and the result replaces the old value.

Answer

1

Answer

3

Answer

null

Question 8

Given the following code snippet: `List list = new ArrayList<>(); list.add(10); list.add(20); list.remove(1); System.out.println(list);` What is the output?

Accepted Answer

[10]. The code creates an ArrayList, adds 10 at index 0 and 20 at index 1. Then `list.remove(1)` removes the element at index 1, which is 20. The list now contains only [10]. Option D is correct because `remove(int index)` removes the element at the specified position, not the value.

Answer

[10, 20]

Answer

[]

Answer

[20]

Question 9

What will be the result of the following code?
Object[] arr = new Integer[5];
arr[0] = "String";

Accepted Answer

ArrayStoreException at runtime. The code creates an array of type `Integer[]` referenced by an `Object[]` variable. At runtime, the array's actual component type is `Integer`, so attempting to store a `String` violates the array's type constraint and throws an `ArrayStoreException`.

Answer

Successfully stores "String"

Answer

Compilation error

Answer

ClassCastException

Question 10

Which Map implementation guarantees that keys are sorted in their natural order?

Accepted Answer

TreeMap. TreeMap implements the SortedMap interface, which ensures that keys are stored in their natural ordering (as defined by Comparable) or by a provided Comparator. This makes TreeMap the only standard Map implementation that guarantees sorted keys without external sorting.

Answer

Hashtable

Answer

LinkedHashMap

Answer

HashMap

Question 11

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 12

A team uses 'jlink' to create a custom runtime image for a modular application. They run the following command: 'jlink --module-path $JAVA_HOME/jmods:myapp --add-modules com.example.myapp --output myimage'. The application requires several non-Java native libraries (e.g., .so files) that are loaded via System.loadLibrary(). After creating the image, the application fails with an UnsatisfiedLinkError. What is the most likely cause?

Accepted Answer

The native libraries were not included in the image; they must be manually copied or added using --add-modules and a custom module.. The `jlink` tool creates a runtime image that includes only Java modules and their dependencies, not native libraries (e.g., .so files). Native libraries must be manually placed into the image's library path (e.g., `lib/` or `bin/` directory) or packaged into a custom module that is added via `--add-modules`. The `UnsatisfiedLinkError` occurs because `System.loadLibrary()` cannot find the native library in the image's expected locations.

Answer

The native library loading requires a module that exports the package containing the native method.

Answer

The --add-modules flag omitted transitive dependencies of com.example.myapp.

Answer

The --module-path must also include the directories containing the native libraries.

Question 13

Which loop construct guarantees that the body executes at least once?

Accepted Answer

do-while loop. The do-while loop is the only loop construct in Java that guarantees the body executes at least once because the condition is evaluated after the loop body. This post-test loop design ensures that regardless of the initial condition value, the body runs before any check occurs.

Answer

for loop

Answer

enhanced for loop

Answer

while loop

Question 14

Which TWO are valid multi-catch statements in Java 17? (Choose two.)

Accepted Answer

catch (SQLException | IOException e). Option A is correct because catch (SQLException | IOException e) is a valid multi-catch: SQLException and IOException are unrelated checked exception types (neither is a subclass of the other), so the alternatives are disjoint and the compiler accepts them. Option E is correct because catch (IOException | RuntimeException e) combines a checked exception with an unchecked exception that are unrelated in the class hierarchy, which is also legal in Java 7+ multi-catch syntax. Option B is invalid because Exception is a supertype of RuntimeException, so the alternatives are not disjoint and the compiler rejects the redundancy. Option C is invalid for the same reason: SQLException is a subclass of Exception, making the multi-catch alternatives related by inheritance. Option D is invalid because FileNotFoundException is a subclass of IOException, so listing both in one multi-catch is a compile-time error.

Answer

catch (Exception | RuntimeException e)

Answer

catch (SQLException | Exception e)

Answer

catch (IOException | FileNotFoundException e)

Question 15

Given the code snippet:
int x = 10;
if (x > 5) {
    System.out.print("A");
} else if (x > 7) {
    System.out.print("B");
} else {
    System.out.print("C");
}
What is the output?

Accepted Answer

A. The if-else chain evaluates conditions sequentially. Since x=10 satisfies x > 5, the first block executes and prints 'A'. The else if and else branches are skipped entirely because the first condition was true. Thus, only 'A' is output.

Answer

C

Answer

ABC

Answer

B