1Z0-829 Practice Test 24 — 15 Questions

Question 1

Given the output of `java --list-modules` from a Java 17 installation, which module is NOT included by default when using the `--release 17` flag with `javac`?

Accepted Answer

jdk.incubator.foreign. The `--release 17` flag restricts `javac` to the standard Java SE 17 API, which does not include incubator modules like `jdk.incubator.foreign`. Incubator modules are preview features that are not part of the Java SE specification and must be explicitly added with `--add-modules`.

Answer

jdk.jfr

Answer

java.net.http

Answer

java.sql

Question 2

Given the following code fragment:
```java
int x = 0;
for (int i = 0; i < 4; i++) {
    x++;
}
System.out.println(x);
```
What is the result?

Accepted Answer

4. The loop runs four times (i = 0, 1, 2, 3), incrementing x each time. Therefore, x becomes 4, so the output is 4. Option B is correct.

Answer

9

Answer

3

Answer

5

Question 3

A developer is writing a utility to copy a large binary file (e.g., 500 MB) from one location to another while minimizing memory overhead and ensuring data integrity. Which approach is most appropriate?

Accepted Answer

Use a custom loop reading into a byte array of 8KB and writing to the output stream.. Reading and writing in fixed-size chunks (e.g., 8KB) minimizes memory overhead by avoiding loading the entire 500 MB file into memory, while still providing efficient I/O through buffered operations. This approach ensures data integrity by processing the file sequentially without relying on character-based streams, which are unsuitable for binary data.

Answer

Use BufferedReader and BufferedWriter for binary data.

Answer

Use Files.copy() with StandardCopyOption.REPLACE_EXISTING.

Answer

Use FileInputStream.readAllBytes() and FileOutputStream.write().

Question 4

Which functional interface is most appropriate for a lambda that takes a String and returns nothing?

Accepted Answer

Consumer. A lambda that takes a String and returns nothing matches the `Consumer` functional interface, which has a single abstract method `void accept(String t)`. `Consumer` is designed for operations that consume an input and produce no output, such as printing or logging the string.

Answer

Predicate<String>

Answer

Function<String, Void>

Answer

Supplier<String>

Question 5

Which TWO statements about the java.util.Collections class are true?

Accepted Answer

Collections.synchronizedList(List) returns a synchronized list backed by the specified list.. Collections.synchronizedList(List) returns a synchronized (thread-safe) list backed by the specified list. This method wraps the provided list in a synchronized wrapper, ensuring that all access to the underlying list is serialized when accessed through the returned list. It does not create a new independent list but provides a view that synchronizes all method calls.

Answer

Collections.sort(List) returns a new sorted list.

Answer

Collections.reverse(List) returns a new reversed list.

Answer

Collections.shuffle(List) returns a new shuffled list.

Question 6

Which TWO statements about try-with-resources are true? (Choose two.)

Accepted Answer

If both the try block and the close method throw exceptions, the close exception is suppressed.. When both the try block and the close method throw exceptions, the exception from the close method is suppressed and added to the suppressed exceptions list of the exception thrown by the try block. This behavior is defined by the try-with-resources specification in Java, ensuring that the primary exception is not masked by resource-closing exceptions.

Answer

Resources are closed in the order they are declared.

Answer

Only a single resource can be managed in a try-with-resources statement.

Answer

Resources are closed after the catch block if an exception occurs.

Question 7

A method receives a List<String> and needs to transform it to a Map where the key is the first three characters of each string and the value is the string itself. If two strings have the same prefix, the later one should override the earlier. Which collector achieves this?

Accepted Answer

Collectors.toMap(s -> s.substring(0,3), Function.identity(), (a,b) -> b). `Collectors.toMap` with a merge function `(a, b) -> b` ensures that when duplicate keys (first three characters) occur, the later string in the stream order replaces the earlier one. The merge function is invoked on key collision, and returning `b` (the second argument) keeps the later value, satisfying the requirement.

Answer

Collectors.groupingBy(s -> s.substring(0,3))

Answer

Collectors.toMap(s -> s.substring(0,3), Function.identity())

Answer

Collectors.toConcurrentMap(s -> s.substring(0,3), Function.identity())

Question 8

A developer implements a reduction using reduce() to concatenate strings from a stream. The code: Optional<String> result = stream.reduce((s1, s2) -> s1.concat(s2)); The operation works but the developer is concerned about performance with large streams. Which change would most likely improve performance?

Accepted Answer

Use StringBuffer with collect() instead.. `StringBuffer` is mutable and thread-safe, making it efficient for accumulating strings in a parallel or sequential stream via `collect()`. The `reduce()` operation with `concat()` creates a new `String` object for each pair, leading to O(n) string copying and quadratic time complexity. Using `collect()` with `StringBuffer` avoids this overhead by reusing a mutable buffer.

Answer

Use a sequential stream.

Answer

Use parallelStream with reduce.

Answer

Use reduce with identity "".

Question 9

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 10

A company uses a large dataset of customer orders. They want to compute statistics: total orders, average amount, and maximum amount per city. They write: Map<String, IntSummaryStatistics> stats = orders.stream() .collect(Collectors.groupingBy(Order::getCity, Collectors.summarizingInt(Order::getAmount))); The code works but is slower than expected when run on a large dataset. They suspect the grouping operation is not taking advantage of parallelism. They want to improve performance by making the collector concurrent. Which change is correct?

Accepted Answer

Use Collectors.groupingByConcurrent(Order::getCity, Collectors.summarizingInt(Order::getAmount)).. `Collectors.groupingByConcurrent` performs an unordered, concurrent reduction that can leverage a `ConcurrentHashMap` internally, allowing the collector to work efficiently with a parallel stream. This reduces contention and improves performance on large datasets compared to the sequential `groupingBy`.

Answer

Use parallelStream() instead of stream().

Answer

Keep the code but supply a ConcurrentHashMap as the map supplier to groupingBy.

Answer

Replace collect with forEach and manually update a ConcurrentHashMap.

Question 11

Refer to the exhibit. Which Java code correctly performs the equivalent timezone conversion?

Accepted Answer

ZonedDateTime.of(2024,3,10,2,30,0,0,ZoneId.of("America/New_York")).withZoneSameInstant(ZoneOffset.UTC). It explicitly constructs a ZonedDateTime for the given date and time in the America/New_York timezone, then converts it to UTC using withZoneSameInstant. This correctly accounts for the fact that on March 10, 2024, at 2:30 AM, clocks in New York were set forward to 3:30 AM EDT (UTC-4), so the equivalent UTC time is 6:30 AM, not 2:30 AM UTC.

Answer

LocalDateTime.of(2024,3,10,2,30).atZone(ZoneOffset.UTC)

Answer

Instant.parse("2024-03-10T02:30:00Z")

Answer

OffsetDateTime.of(2024,3,10,2,30,0,0,ZoneOffset.UTC)

Question 12

A developer has a method that contains a try-catch-finally block inside a while loop. The try block throws a checked exception that is caught by the catch block. The catch block throws a new runtime exception. What is the behavior?

Accepted Answer

The loop terminates immediately, and the runtime exception propagates.. When a checked exception is caught and the catch block throws a new runtime exception, the finally block executes before the runtime exception propagates. Since the runtime exception is thrown from within the catch block (inside the while loop), it immediately terminates the loop and propagates up the call stack. Option B is correct because the loop does not continue; the runtime exception is thrown after the finally block completes.

Answer

The loop continues after the finally block, and the runtime exception is thrown after the loop.

Answer

The loop continues after the catch block, and the runtime exception is not propagated.

Answer

The loop continues after the finally block, and the runtime exception is suppressed.

Question 13

Refer to the exhibit. What is the output when the program is executed?

Accepted Answer

0 0 0 1 0 2 1 0 1 1. The code uses nested for loops with break labels. The outer loop iterates i from 0 to 2, and the inner loop iterates j from 0 to 2. When i == 1 and j == 1, the break outer; statement exits both loops, so after printing 0 0, 0 1, 0 2, 1 0, 1 1, the program terminates. This matches option C.

Answer

0 0 0 1 0 2 1 0 1 1 1 2

Answer

0 0 0 1 0 2 1 0 1 1 2 0 2 1 2 2

Answer

0 0 0 1 0 2 1 0 1 1 1 2 2 0 2 1 2 2

Question 14

Refer to the exhibit. Which statement about this Singleton implementation is correct?

Accepted Answer

It may still have a race condition due to instruction reordering.. The provided Singleton implementation uses double-checked locking without declaring the instance variable as volatile. Without volatile, the JVM may reorder instructions such that a thread reads a non-null reference to a partially constructed object, leading to a race condition. This is a classic pitfall in Java concurrency.

Answer

The volatile keyword is unnecessary.

Answer

It is thread-safe without any issues.

Answer

It will compile only if the constructor is public.

Question 15

Which TWO practices improve the security of Java serialization?

Accepted Answer

Mark sensitive fields as transient to exclude them from serialization.. Marking sensitive fields as transient prevents them from being serialized, ensuring that confidential data (e.g., passwords, cryptographic keys) is not exposed through the serialized stream. Option D is correct because implementing readObject() allows you to validate and sanitize deserialized fields, protecting against deserialization attacks where crafted data could corrupt the object state or trigger malicious behavior.

Answer

Disable serialization by throwing NotSerializableException from writeObject().

Answer

Set a random serialVersionUID to prevent malicious serialization.

Answer

Use Externalizable for full control over serialization format.