1Z0-829 Practice Test 34 — 15 Questions

Question 1

An application deserializes objects from a network stream. To protect against deserialization attacks, which approach is most effective in Java 17?

Accepted Answer

Set an ObjectInputFilter on the ObjectInputStream. Setting an ObjectInputFilter on the ObjectInputStream allows you to define a filter that can reject deserialization of arbitrary or malicious classes, which is the primary defense against deserialization attacks. This mechanism, introduced in Java 9 and enhanced in later versions, lets you whitelist or blacklist classes based on patterns, limits on array sizes, or depth of object graphs, directly mitigating the risk of remote code execution or denial-of-service via crafted serialized data.

Answer

Declare all fields as transient

Answer

Use try-with-resources to auto-close the stream

Answer

Mark the class as final

Question 2

A company's Java application processes time-sensitive data from IoT sensors. The system must handle timestamps across multiple time zones. The application runs on a server set to UTC. Developers have been using java.util.Date and SimpleDateFormat for date parsing. Recently, there have been intermittent failures where timestamps from sensors in the America/New_York time zone are parsed incorrectly around daylight saving time transitions. Specifically, during the spring forward (March 12, 2023, at 2:00 AM EST to 3:00 AM EDT), timestamps like "2023-03-12 02:30:00" are being interpreted as times that do not exist, causing DateTimeParseException. The team decides to migrate to the java.time API. They need to parse sensor timestamps that include a time zone offset (e.g., "2023-03-12 02:30:00 -05:00") into an OffsetDateTime. Which course of action correctly parses the timestamp and handles the DST issue?

Accepted Answer

Use DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss XXX") and OffsetDateTime.parse(timestamp, formatter).. The timestamp includes an explicit offset (-05:00), which makes it directly parseable into an OffsetDateTime using a DateTimeFormatter with the XXX pattern for the offset. OffsetDateTime.parse() handles the offset directly without any DST ambiguity, as the offset is explicitly provided in the string, avoiding the nonexistent time issue during spring-forward transitions.

Answer

Use LocalDateTime.parse(timestamp, formatter) and then apply a ZoneOffset.

Answer

Use ZonedDateTime.parse(timestamp, formatter) with a formatter that includes time zone ID, then convert to OffsetDateTime.

Answer

Keep using SimpleDateFormat but set the time zone of the parser to America/New_York.

Question 3

A Java team is processing a large dataset with parallel streams. They notice inconsistent results due to non-atomic operations on shared mutable state. Which approach should they use to ensure thread-safety while maximizing performance?

Accepted Answer

Use the collect method with a concurrent Collector such as toConcurrentMap().. The `collect` method with a concurrent `Collector` like `toConcurrentMap()` ensures thread-safe accumulation by leveraging `ConcurrentHashMap` internally, which uses fine-grained locking or lock-free operations. This approach allows multiple threads to update the shared mutable state concurrently without external synchronization, maximizing parallelism and performance while maintaining consistency.

Answer

Use forEach with AtomicInteger and update atomically.

Answer

Use synchronized blocks inside the lambda expression.

Answer

Use ConcurrentHashMap for accumulation, but collect using toList().

Question 4

A developer is writing a method that reads a file and processes its content. The method must ensure that if an IOException occurs during reading, the method throws a custom ApplicationException that wraps the original IOException, and that any resources opened are closed properly. Which approach correctly implements this requirement?

Accepted Answer

try (BufferedReader reader = Files.newBufferedReader(path)) { ... } catch (IOException e) { throw new ApplicationException(e); }. It uses a try-with-resources statement, which automatically closes the BufferedReader (which implements AutoCloseable) when the block exits, whether normally or exceptionally. The catch clause then catches any IOException and wraps it in a custom ApplicationException, satisfying both the resource-closing and exception-wrapping requirements without manual cleanup.

Answer

try { ... } catch (IOException e) { System.err.println(e); } finally { reader.close(); }

Answer

catch (Exception e) { throw new ApplicationException(e); } finally { reader.close(); }

Answer

try { ... reader.close(); } catch (IOException e) { throw new ApplicationException(e); }

Question 5

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

Accepted Answer

Simplified recursive file operations using FileVisitor.. 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 6

Refer to the exhibit. Assuming the application is running from /home/application/lib/myapp.jar, which of the following actions is allowed by the policy?

Accepted Answer

All of the above. The policy grants all permissions (java.security.AllPermission) to the codebase file:/home/application/lib/myapp.jar, which means any action—including writing to /var/log/app.log, queuing a print job, and reading /etc/config/application.properties—is allowed. The AllPermission permission effectively disables all security checks for that code source, so all three listed actions are permitted.

Answer

Write to the file /var/log/app.log

Answer

Queue a print job using the system printer

Answer

Read the file /etc/config/application.properties

Question 7

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

Question 8

A developer wants to count how many strings in a list have length greater than 5. Which is the correct implementation?

Accepted Answer

list.stream().filter(s -> s.length() > 5).count(). The Stream API provides the `filter` method to select elements matching a predicate, and `count` returns the number of elements in the resulting stream. This directly counts strings with length greater than 5 without needing any intermediate mapping or collection.

Answer

list.stream().mapToLong(s -> s.length() > 5).sum()

Answer

list.stream().count(s -> s.length() > 5)

Answer

list.stream().collect(Collectors.counting(s -> s.length() > 5))

Question 9

Refer to the exhibit. A developer runs the code and gets an IllegalStateException on the second forEach. Which statement explains why?

Accepted Answer

The stream has already been operated upon or closed.. A Stream in Java cannot be reused after a terminal operation has been executed. Once the first forEach terminal operation completes, the stream is consumed and closed. Attempting to call another terminal operation (the second forEach) on the same stream reference throws an IllegalStateException with the message 'stream has already been operated upon or closed'.

Answer

The filter operation is not lazy.

Answer

The map operation modifies the source list.

Answer

The stream is not closed after the first terminal operation.

Question 10

A developer is implementing a method that reads a file and parses its contents. The method should ensure that any resources opened during the process are properly closed, even if an exception occurs. Which approach guarantees resource closure with minimal code?

Accepted Answer

Use try-with-resources with the resource declared in the try clause.. Try-with-resources automatically closes any resource that implements `AutoCloseable` (or `Closeable`) at the end of the try block, regardless of whether an exception occurs. This guarantees resource closure with minimal code, as the developer does not need to write explicit `close()` calls or manage finally blocks.

Answer

Use a try-catch block and close the resource inside the catch block.

Answer

Use a try block followed by a finally block without catch.

Answer

Use a try-catch-finally block and call close() in the finally block.

Question 11

Order the steps to properly handle resources using try-with-resources in Java.

Accepted Answer

Step 1: Declare and initialize resources in the try-with-resources parentheses. Step 2: Use the resources in the try block. Step 3: Resources are automatically closed in reverse order of declaration.. try-with-resources ensures each resource is closed at the end of the statement. Resources are closed in the opposite order they were created.

Answer

Step 1: Use resources in try block. Step 2: Declare resources in try-with-resources. Step 3: Resources are closed in declaration order.

Answer

Step 1: Declare resources in try-with-resources. Step 2: Close resources manually in a finally block. Step 3: Use resources in try block.

Answer

Step 1: Use resources in try block. Step 2: Declare resources in try-with-resources. Step 3: Resources are closed automatically in declaration order.

Question 12

Which THREE statements are true about the Boolean class? (Choose three.)

Accepted Answer

The parseBoolean(String) method returns false if the string is null or not equal to "true" (case-insensitive).. The `Boolean.parseBoolean(String)` method returns `false` for any input that is not exactly equal to `"true"` (case-insensitive), including `null`. This is specified in the Java API documentation and is a common way to safely parse boolean strings without throwing a NullPointerException.

Answer

The Boolean constructor is the preferred way to create a Boolean object.

Answer

Boolean has three possible values: true, false, and null.

Question 13

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.. Using PreparedStatement with parameterized queries prevents SQL injection by separating SQL logic from user input. The database driver automatically escapes special characters in the input, ensuring that user-supplied data is treated as literal values, not executable SQL code.

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 14

Which THREE of the following variable declarations are valid in Java 17?

Accepted Answer

List list = new ArrayList();. `List` is a wildcard type that can hold any type, and `new ArrayList()` creates an `ArrayList` of a specific type (`String`). The wildcard `?` acts as a type-safe placeholder, allowing the assignment of a concrete parameterized type to an unbounded wildcard reference. This is valid because the wildcard represents an unknown type, and the list is read-only in terms of type safety (you cannot add elements except `null`).

Answer

List<Object> list = new ArrayList<String>();

Answer

List list = new ArrayList();

Question 15

Which TWO are valid ways to obtain a Stream from a List<String> named 'list'? (Choose two.)

Accepted Answer

list.stream(). Options A and E are correct. The `List` interface provides the `stream()` method to obtain a sequential stream and `parallelStream()` to obtain a parallel stream. Option B is incorrect because `Stream.of(list)` treats the list itself as a single element, producing a `Stream>` rather than a `Stream`. Option C is incorrect because `Arrays.stream(list.toArray())` would work if you had a String array, but it returns a `Stream

Answer

Stream.of(list)

Answer

Arrays.stream(list.toArray())

Answer

new Stream<>(list)