1Z0-829 Practice Test 3 — 30 Questions

Question 1

Which of the following lambda expressions is syntactically invalid?

Accepted Answer

(a, b) -> return a + b;. Syntactically invalid because in a lambda expression, the `return` keyword is only allowed inside a block body (with braces). When using an expression body (no braces), the `return` keyword must be omitted, and the expression itself is implicitly returned. Option C incorrectly uses `return` without braces, which is a syntax error.

Answer

() -> {return 42;}

Answer

(a, b) -> a + b

Answer

(int a, int b) -> a + b

Answer

(a) -> a * 2

Question 2

A developer creates an unmodifiable list via Collections.unmodifiableList(originalList). Later, originalList is modified by adding an element. Which statement is true?

Accepted Answer

The unmodifiable list reflects the addition. D is correct because `Collections.unmodifiableList()` returns a view-backed unmodifiable list that reflects any changes made to the original list. The unmodifiable list does not create a snapshot; it wraps the original list, so modifications to the original are visible through the unmodifiable wrapper.

Answer

The unmodifiable list remains unchanged

Answer

The unmodifiable list becomes inconsistent

Answer

An UnsupportedOperationException is thrown

Question 3

Which two statements about the java.time.Duration class are true? (Choose two.)

Accepted Answer

Duration can be negative.. Option B is correct because java.time.Duration models an amount of time in terms of seconds and nanoseconds, and both components may carry a negative sign, so a Duration can represent a negative span (e.g., Duration.ofSeconds(-5) or the result of between() when the end is before the start). Option C is correct because Duration is a final, immutable value-based class: all its fields are final and every mutating-looking method such as plus() or withSeconds() returns a new instance, which makes instances safe to share across threads without synchronization. Option A is wrong because Duration only supports time-based units (days treated as exactly 24 hours, hours, minutes, seconds, nanos); months and years are date-based and are handled by java.time.Period. Option D is wrong because Duration.between() requires two Temporal objects that support time-based fields, and LocalDate is date-only, so passing LocalDate arguments throws an UnsupportedTemporalTypeException (or fails to compile against the Temporal signature). Option E is wrong because Duration's internal representation is seconds plus a nanosecond adjustment, not a days-based representation; the days-based model belongs to Period.

Answer

Duration supports units like months and years.

Answer

Duration.between(LocalDate.now(), LocalDate.now()) returns a Duration.

Answer

Duration uses a days-based representation.

Question 4

A web application allows users to specify filenames for uploaded documents. The application saves files to a directory using the provided name. Which secure programming practice should be applied to prevent path traversal attacks?

Accepted Answer

Use File.getCanonicalPath() to resolve the path and check it starts with the intended directory.. `File.getCanonicalPath()` resolves all symbolic links, `.` and `..` sequences, and platform-specific path conventions to produce an absolute, unique path. By then verifying that this canonical path starts with the intended base directory (e.g., `/var/uploads/`), the application can definitively reject any path that escapes outside the allowed directory, even if the user-supplied filename contains encoded or obfuscated traversal sequences.

Answer

Validate that the filename contains only alphanumeric characters.

Answer

Generate a random UUID for each file, ignoring the user-provided filename.

Answer

Replace all occurrences of ".." and "/" with an empty string.

Question 5

Which of the following is a terminal operation of the Stream API?

Accepted Answer

forEach(). (forEach()) is correct because it is a terminal operation in the Stream API. Terminal operations produce a result or side effect and close the stream, meaning no further operations can be performed on the same stream. forEach() consumes each element of the stream and returns void, making it a terminal operation.

Answer

map()

Answer

filter()

Answer

peek()

Question 6

A team uses a TreeSet with a custom Comparable that returns 0 for objects that are not logically equal (e.g., based on one field but objects differ in another). What is the likely outcome when adding such objects?

Accepted Answer

The second object is not added because TreeSet considers it a duplicate. TreeSet uses the compareTo() method of the Comparable interface (or Comparator) to determine ordering and equality. When compareTo() returns 0 for two objects that are not logically equal (e.g., they share the same field used in comparison but differ in other fields), TreeSet treats them as duplicates and does not add the second object. This is because TreeSet relies on the comparison result, not the equals() method, for uniqueness.

Answer

The second object replaces the first

Answer

A ClassCastException is thrown

Answer

Both objects are added and insertion order is preserved

Question 7

Which of the following correctly uses try-with-resources to ensure a FileInputStream is closed after use?

Accepted Answer

try (FileInputStream fis = new FileInputStream("file.txt")) { ... }. It uses the try-with-resources syntax (try (resource declaration) { ... }), which automatically closes the FileInputStream when the block exits, regardless of exceptions. This ensures the resource is closed without requiring an explicit finally block, as mandated by the AutoCloseable interface.

Answer

FileInputStream fis = new FileInputStream("file.txt"); try { ... } finally { fis.close(); }

Answer

try { FileInputStream fis = new FileInputStream("file.txt"); ... } finally { fis.close(); }

Answer

try (fis = new FileInputStream("file.txt")) { ... }

Question 8

You are developing a microservice that processes financial transactions. The service reads transaction data from a message queue, validates it, and writes results to a database. The code uses a try-with-resources statement to manage database connections. During testing, you notice that when a transaction fails validation, the service throws an IllegalStateException before closing the database connection, causing a resource leak. You need to ensure that the database connection is always closed properly, even if an exception is thrown during validation. The current code structure is:

try (Connection conn = DriverManager.getConnection(url, user, pass)) {
    // read from queue
    // validate transaction
    // if invalid, throw new IllegalStateException("Invalid transaction");
    // write to database
}

Which course of action would you recommend?

Accepted Answer

No change is needed; the try-with-resources ensures the connection is closed.. Try-with-resources automatically closes any resource that implements AutoCloseable (including Connection) when the try block exits, whether normally or via an exception. The IllegalStateException thrown during validation does not prevent the connection from being closed; the close() method is called as part of the implicit finally block generated by the compiler.

Answer

Move the connection creation outside the try-with-resources to manually manage it.

Answer

Replace the try-with-resources with a try-catch-finally block and close the connection in the finally block.

Answer

Add a catch block to catch the IllegalStateException and close the connection.

Question 9

A junior developer writes a method that uses a switch statement to handle different types of user input. The input is an integer representing an operation code. The developer uses a traditional switch statement with break statements. However, when operation code 2 is entered, the program also executes the code for operation 3. What is the most likely cause?

Accepted Answer

The break statement is missing after the operation 2 case.. In a traditional Java switch statement, execution continues into the next case block unless a break statement is encountered. If operation code 2 executes the code for operation 3, it indicates that the break statement is missing after the case for operation 2, causing fall-through to the next case.

Answer

The operation codes are not mutually exclusive.

Answer

The variable is being modified inside the switch.

Answer

The switch statement uses fall-through by design.

Question 10

Which method of Collection interface returns a primitive int?

Accepted Answer

size(). The `size()` method is the only one in the `Collection` interface that returns a primitive `int`, representing the number of elements in the collection. All other methods listed return either a `boolean` or an array of objects, making D the correct answer.

Answer

contains(Object o)

Answer

isEmpty()

Answer

toArray()

Question 11

Given the following assertion: assert age >= 0 : "Age must be non-negative"; When is it appropriate to use assertions?

Accepted Answer

To verify internal invariants of a private method.. Assertions are used to verify internal invariants of a private method during development and testing. They should not be used for argument validation in public methods, handling recoverable conditions, or validating external input. Therefore, option A is correct.

Answer

To handle recoverable conditions like file not found.

Answer

To check parameters of a public API method.

Answer

To validate user input from an external system.

Question 12

Which two statements about the do-while loop are true?

Accepted Answer

The do-while loop can be used with a label.. Option C is correct because Java's do-while loop is a statement that can be prefixed with a label (e.g., outer: do { ... } while (cond);), and that label can then be targeted by a labeled break or continue to control the loop's flow. Option D is correct because the do-while loop checks its condition only after executing the body, so the body always runs at least once, even if the condition is false on the first evaluation. Option A is wrong because evaluating the condition before the body is the behavior of the while loop, not the do-while loop. Option B is wrong because a do-while loop can be preceded by an initialization statement (e.g., int i = 0; do { ... } while (i < 5);), so it is not prohibited. Option E is wrong because a do-while loop does not always execute more times than an equivalent while loop; it executes at least once, but for many conditions (such as a false condition initially) the while loop executes zero times while the do-while executes once, and in other cases the counts can be equal.

Answer

The condition is evaluated before the body executes.

Answer

The do-while loop cannot have an initialization statement.

Answer

The do-while loop always executes more times than a while loop with the same condition.

Question 13

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 14

Which two of the following are valid methods to create a new directory using the NIO.2 Files class? (Select two.)

Accepted Answer

Files.createDirectory(Path). Option C, Files.createDirectory(Path), is correct because it is the standard NIO.2 method that creates a single new directory, throwing an exception if the parent path does not exist or if the directory already exists. Option D, Files.createDirectories(Path), is also correct because it creates a directory and any nonexistent parent directories, and unlike createDirectory it does not throw an exception if the directory already exists. Option A, Files.mkdir(Path), is not a method of the java.nio.file.Files class; mkdir() belongs to java.io.File. Option B, Files.createNewDirectory(Path), does not exist in the NIO.2 API. Option E, Files.makeDirectory(Path), is likewise not a real method in the Files class.

Answer

Files.mkdir(Path)

Answer

Files.createNewDirectory(Path)

Answer

Files.makeDirectory(Path)

Question 15

Which THREE of the following are valid ways to create a Stream<String>? (Choose three.)

Accepted Answer

Arrays.stream(new String[]{"a", "b"}). Option A is correct because Arrays.stream(T[] array) is a static factory method on java.util.Arrays that accepts an object array such as new String[]{"a", "b"} and returns a Stream whose elements are the array's elements. Option B is correct because Stream.of(T... values) is a static factory method on java.util.stream.Stream that takes a varargs of String values ("a", "b") and returns a Stream. Option C is correct because List.of("a", "b") creates an immutable List, and calling stream() on any Collection (including List) returns a Stream of its elements. Option D is not correct because "ab".chars() returns an IntStream of primitive int character values, not a Stream. Option E is not correct because Stream is an interface and cannot be instantiated with new Stream(); streams must be obtained via factory methods or from a source such as a collection or array.

Answer

"ab".chars()

Answer

new Stream<String>()

Question 16

A developer writes code to iterate over a list of strings and print each element. The code uses an enhanced for loop. Which statement is true about the enhanced for loop?

Accepted Answer

It can be used with arrays and any object that implements Iterable.. The enhanced for loop (for-each) in Java can iterate over arrays and any object that implements the Iterable interface, which includes all Collection classes (e.g., List, Set, Queue). This is because the for-each loop internally uses an iterator for Iterable objects or array indexing for arrays, making it a versatile construct for traversing elements without needing an explicit counter.

Answer

It can only be used with arrays.

Answer

It requires an explicit counter variable.

Answer

It allows removing elements from the collection during iteration without ConcurrentModificationException.

Question 17

You are responsible for a Java 17 application that processes user uploads. The application uses a custom AutoCloseable resource, UploadSession, which must always be closed after use to free server resources. A junior developer wrote the following code:

```
UploadSession session = new UploadSession();
try {
    session.upload(data);
    // more processing
} catch (UploadException e) {
    log.error("Upload failed", e);
} finally {
    session.close();
}
```

During a code review, you notice that the close() method of UploadSession throws a checked CloseException. The current code does not handle this exception. Which course of action should you recommend to ensure the application is robust and follows best practices?

Accepted Answer

Rewrite the code to use try-with-resources: try (UploadSession session = new UploadSession()) { ... } catch (UploadException e) { ... }. Try-with-resources automatically calls the close() method on the UploadSession resource when the try block exits, whether normally or abruptly. This eliminates the need for an explicit finally block and ensures that any checked exception thrown by close() is either caught or propagated according to the developer's declared exception handling, making the code both robust and concise.

Answer

Add a try-catch block inside the finally block to handle CloseException from session.close().

Answer

Declare the method with throws CloseException, and remove the finally block.

Answer

Keep the code as-is. The CloseException is not critical; it can be ignored.

Question 18

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.. Option D is correct because Collections.synchronizedList(List) returns a thread-safe wrapper around the given list, and the returned list is backed by the original list, so changes to one are reflected in the other. Option E is correct because Collections.unmodifiableList(List) returns an unmodifiable view of the specified list, meaning any attempt to modify it throws UnsupportedOperationException while reads pass through to the backing list. Options A, B, and C are incorrect because Collections.sort(List), Collections.reverse(List), and Collections.shuffle(List) all return void and mutate the list in place rather than returning a new list.

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 19

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 20

A Java application uses a custom resource class implementing AutoCloseable. The close() method throws a checked exception. In a try-with-resources block, if both the try block and the close() method throw exceptions, which exception is propagated to the caller? Assume the resource is declared in try-with-resources.

Accepted Answer

The exception from the try block is the primary exception, and the close() exception is added as a suppressed exception.. In a try-with-resources block, when both the try block and the close() method throw exceptions, the exception from the try block is the primary exception propagated to the caller. The exception thrown by close() is added to the primary exception's suppressed exception list, as defined by the Java Language Specification (JLS §14.20.3.2). This ensures that the most relevant exception (the one from the application logic) is not masked by a resource-closing failure.

Answer

The exception from close() is always the primary exception.

Answer

Both exceptions are thrown simultaneously as a multi-catch exception.

Answer

The exception from the try block is always suppressed.