1Z0-829 Practice Test 25 — 15 Questions

Question 1

A developer writes the following code to print a list of strings in order: list.stream().map(s -> s.toUpperCase()).forEach(System.out::print). They want to parallelize the processing but must preserve the output order. Which change is correct and most appropriate?

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

Accepted Answer

list.parallelStream().map(s -> s.toUpperCase()).forEachOrdered(System.out::print);. `forEachOrdered` guarantees that elements are processed in encounter order even when the stream is parallelized. The `map` operation is stateless and can run in parallel, but the terminal operation must preserve order, which `forEachOrdered` does by enforcing sequential output in the stream's encounter order.

Answer

list.parallelStream().map(s -> s.toUpperCase()).forEach(System.out::print);

Answer

list.stream().parallel().map(s -> { synchronized(System.out) { return s.toUpperCase(); } }).forEach(System.out::print);

Answer

list.stream().parallel().map(s -> s.toUpperCase()).sequential().forEach(System.out::print);

Question 2

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 3

A developer runs `java --list-modules` and sees the above output on a standard JDK installation. What does this output represent?

Accepted Answer

The set of modules available in the current JDK.. The `java --list-modules` command outputs the names of all observable modules that are part of the current JDK installation. This includes all platform modules (e.g., `java.base`, `java.sql`, `jdk.compiler`) that are available for use, regardless of whether they are currently required or loaded by an application. Option C correctly identifies this as the set of modules available in the current JDK.

Answer

The modules that are part of the java.base module.

Answer

The modules that are required by the current application.

Answer

The modules that are currently loaded by the JVM.

Question 4

Refer to the exhibit. A Java application is deployed in /opt/app/lib/ and attempts to perform the following operations:
1) Read the file /data/config/settings.xml
2) Write to the file /logs/app.log
3) Read the file /data/config/subdir/extra.conf
Which statement is true?

Accepted Answer

Operations 1 and 2 are allowed; operation 3 is denied.. The Java application is deployed in /opt/app/lib/, so its code base is /opt/app/lib/. The security policy grants read permission for /data/config/*, which matches /data/config/settings.xml (operation 1) but does not match /data/config/subdir/extra.conf because the wildcard * does not descend into subdirectories (operation 3 is denied). Write permission is granted for /logs/*, so /logs/app.log (operation 2) is allowed. Thus, operations 1 and 2 are allowed, and operation 3 is denied.

Answer

All three operations are allowed because the code base matches.

Answer

Only operation 1 is allowed; operations 2 and 3 are denied.

Answer

Operations 1 and 3 are allowed; operation 2 is denied.

Question 5

A serialized object has an explicitly declared serialVersionUID of 123L. After a code change, a new field is added to the class but the serialVersionUID is left unchanged. What happens when deserializing an old stream?

Accepted Answer

Deserialization succeeds and the new field is set to its default value.. When a serialized object has an unchanged serialVersionUID, the Java deserialization mechanism treats the class as compatible. The new field is not present in the old stream, so it is simply initialized to its default value (e.g., null for objects, 0 for primitives) without throwing an exception. This behavior is defined by the Java Object Serialization Specification, which allows forward compatibility as long as the serialVersionUID matches.

Answer

Deserialization succeeds only if the new field is marked transient.

Answer

Deserialization throws StreamCorruptedException due to missing field.

Answer

Deserialization throws InvalidClassException because the class definition has changed.

Question 6

Which TWO of the following are checked exceptions in Java?

Accepted Answer

SQLException. SQLException (A) is a checked exception because it directly extends java.lang.Exception (via java.sql.SQLException) and is not a subclass of RuntimeException, so the compiler requires it to be declared in a throws clause or caught. IOException (E) is likewise a checked exception, extending java.lang.Exception through java.io.IOException, and must be handled or declared for file, stream, and network I/O operations. The unmarked options do not belong because ArithmeticException (B), ArrayIndexOutOfBoundsException (C), and NullPointerException (D) all extend RuntimeException, making them unchecked exceptions that the compiler does not force callers to catch or declare.

Answer

ArithmeticException

Answer

ArrayIndexOutOfBoundsException

Answer

NullPointerException

Question 7

Which two statements are true about the java.util.Comparator and java.lang.Comparable interfaces? (Choose two.)

Accepted Answer

Comparator can be used to sort a list in multiple ways.. Option B is correct because Comparator is an external, strategy-style interface whose compare(T o1, T o2) method can be supplied in many different implementations (or lambdas), allowing the same list to be sorted by different criteria such as name, age, or salary via Collections.sort(list, comparator) or list.sort(comparator). Option D is correct because Comparable defines the natural ordering of a class through its single abstract method compareTo(T o), which is used implicitly by sorting methods like Collections.sort(list) and Arrays.sort(array) when no Comparator is provided. Option A is wrong because Comparator's compare method returns an int (negative, zero, or positive), not a boolean. Option C is wrong because implementing Comparable requires overriding compareTo, not equals; while it is strongly recommended that compareTo be consistent with equals, overriding equals is not a requirement of the interface. Option E is wrong because Comparator resides in the java.util package, whereas Comparable is in java.lang.

Answer

Comparator's compare method returns a boolean.

Answer

A class implementing Comparable must override equals().

Answer

Comparator is in java.lang package.

Question 8

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. 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 9

Given: int x=1; switch(x) { case 1: System.out.print("A"); case 2: System.out.print("B"); break; default: System.out.print("C"); } What is printed?

Accepted Answer

AB. The switch statement does not have a break after case 1, so execution falls through to case 2 after printing 'A'. Case 2 prints 'B' and then hits the break, exiting the switch. The default case is skipped because a matching case was found. Thus, 'AB' is printed.

Answer

C

Answer

ABC

Answer

A

Question 10

Which is the best practice for securing a Java application that reads sensitive configuration files?

Accepted Answer

Restrict access to the file using operating system permissions.. Restricting access to sensitive files using operating system permissions is a fundamental security practice that applies regardless of the Java version. In Java 17, the Security Manager is deprecated for removal (JEP 411), so relying on a Java security policy file (Option B) is no longer considered a best practice. OS-level permissions provide a robust, platform-native access control that does not depend on deprecated features. Options C and D are insufficient: making a file read-only does not prevent unauthorized access, and storing credentials in source code is highly insecure.

Answer

Define a Java security policy file with FilePermission for the configuration file.

Answer

Make the file read-only at the OS level.

Answer

Store credentials in the source code and use encryption.

Question 11

Refer to the exhibit. What is the purpose of this code?

Accepted Answer

Encrypt data.txt and write to data.enc. The code uses a CipherOutputStream with a cipher initialized in ENCRYPT_MODE, reading from data.txt and writing to data.enc, thus encrypting the plaintext file and producing an encrypted output file. This is the standard pattern for file encryption in Java using the JCA (Java Cryptography Architecture).

Answer

Compress data.txt and write to data.enc

Answer

Encrypt data.enc and write to data.txt

Answer

Decrypt data.txt and write to data.enc

Question 12

Which class is best suited for reading integer tokens from a string containing space-separated integers?

Accepted Answer

Scanner. Scanner is best suited because it provides built-in methods like nextInt() that can parse space-separated integer tokens directly from a string, handling whitespace delimiters automatically. It is designed for parsing formatted input, making it the ideal choice for this task.

Answer

InputStreamReader

Answer

BufferedReader

Answer

DataInputStream

Question 13

Given: int a=5, b=10; String result = (a > b) ? "greater" : (a < b) ? "less" : "equal"; What is result?

Accepted Answer

"less". The ternary operator is right-associative, so the expression is parsed as `a > b ? "greater" : (a < b ? "less" : "equal")`. Since `a=5` and `b=10`, `a > b` is false, so the second operand of the outer ternary is evaluated: `a < b` is true, so the inner ternary returns `"less"`. The code compiles and runs without error, producing `"less"`.

Answer

"equal"

Answer

"greater"

Answer

Compilation error

Question 14

Which of the following correctly describes the behavior of the following code? List list = new ArrayList<>(); list.add("A"); list.add("B"); for (String s : list) { if (s.equals("A")) { list.remove(s); } } System.out.println(list);

Accepted Answer

ConcurrentModificationException is thrown. The code uses an enhanced for-each loop to iterate over an ArrayList while calling `list.remove(s)` when the element equals "A". This modifies the list structurally during iteration, which causes the iterator (used internally by the for-each loop) to detect the concurrent modification and throw a `ConcurrentModificationException` at runtime. The exception is thrown because the iterator's `modCount` check fails when the list is modified outside of the iterator's own `remove` method.

Answer

Compilation error

Answer

[B]

Answer

[A, B] unchanged

Question 15

Which command creates a custom runtime image containing only the modules needed by an application, reducing the size of the JRE?

Accepted Answer

jlink. The `jlink` tool is specifically designed to create a custom runtime image that contains only the modules required by a given application, along with their transitive dependencies. This reduces the JRE size by eliminating unused modules, which is a key feature of Java's module system (Project Jigsaw). Option C is correct because `jlink` is the only command among the choices that performs this modular runtime image assembly.

Answer

jmod

Answer

jar

Answer

jdeps