1Z0-829 Multiple Select — 30 Questions

Question 1

Which THREE of the following are true about the Optional class? (Choose three.)

Accepted Answer

Optional.empty().orElseThrow(IllegalStateException::new) throws IllegalStateException. Option A is correct: Optional.empty() creates an empty Optional, and orElseThrow(IllegalStateException::new) invokes the supplied exception supplier when no value is present, so it throws a new IllegalStateException. Option C is correct: Optional.ofNullable(null) explicitly returns an empty Optional because ofNullable is designed to accept null and map it to Optional.empty(). Option E is correct: ifPresent executes the given Consumer only when a value is present, so on an empty Optional the lambda is skipped and nothing is printed. Option B is wrong because Optional.of(null) throws NullPointerException rather than returning an empty Optional. Option D is wrong because Optional.get() on an empty Optional throws NoSuchElementException, not null.

Answer

Optional.of(null) returns an empty Optional

Answer

Optional.get() on empty Optional returns null

Question 2

Which TWO statements are true about the Java module system?

Accepted Answer

The --add-exports flag can be used to export a package from one module to a specific target module.. The --add-exports command-line flag allows you to export a package from one module to a specific target module at runtime, overriding the module system's encapsulation. This is useful for modules that do not export a package by default but need to be accessed by a specific module during development or testing.

Answer

The --add-exports command-line flag opens a package for deep reflection.

Answer

The jlink tool can generate module-info.java files for automatic modules.

Answer

The exports directive can be used to export a specific class to another module.

Question 3

A developer is reviewing code that uses Java 17 collections. Which two statements about the java.util.ArrayDeque class are correct? (Choose two.)

Accepted Answer

It can be used as a LIFO stack and as a FIFO queue.. ArrayDeque is a resizable-array implementation of the Deque interface. It prohibits null elements and supports both stack (LIFO) and queue (FIFO) operations through its Deque methods. It is not a List, is not thread-safe, and does not maintain sorted order. These characteristics make it a versatile and efficient choice for many single-threaded scenarios.

Answer

It implements the List interface.

Answer

It is thread-safe for concurrent use by multiple threads without external synchronization.

Answer

It maintains its elements in sorted order.

Question 4

Which TWO statements about Java interfaces are true? (Choose two.)

Accepted Answer

Interfaces can contain static methods with a body.. Option C is correct because since Java 8, interfaces may declare static methods that have a full implementation body; these methods belong to the interface itself and must be invoked via the interface name (e.g., InterfaceName.method()), not through an implementing instance. Option D is correct because since Java 9, interfaces may contain private methods (both private instance methods and private static methods) with bodies, which serve as helper methods for default and static methods and are not inherited by implementing classes. Option A is wrong because an interface can extend multiple interfaces using a comma-separated list (e.g., interface A extends B, C), not just one. Option B is wrong because interface fields are implicitly public static final, so they cannot be declared protected (or private, or package-private). Option E is wrong because default methods are provided to add method implementations to interfaces without breaking existing implementing classes, and they can be overridden by implementing classes, so they do not prevent overriding.

Answer

An interface can extend at most one other interface.

Answer

Fields in an interface can be declared as protected.

Answer

Default methods are used to prevent method overriding.

Question 5

Which THREE statements are true about the Java Platform editions? (Select three.)

Accepted Answer

Java ME provides a subset of Java SE APIs for embedded devices.. Java ME (Micro Edition) is designed for resource-constrained devices like sensors, mobile phones, and embedded systems. It provides a subset of the Java SE APIs, along with additional APIs tailored for small devices, such as the Connected Limited Device Configuration (CLDC) and the Mobile Information Device Profile (MIDP). This allows developers to write Java applications that run on devices with limited memory, processing power, and display capabilities.

Answer

Java ME (Micro Edition) is the same as Android SDK.

Answer

Java SE includes a full application server for enterprise applications.

Question 6

Which TWO are valid lambda expressions? (Choose two.)
A. (int a, int b) -> a + b
B. a, b -> a + b
C. (a, b) -> a + b
D. (a, b) -> { a + b; }
E. (int a, b) -> a + b

Accepted Answer

(int a, int b) -> a + b. Option A is correct because a lambda expression may declare explicit parameter types, and when it does, the parameter list must be enclosed in parentheses: (int a, int b) -> a + b is valid syntax. Option C is correct because a lambda may use inferred parameter types, and with two or more inferred parameters the parentheses are required: (a, b) -> a + b is valid. Option B is invalid because a lambda parameter list with multiple parameters must be enclosed in parentheses, so a, b -> a + b is not legal. Option D is invalid because a block-bodied lambda must contain statements, and a + b; is an expression, not a statement, so it would not compile. Option E is invalid because Java does not allow mixing explicit and inferred parameter types in the same lambda parameter list, so (int a, b) -> a + b is illegal.

Answer

a, b -> a + b

Answer

(a, b) -> { a + b; }

Answer

(int a, b) -> a + b

Question 7

Which TWO are correct about parallel streams in Java? (Choose TWO.)

Accepted Answer

Parallel streams use the common ForkJoinPool by default.. Option D is correct because parallel streams in Java execute their tasks on the common ForkJoinPool by default, which is obtained via ForkJoinPool.commonPool() and sized to Runtime.getRuntime().availableProcessors() - 1. Option E is correct because parallel stream pipelines require stateless, non-interfering, and side-effect-free lambda functions; shared mutable state or interference between operations can produce nondeterministic or incorrect results due to concurrent execution across threads. Option A is wrong because parallelism adds overhead (splitting, task scheduling, merging) and can be slower than sequential streams for small data sets or cheap operations. Option B is wrong because lambdas that mutate shared state, rely on encounter order, or are not thread-safe can break under parallel execution. Option C is wrong because parallel streams do not guarantee encounter order unless the terminal operation and stream source explicitly preserve it (e.g., using forEachOrdered), and unordered sources or operations may yield results in any order.

Answer

Parallel streams always improve performance over sequential streams.

Answer

Any lambda expression is safe to use in a parallel stream.

Answer

Using parallel streams guarantees the order of elements in the result.

Question 8

Which TWO practices improve the security of Java serialization?

Accepted Answer

Mark sensitive fields as transient to exclude them from serialization.. Option B is correct because marking sensitive fields (e.g., passwords, keys) as transient excludes them from the default serialization process, so their values are never written to the byte stream and cannot be recovered by an attacker deserializing the object. Option D is correct because overriding readObject() lets you validate and sanitize field values after deserialization, rejecting malformed or malicious state before it is used, which mitigates gadget-chain and tampering attacks. Option A is not a security practice: throwing NotSerializableException from writeObject() merely prevents serialization of that class and does not protect against deserialization of crafted streams. Option C is wrong because serialVersionUID is only a version-compatibility identifier; a random value does not prevent malicious serialization and can actually break legitimate deserialization. Option E is not inherently secure: Externalizable gives full control over the wire format but shifts the burden of validation to the developer and, without explicit checks in readExternal(), can be just as vulnerable as default serialization.

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.

Question 9

Which THREE conditions must be true for a method to override another method in a subclass? (Choose three.)

Accepted Answer

The method name must be the same.. Option C is correct because an overriding method must have exactly the same name as the method it overrides in the superclass, which is the fundamental basis for the override relationship. Option D is correct because the parameter list (number, types, and order of parameters) must match exactly; otherwise the method would be an overload, not an override. Option E is correct because Java permits covariant return types, meaning the overriding method's return type may be the same as, or a subtype of, the overridden method's return type. Option A is incorrect because static methods are hidden rather than overridden, and an instance method cannot override a static method. Option B is incorrect because the access modifier must be the same or less restrictive (wider), not more restrictive; a more restrictive modifier would cause a compile-time error.

Answer

The method must be static in the superclass.

Answer

The access modifier must be the same or more restrictive.

Question 10

Which TWO are terminal operations on the Stream interface? (Choose two.)

Accepted Answer

count(). Option A, count(), is a terminal operation because it triggers the stream pipeline to execute and returns a long result (the number of elements), consuming the stream so it cannot be reused. Option B, forEach(), is also terminal: it accepts a Consumer and performs an action on each element, causing the pipeline to run and rendering the stream consumed. By contrast, filter(), map(), and sorted() are intermediate operations—they return a new Stream (or a specialized stream) and are lazy, merely building up the pipeline until a terminal operation is invoked. Therefore C, D, and E do not belong among the terminal operations.

Answer

filter()

Answer

map()

Answer

sorted()

Question 11

Which THREE statements about the jpackage tool are true?

Accepted Answer

jpackage can create native installers for Windows, macOS, and Linux.. The jpackage tool is designed to create native installers for Windows (e.g., .exe/.msi), macOS (e.g., .dmg), and Linux (e.g., .deb/.rpm). This is a core feature of jpackage, which replaces the older Java Packager and allows developers to distribute self-contained applications with platform-specific packaging formats.

Answer

jpackage requires an existing JRE to create a runtime image.

Answer

jpackage uses the Java Packager library.

Question 12

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 13

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

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 17

Which two statements about multi-catch blocks are correct?

Accepted Answer

A multi-catch block can be used with a finally block.. Option B is correct because a multi-catch block is simply an alternative form of a catch clause, so it can be freely combined with a finally block (and with other catch clauses) in the same try statement, e.g. try { ... } catch (IOException | SQLException e) { ... } finally { ... }. Option E is correct because the exception parameter types listed in a multi-catch must be disjoint — the compiler rejects alternatives where one type is a subclass of another (e.g. catch (IOException | FileNotFoundException e) fails), since the parameter is implicitly final and typed as the least upper bound of the alternatives. Option A is wrong because a multi-catch may combine checked and unchecked exception types, such as catch (IOException | IllegalArgumentException e), as long as the alternatives are disjoint. Option C is wrong because the multi-catch parameter is implicitly final, which is exactly why it cannot be reassigned inside the handler. Option D is wrong because multi-catch is independent of try-with-resources; it works with any try statement, with or without resources.

Answer

A multi-catch block cannot catch both checked and unchecked exceptions.

Answer

The variable in a multi-catch block is not implicitly final.

Answer

A multi-catch block can only be used with try-with-resources.

Question 18

Which THREE are methods of the Map.Entry interface? (Java 17)

Accepted Answer

getValue(). The java.util.Map.Entry interface defines getKey() (option C), which returns the key corresponding to the entry, and getValue() (option A), which returns the value corresponding to the entry; both are core accessors used when iterating a map's entrySet(). It also defines setValue(V value) (option D), which replaces the value for this entry and returns the previous value, enabling in-place modification during iteration. Option B, getHash(), does not exist on Map.Entry (hashing is handled by hashCode() inherited from Object), and option E, getValueOrDefault(), is not a Map.Entry method — it is a default method on the Map interface (getOrDefault(Object key, V defaultValue)), so neither belongs here.

Answer

getHash()

Answer

getValueOrDefault()

Question 19

Which THREE statements are true about loops in Java?

Accepted Answer

The break statement can be used to exit a loop prematurely.. The break statement in Java is used to immediately terminate the execution of a loop (for, while, or do-while) and transfer control to the statement following the loop. This allows premature exit based on a condition, which is a fundamental control flow mechanism in Java.

Answer

A while loop always executes at least once.

Answer

A do-while loop may execute zero times if the condition is false.

Question 20

Which TWO of the following are valid ways to create a LocalDate object in Java 17?

Accepted Answer

LocalDate.of(2023, Month.JANUARY, 15). Option B is correct because LocalDate.of(int year, Month month, int dayOfMonth) is a valid static factory method in java.time that accepts a Month enum constant such as Month.JANUARY, producing 2023-01-15. Option D is correct because LocalDate.parse(CharSequence) uses the ISO_LOCAL_DATE formatter by default, and "2023-01-15" matches the required yyyy-MM-dd pattern. Option A is wrong because LocalDate.from(TemporalAccessor) requires a temporal that contains date fields, and Instant only provides an instant on the time-line without a date, so it throws DateTimeException. Option C is wrong because month 13 is outside the valid range of 1-12 and LocalDate.of throws DateTimeException. Option E is wrong because LocalDate.ofEpochDay takes a long primitive, not a String, so passing "19375" does not compile.

Answer

LocalDate.from(Instant.now())

Answer

LocalDate.of(2023, 13, 1)

Answer

LocalDate.ofEpochDay("19375")