Oracle Certified Professional Java SE 17 Developer 1Z0-829 1Z0-829 Questions 151–225 | Page 3/7

151

MCQeasy

A Java application writes sensitive user data to a file. To ensure that data is not left in the file system after the application crashes, which practice should be followed?

A.Call flush() after every write operation

B.Delete the file manually in a finally block

C.Use a FileLock to prevent concurrent access

D.Write to a temporary file, then use Files.move() with ATOMIC_MOVE to replace the target file

AnswerD

Atomic move ensures the target file is either fully written or not replaced, preventing partial writes.

Why this answer

Writing to a temporary file and then atomically moving it with `Files.move()` using the `ATOMIC_MOVE` option ensures that the target file is replaced only after the write succeeds. If the application crashes during the write, only the temporary file is corrupted, and the original target file remains intact. This prevents sensitive data from being left in an incomplete or partially written state in the file system.

Exam trap

The trap here is that candidates often confuse data flushing or locking with crash-safe file updates, but neither `flush()` nor `FileLock` provides atomicity guarantees, which is the key requirement for preventing data corruption after a crash.

How to eliminate wrong answers

Option A is wrong because calling `flush()` only forces buffered data to the underlying stream but does not guarantee that the data is fully written to disk or that the file is not left in an inconsistent state after a crash. Option B is wrong because manually deleting the file in a `finally` block cannot execute if the JVM crashes or the application is killed abruptly, leaving the sensitive data on disk. Option C is wrong because a `FileLock` prevents concurrent access from other JVM processes but does not protect against data loss or incomplete writes during a crash.

Full explanation →

152

MCQmedium

A developer wants to collect elements from a stream into an immutable List. Which collector should be used?

A.Collectors.toList()

B.Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)

C.Collectors.toList().stream().collect(Collectors.toUnmodifiableList())

D.Collectors.toUnmodifiableList()

AnswerD

Correct: Returns an unmodifiable list.

Why this answer

`Collectors.toUnmodifiableList()` directly returns a collector that accumulates elements into an immutable `List`. This was introduced in Java 10 and guarantees that the resulting list cannot be modified, throwing `UnsupportedOperationException` on any mutation attempt.

Exam trap

The trap here is that candidates may think `Collectors.toList()` returns an immutable list (since it's often used in read-only contexts), or they may overcomplicate the solution by chaining collectors when a direct method exists.

How to eliminate wrong answers

Option A is wrong because `Collectors.toList()` returns a mutable `List` (typically an `ArrayList`), not an immutable one. Option B is wrong because although `Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)` does produce an unmodifiable list, it is unnecessarily verbose and less efficient than the direct `toUnmodifiableList()` method; it also wraps a mutable list rather than creating a truly immutable list from the start. Option C is wrong because `Collectors.toList().stream().collect(Collectors.toUnmodifiableList())` is syntactically invalid — `Collectors.toList()` returns a `Collector`, not a `Stream`, so calling `.stream()` on it is a compile-time error.

Full explanation →

153

MCQmedium

A developer writes: List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add(1, "C"); System.out.println(list); What is the output?

A.[A, C, B]

B.[A, B, C]

C.[A, B]

D.[C, A, B]

AnswerA

Correct insertion order.

Why this answer

The `add(int index, E element)` method inserts the element at the specified index, shifting subsequent elements to the right. Initially, the list is [A, B]. After `list.add(1, "C")`, "C" is inserted at index 1, moving "B" to index 2, resulting in [A, C, B].

Exam trap

The trap here is that candidates often confuse the `add(E element)` method (which appends at the end) with the `add(int index, E element)` method (which inserts at a specific index), leading them to mistakenly think "C" is appended or placed at the beginning.

How to eliminate wrong answers

Option B is wrong because it assumes the `add(int index, E element)` method appends the element at the end, but it actually inserts at the given index. Option C is wrong because it omits the inserted element "C", ignoring the effect of the `add` method. Option D is wrong because it places "C" at the beginning (index 0), but the insertion was at index 1, not index 0.

Full explanation →

154

MCQmedium

Given the following code snippet inside a method: try { // risky code } catch (IOException | SQLException e) { // handle } What is the implicit type of the exception variable 'e' in the catch block?

A.It is of type Object.

B.It is of type Exception.

C.It is of type Throwable.

D.It is either IOException or SQLException.

AnswerB

The common base of IOException and SQLException is Exception.

Why this answer

In Java, when a multi-catch clause catches multiple exception types (e.g., IOException | SQLException), the compiler infers the catch parameter's type as the closest common superclass that is not Object or Throwable. Since IOException and SQLException both extend Exception directly, the implicit type of 'e' is Exception. This allows the catch block to handle both exception types polymorphically.

Exam trap

The trap here is that candidates mistakenly think 'e' has a union type (like TypeScript) or that the compiler uses the first listed exception type, when in fact Java infers the most specific common superclass, which is Exception for IOException and SQLException.

How to eliminate wrong answers

Option A is wrong because the implicit type is not Object; the compiler selects the most specific common superclass, which is Exception, not Object. Option C is wrong because Throwable is too broad; the common superclass of IOException and SQLException is Exception, not Throwable. Option D is wrong because 'e' is not a union type; it is a single type (Exception) that can reference either IOException or SQLException at runtime, but its compile-time type is Exception.

Full explanation →

155

MCQmedium

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?

A.9

B.4

C.3

D.5

AnswerB

4 is correct as the loop runs 4 times.

Why this answer

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.

Exam trap

Without the code, the answer is arbitrary. In a real exam, carefully examine the loop condition, initial value, and increment to avoid off-by-one errors. Here, if a loop runs for 4 iterations, the result is 4.

How to eliminate wrong answers

Option A is wrong because 9 would only result if the loop ran 9 times, but the condition `i < 4` limits execution to 4 iterations. Option C is wrong because 3 would occur if the loop started at i = 1 or if the condition were `i <= 3` and the loop ran only 3 times, but here it runs 4 times. Option D is wrong because 5 would require the loop to run 5 times, which would need a condition like `i <= 4` or `i < 5`, but the condition is `i < 4`.

Full explanation →

156

MCQhard

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

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

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

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

D.ZonedDateTime.of(2024,3,10,2,30,0,0,ZoneId.of("America/New_York")).withZoneSameInstant(ZoneOffset.UTC)

AnswerD

Correct: withZoneSameInstant converts to UTC while preserving the instant.

Why this answer

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.

Exam trap

Oracle often tests the misconception that a simple UTC offset or LocalDateTime can be used to represent a time that falls within a DST gap, when in fact you must use ZonedDateTime with the correct ZoneId to trigger the proper offset adjustment.

How to eliminate wrong answers

Option A is wrong because LocalDateTime.of(2024,3,10,2,30).atZone(ZoneOffset.UTC) creates a LocalDateTime without timezone context and then attaches UTC offset, resulting in 2:30 AM UTC, which ignores the DST transition in America/New_York. Option B is wrong because Instant.parse("2024-03-10T02:30:00Z") directly parses a UTC instant of 2:30 AM, which does not represent the equivalent time in New York after the DST spring-forward. Option C is wrong because OffsetDateTime.of(2024,3,10,2,30,0,0,ZoneOffset.UTC) creates a date-time with a fixed UTC offset of +00:00, again yielding 2:30 AM UTC and failing to account for the DST shift.

Full explanation →

157

MCQhard

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?

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

B.The loop terminates immediately, and the runtime exception propagates.

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

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

AnswerB

The runtime exception thrown in catch causes the loop to exit and the exception to propagate.

Why this answer

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.

Exam trap

The trap here is that candidates mistakenly think the finally block or the loop's condition allows the loop to continue, but the runtime exception thrown in the catch block immediately propagates, terminating the loop.

How to eliminate wrong answers

Option A is wrong because the runtime exception is thrown inside the loop, not after the loop; the finally block executes, but the exception propagates immediately, preventing any further loop iterations. Option C is wrong because the catch block throws a runtime exception, which is not caught within the loop, so the loop does not continue; the exception propagates. Option D is wrong because the runtime exception is not suppressed; it propagates after the finally block executes, and the loop terminates.

Full explanation →

158

Multi-Selecthard

Which two statements are true about Java module declarations? (Choose two.)

Select 2 answers

A.The uses directive is used to specify that a module provides a service implementation.

B.A module can read another module only if it explicitly requires it.

C.A qualified export allows access to the exported package only to specific modules.

D.The requires directive can be used to specify a module that is optional.

E.The opens directive allows reflective access to all types and members in the opened package, including private members.

AnswersC, E

Qualified exports restrict accessibility to a comma-separated list of module names.

Why this answer

A qualified export in a Java module declaration (using the 'exports ... to ...' syntax) restricts access to the exported package only to the specific modules listed after the 'to' keyword. This provides fine-grained control over which other modules can use the exported types, enhancing encapsulation and security.

Exam trap

The trap here is that candidates confuse the 'uses' directive with 'provides' (Option A) and mistakenly think 'requires' can make a module optional (Option D), when in fact 'requires static' is for optional compilation, not runtime optionality.

Full explanation →

159

MCQhard

A company uses jlink to create a custom runtime image. They want to reduce the image size by removing debug information. Which jlink option or plugin should they use?

A.--compress=2

B.--strip-debug

C.--no-header-files

D.--bind-services

AnswerB

Specifically removes debug information to reduce image size.

Why this answer

The `--strip-debug` option in jlink removes debug information from the custom runtime image, including line numbers, local variable tables, and source file references, which significantly reduces the image size. This is the correct option for stripping debug information, as it directly targets the removal of debugging metadata from the generated image.

Exam trap

The trap here is that candidates often confuse `--strip-debug` with `--compress=2`, assuming compression removes debug information, but compression only reduces file size without eliminating the underlying debug metadata.

How to eliminate wrong answers

Option A is wrong because `--compress=2` applies ZIP compression to resources in the runtime image, which reduces size through compression but does not remove debug information. Option C is wrong because `--no-header-files` excludes header files (e.g., C headers for native code) from the image, which is unrelated to debug information removal. Option D is wrong because `--bind-services` enables service binding resolution for modules, which affects module graph resolution but has no impact on debug information.

Full explanation →

160

MCQhard

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

A.The unmodifiable list remains unchanged

B.The unmodifiable list becomes inconsistent

C.An UnsupportedOperationException is thrown

D.The unmodifiable list reflects the addition

AnswerD

Unmodifiable wrapper is a view; changes to backing list are visible.

Why this answer

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.

Exam trap

The trap here is that candidates often assume `Collections.unmodifiableList()` creates an immutable copy, similar to `List.copyOf()`, but it actually creates a dynamic view that changes with the original list.

How to eliminate wrong answers

Option A is wrong because the unmodifiable list is a view of the original list, so it does change when the original list is modified. Option B is wrong because the unmodifiable list remains consistent with the original list; it does not become inconsistent. Option C is wrong because `UnsupportedOperationException` is thrown only when attempting to modify the unmodifiable list itself (e.g., calling `add()` on it), not when the original list is modified.

Full explanation →

161

MCQeasy

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?

A.Validate that the filename contains only alphanumeric characters.

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

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

D.Use File.getCanonicalPath() to resolve the path and check it starts with the intended directory.

AnswerD

By resolving the canonical path, the application can verify that the file lies within the allowed directory.

Why this answer

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

Exam trap

The trap here is that candidates often choose Option C (string replacement) because it seems straightforward, but they overlook that simple blacklisting of `..` and `/` is trivially bypassed by double-encoding, nested patterns, or Unicode normalization, whereas canonical path resolution is the only robust defense against path traversal.

How to eliminate wrong answers

Option A is wrong because restricting to alphanumeric characters is overly restrictive and still fails to prevent path traversal if the filename contains encoded traversal sequences (e.g., `%2e%2e%2f`) that are decoded after validation. Option B is wrong because while generating a random UUID eliminates the user-supplied filename entirely and prevents traversal, it is not a validation or sanitization technique; it is a complete replacement strategy that discards user intent, which may not be acceptable for all use cases (e.g., when the original filename must be preserved for business logic). Option C is wrong because simply replacing `..` and `/` with an empty string is easily bypassed by using nested patterns like `....//` which, after removal of `..` and `/`, leave `../` intact, or by using URL-encoded or Unicode variants that the replacement logic does not catch.

Full explanation →

162

MCQeasy

What does the following code print? List<Integer> list = List.of(1, 2, 3, 4, 5); list.stream().filter(i -> i % 2 == 0).forEach(System.out::print);

A.No output

B.12345

C.135

D.24

AnswerD

Correct.

Why this answer

The stream filters only even numbers (i % 2 == 0) from the list, producing 2 and 4, which are then printed sequentially via forEach. The filter operation retains elements where the predicate is true, so only 2 and 4 satisfy the condition.

Exam trap

The trap here is that candidates often confuse the filter predicate (i % 2 == 0) with selecting odd numbers, or they forget that filter retains matching elements rather than removing them, leading to selection of option C or B.

How to eliminate wrong answers

Option A is wrong because the stream pipeline does produce output; the filter does not eliminate all elements, so there is output. Option B is wrong because it prints all numbers (1,2,3,4,5), which would occur if no filter were applied, but the filter removes odd numbers. Option C is wrong because it prints odd numbers (1,3,5), which is the opposite of the filter condition (i % 2 == 0 selects even numbers).

Full explanation →

163

MCQhard

Which of the following will compile without error and produce an unmodifiable list containing three elements?

A.Arrays.asList("A","B","C")

B.new ArrayList<>(List.of("A","B","C"))

C.List.of("A","B","C")

D.Collections.unmodifiableList(new ArrayList<>(List.of("A","B","C")))

E.None of the above

AnswerC

Correct: List.of returns an immutable list.

Why this answer

`List.of("A","B","C")` returns an unmodifiable list exactly as required. In Java 9+, `List.of` returns an immutable list; any attempt to modify it throws `UnsupportedOperationException`. Option A, `Arrays.asList`, returns a fixed-size list backed by an array that allows modification via `set()`, so it is not unmodifiable.

Option B, `new ArrayList<>(List.of(...))`, creates a mutable ArrayList. Option D, `Collections.unmodifiableList`, returns an unmodifiable view, but the underlying ArrayList is still mutable; modifications to the original list affect the view, so it does not guarantee immutability. Therefore, only C meets the criteria.

Exam trap

The trap here is that candidates often confuse `Arrays.asList()` with an unmodifiable list, not realizing that `set()` is still permitted, while `List.of()` is truly immutable and the correct choice for an unmodifiable list in modern Java.

How to eliminate wrong answers

Option A is wrong because `Arrays.asList("A","B","C")` returns a fixed-size list backed by the array, but it is not truly unmodifiable — you can still call `set()` to change elements, so it does not produce an unmodifiable list. Option B is wrong because `new ArrayList<>(List.of("A","B","C"))` creates a mutable `ArrayList` that can be modified via `add()` or `remove()`, so it is not unmodifiable. Option D is wrong because `Collections.unmodifiableList(new ArrayList<>(List.of("A","B","C")))` does produce an unmodifiable view, but it is not the simplest or most direct way; the question asks for an option that 'will compile without error and produce an unmodifiable list', and while D technically works, it is not the best answer because it involves extra wrapping and the question implies a single method call.

Option E is wrong because option C is correct.

Full explanation →

164

Multi-Selecthard

Which TWO statements about Java serialization are true?

Select 2 answers

A.The serialVersionUID must be explicitly declared in every serializable class.

B.During deserialization, the constructor of the serialized class is not invoked.

C.A class that implements Externalizable does not need to implement Serializable.

D.Static fields are not serialized during serialization.

E.Fields marked as transient are serialized by default.

AnswersB, D

Deserialization uses special mechanism without constructor.

Why this answer

During deserialization, Java does not invoke the constructor of the class being deserialized. Instead, the object is reconstructed from the serialized stream data using the no-arg constructor of the first non-serializable superclass (if any), and the serialized class's fields are populated via reflection or readObject() methods. This avoids re-executing initialization logic that may have side effects or depend on runtime state.

Exam trap

The trap here is that candidates often assume constructors are always called during object creation, but Java serialization bypasses constructors for the serialized class, which can lead to unexpected behavior if initialization logic is missing.

Full explanation →

165

MCQeasy

Refer to the exhibit. What is the output?

A.compile error

B.null

C.false

D.true

AnswerD

Correct: Both return Boolean.TRUE, so == compares reference and is true.

Why this answer

The code uses `Boolean.valueOf(true)` which returns the `Boolean` constant `Boolean.TRUE`, and `Boolean.TRUE` is a singleton object that is `==` to itself. The `==` operator compares object references, not values, so the comparison `Boolean.valueOf(true) == Boolean.TRUE` evaluates to `true` because both refer to the same cached `Boolean` instance from the `Boolean` class's static final fields.

Exam trap

The trap here is that candidates mistakenly think `Boolean.valueOf(true)` returns a primitive `boolean` or a new object each time, leading them to believe `==` compares values or that the result is `false`, when in fact `valueOf` returns the cached singleton `Boolean.TRUE`.

How to eliminate wrong answers

Option A is wrong because the code compiles without error; `Boolean.valueOf(boolean)` is a valid static method that returns a `Boolean` object, and the `==` operator is valid for reference comparison. Option B is wrong because the output is not `null`; `Boolean.valueOf(true)` never returns `null`—it returns a non-null `Boolean` object. Option C is wrong because `false` would only occur if the `==` comparison evaluated to `false`, but since `Boolean.valueOf(true)` returns the same singleton as `Boolean.TRUE`, the reference equality is `true`.

Full explanation →

166

Multi-Selecthard

Which TWO are true about HashSet and TreeSet?

Select 2 answers

A.HashSet maintains elements in insertion order.

B.HashSet uses equals() and hashCode() for uniqueness, TreeSet uses compareTo() or Comparator.

C.Both implement the List interface.

D.Both guarantee constant-time performance for basic operations (add, remove, contains).

E.TreeSet requires elements to be mutually comparable, unless a Comparator is provided.

AnswersB, E

Correct.

Why this answer

HashSet relies on the equals() and hashCode() methods to determine element uniqueness, while TreeSet uses the natural ordering (compareTo()) or a provided Comparator to maintain sorted order and check for duplicates. This distinction is fundamental to how these Set implementations enforce uniqueness.

Exam trap

The trap here is that candidates often confuse the performance guarantees of HashSet (constant-time average) with TreeSet (logarithmic time), or mistakenly think both maintain insertion order, when in fact only LinkedHashSet does.

Full explanation →

167

MCQmedium

What does the following code print? List<Integer> list = new ArrayList<>(List.of(1,2,3)); list.replaceAll(x -> x * 2); System.out.println(list);

A.[2,3,4]

B.[2,4,6]

C.Compilation fails

D.[1,4,9]

E.[1,2,3]

AnswerB

Correct: each element is doubled.

Why this answer

The `replaceAll` method on a `List` applies the given `UnaryOperator` to each element, replacing it with the result. Here, `x -> x * 2` multiplies each integer by 2, so the list becomes `[2, 4, 6]`. Option B is correct because the code compiles and runs, producing that output.

Exam trap

The trap here is that candidates may think `replaceAll` doesn't exist on `List` or that it requires a `Comparator`, or they may confuse it with `replaceAll` on `Map` or `String`, leading them to incorrectly choose compilation failure (Option C).

How to eliminate wrong answers

Option A is wrong because it suggests the output is `[2,3,4]`, which would result from adding 1 to each element, not multiplying by 2. Option C is wrong because the code compiles successfully; `List.replaceAll` accepts a `UnaryOperator` lambda, and `List.of(1,2,3)` returns an immutable list, but `new ArrayList<>(List.of(1,2,3))` creates a mutable copy, so no compilation error occurs. Option D is wrong because it implies squaring each element (`x -> x * x`), not doubling.

Option E is wrong because it shows the original list unchanged, ignoring the effect of `replaceAll`.

Full explanation →

168

MCQmedium

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?

A.All three operations are allowed because the code base matches.

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

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

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

AnswerB

Operation 1 is allowed by "/data/config/*" (file in /data/config/). Operation 2 is explicitly granted. Operation 3 is in a subdirectory, not matched by *.

Why this answer

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.

Exam trap

In Oracle Java security policy, the wildcard (*) matches files in the immediate directory only, not subdirectories. To include subdirectories, the policy must use the recursive wildcard (-). For example, /data/config/* matches /data/config/settings.xml but not /data/config/subdir/extra.conf; /data/config/- would match both.

How to eliminate wrong answers

Option A is wrong because the code base match alone does not grant permissions; the security policy explicitly restricts access based on file paths, and operation 3 is denied due to the wildcard not covering subdirectories. Option C is wrong because operation 2 (write to /logs/app.log) is explicitly allowed by the grant for /logs/*. Option D is wrong because operation 3 is denied (the wildcard does not match subdirectories), and operation 2 is allowed, not denied.

Full explanation →

169

MCQhard

A team is developing a large enterprise application using Java 17. The application consists of multiple modules: core (provides logging and configuration), services (business logic), and web (REST endpoints). The modules are packaged as separate JAR files and deployed on a server. During runtime, the web module throws a java.lang.ClassNotFoundException for a class that is part of the core module. The core module's module-info.java exports the package containing the missing class. The web module's module-info.java requires core. However, the services module also needs the same class but uses a different version of it, causing conflicts. The team decides to use the class path for the conflicting package and the module path for the rest. They add the conflicting JAR to the class path and keep the other JARs on the module path. After this change, the web module still cannot find the class, but the services module works fine. What is the most likely cause of the issue?

A.The services module is using an automatic module, which automatically reads the unnamed module, while the web module is a named module that does not.

B.The class path is not scanned for JAR files unless the module path is empty.

C.The web module is a named module and cannot access classes from a split package that is also in the unnamed module.

D.The core module's module-info.java does not export the package to the web module; it only exports it to all modules.

AnswerC

The module system prevents named modules from accessing split packages from the class path to maintain reliable configuration.

Why this answer

When a named module (the web module) is on the module path, it cannot access classes from the unnamed module (the class path) if those classes belong to a package that is also exported by another named module on the module path. This creates a split package, which is forbidden by the Java module system. The core module exports the package, so the web module cannot load the class from the class path JAR, resulting in ClassNotFoundException.

Exam trap

The trap here is that candidates often think the issue is about module visibility (exports) or class path scanning order, but the real constraint is the split package rule, which prevents a named module from accessing a package that is already defined by another named module on the module path.

How to eliminate wrong answers

Option A is wrong because the services module is not necessarily an automatic module; the scenario states it uses a different version of the class from the class path, and automatic modules can read the unnamed module, but the core issue is about split packages, not automatic module behavior. Option B is wrong because the class path is scanned for JAR files even when the module path is non-empty; the unnamed module is always present and accessible to named modules only for packages not exported by any named module. Option D is wrong because the core module's module-info.java exports the package to all modules (implied by 'exports' without a 'to' clause), so it does export to the web module; the problem is the split package, not insufficient exports.

Full explanation →

170

MCQmedium

A developer wants to traverse a directory tree to find all files that are symbolic links. Which NIO.2 method should be used to follow symbolic links during traversal?

A.Files.newDirectoryStream(Path)

B.Files.list(Path)

C.Files.walk(Path) without options

D.Files.walk(Path, FileVisitOption.FOLLOW_LINKS)

AnswerD

This method with FOLLOW_LINKS will follow symbolic links during directory traversal.

Why this answer

`Files.walk(Path, FileVisitOption.FOLLOW_LINKS)` is the only method among the options that both traverses a directory tree recursively and explicitly follows symbolic links. The `FileVisitOption.FOLLOW_LINKS` enum constant instructs the walk to follow symbolic links, allowing the traversal to detect files that are themselves symbolic links. Without this option, `Files.walk` treats symbolic links as regular files and does not follow them, which would miss the target of the link.

Exam trap

The trap here is that candidates often assume `Files.walk(Path)` without options follows symbolic links by default, but the default behavior is to NOT follow links, and the `FOLLOW_LINKS` option must be explicitly provided to enable that behavior.

How to eliminate wrong answers

Option A is wrong because `Files.newDirectoryStream(Path)` returns a `DirectoryStream` that only lists the immediate entries of a single directory, not a recursive traversal, and it does not have any option to follow symbolic links. Option B is wrong because `Files.list(Path)` also only returns a stream of entries in a single directory (non-recursive) and cannot follow symbolic links. Option C is wrong because `Files.walk(Path)` without options performs a recursive traversal but does not follow symbolic links by default; it treats symbolic links as files and does not descend into directories that are symbolic links, so it would not find all files that are symbolic links in the sense of following them.

Full explanation →

171

Multi-Selecteasy

Which TWO of the following are characteristics of a well-designed lambda expression? (Choose two.)

Select 2 answers

A.Is stateless

B.Throws exceptions that are not declared in the functional interface's abstract method

C.Uses the same variable name as a parameter in the enclosing scope (shadowing)

D.Uses only effectively final variables from the enclosing scope

E.Modifies local variables of the enclosing method

AnswersA, D

Stateless lambdas are safer, especially in parallel streams, as they avoid race conditions.

Why this answer

A well-designed lambda expression should be stateless, meaning it does not depend on or modify mutable state from the enclosing scope. This ensures that the lambda can be safely executed in parallel streams without race conditions or side effects, aligning with the functional programming paradigm promoted by Java streams.

Exam trap

Oracle often tests the misconception that shadowing or modifying local variables is acceptable in lambdas, but the exam specifically requires understanding that only effectively final variables can be captured and that stateful lambdas are discouraged in well-designed code.

Full explanation →

172

Multi-Selectmedium

Which two statements are true about records in Java? (Choose two.)

Select 2 answers

A.Records provide a canonical constructor that initializes all components.

B.Records can be abstract.

C.Records can extend other classes.

D.Records can have instance fields that are not part of the record component list.

E.Records are implicitly final.

AnswersA, E

The canonical constructor initializes all record components.

Why this answer

A record in Java implicitly provides a canonical constructor that accepts all the components declared in the record header and initializes them. This constructor is generated by the compiler unless a custom canonical constructor is explicitly defined, ensuring that all component fields are set upon instantiation.

Exam trap

The trap here is that candidates often confuse records with regular classes and assume they can be abstract, extend other classes, or add extra instance fields, but the Java language explicitly restricts records to be final, to extend only java.lang.Record, and to have all instance fields derived from the component list.

Full explanation →

173

Multi-Selecthard

Which THREE practices are recommended for effective exception handling? (Choose three.)

Select 3 answers

A.Throw exceptions early, catch them late, but handle them at the appropriate level.

B.Define custom exceptions without providing any additional context.

C.Use try-with-resources for automatic resource management instead of manual close in finally.

D.Catch exceptions at the highest level of the application and log them generically.

E.Use specific exception types in catch blocks rather than catching Exception.

AnswersA, C, E

Best practice: throw at point of error, catch where recovery is possible.

Why this answer

Effective exception handling in Java recommends throwing exceptions as soon as an error is detected (fail-fast), catching them at a level where the error can be meaningfully handled (not too early), and handling them at the appropriate layer of abstraction. This prevents swallowing exceptions or losing context, and aligns with the principle of separation of concerns.

Exam trap

Oracle often tests the misconception that catching exceptions at the highest level with generic logging is a good practice, when in fact it hides errors and violates the principle of handling exceptions at the appropriate level.

Full explanation →

174

MCQmedium

A class implements Serializable. Which modification ensures that a specific field (password) is not included in the serialized stream?

A.Declare the field as volatile

B.Declare the field as transient

C.Declare the field as static

D.Declare the field as final

AnswerB

Transient fields are skipped during serialization.

Why this answer

The `transient` modifier is the correct mechanism in Java to exclude a specific field from the default serialization process. When a class implements `Serializable`, all non-transient instance fields are serialized by default. Marking the `password` field as `transient` ensures it is skipped during serialization and restored as `null` (or default value) upon deserialization.

Exam trap

The trap here is that candidates often confuse `transient` with `volatile` or `static`, mistakenly thinking that `volatile` affects serialization or that `static` is the proper way to exclude a field, when in fact `static` fields are excluded by default but are not appropriate for instance-specific data like a password.

How to eliminate wrong answers

Option A is wrong because `volatile` ensures visibility of changes to a field across threads but has no effect on serialization behavior. Option C is wrong because `static` fields belong to the class, not instances, and are not serialized by default, but this is not the intended mechanism for excluding an instance-specific field like password; using `static` would make the field shared across all instances, which is semantically incorrect. Option D is wrong because `final` fields are serialized normally and do not prevent the field from being included in the serialized stream.

Full explanation →

175

MCQmedium

A web server logs user sessions. Each session has a unique session ID (String) and a last access time (long). The system needs to evict sessions that have been inactive for more than 30 minutes. The current implementation uses a HashMap<String, Long> to store session IDs and last access times. A scheduled task iterates over all entries and removes those where currentTime - lastAccess > 30 minutes. However, this iteration is becoming slow as the number of sessions grows (millions). The developer wants to improve the eviction performance without affecting the O(1) put and get operations. Which approach should be taken?

A.Use PriorityQueue<Session> ordered by last access time and update the time when accessed.

B.Use ConcurrentHashMap<String, Long> and use parallel streams to remove expired entries.

C.Use LinkedHashMap<String, Long> with access-order=true and override removeEldestEntry() to evict entries older than 30 minutes.

D.Use TreeMap<String, Long> sorted by last access time and poll the first entry if too old.

AnswerC

Efficiently maintains access order and automatically evicts eldest.

Why this answer

LinkedHashMap with access-order=true and a custom removeEldestEntry() method provides O(1) amortized put/get operations while automatically evicting the least-recently accessed entry when a condition is met. By overriding removeEldestEntry() to check if the eldest entry's last access time is older than 30 minutes, the eviction happens during put operations without requiring a separate iteration over all entries, thus solving the performance issue.

Exam trap

The trap here is that candidates may think a sorted structure like TreeMap or PriorityQueue is needed for time-based eviction, but they overlook the O(1) access-time requirement and the fact that LinkedHashMap's access-order mode provides automatic LRU eviction without explicit iteration.

How to eliminate wrong answers

Option A is wrong because PriorityQueue does not support O(1) updates to the ordering key; updating the last access time would require removing and reinserting the element, which is O(log n) and disrupts the O(1) requirement for get operations. Option B is wrong because using parallel streams to iterate over a ConcurrentHashMap still requires scanning all entries, which is O(n) and does not improve the fundamental iteration cost; it also introduces thread-safety overhead without solving the algorithmic inefficiency. Option D is wrong because TreeMap maintains order by key (session ID), not by last access time; sorting by last access time would require a custom comparator that cannot be updated efficiently, and polling the first entry would not guarantee it is the oldest by access time.

Full explanation →

176

Multi-Selecthard

Which THREE are valid ways to read the contents of a text file into a String in Java?

Select 3 answers

A.String content = Files.readString(Path.of("file.txt"));

B.String content = new FileReader("file.txt").readString();

C.String content = Files.readAllLines(Path.of("file.txt"));

D.String content = new Scanner(new File("file.txt")).useDelimiter("\\Z").next();

E.String content = Files.lines(Path.of("file.txt")).collect(Collectors.joining("\n"));

AnswersA, D, E

Files.readString() reads entire file into a String.

Why this answer

`Files.readString()` (introduced in Java 11) reads the entire content of a text file into a `String` in one call, handling charset encoding (default UTF-8) and closing the file automatically. It is the simplest and most direct method for this task.

Exam trap

The trap here is that candidates may confuse `Files.readAllLines()` (which returns a `List`) with `Files.readString()` (which returns a `String`), or assume `FileReader` has a `readString()` method when it does not.

Full explanation →

177

Multi-Selecthard

Which TWO statements about creating custom exceptions are correct? (Choose two.)

Select 2 answers

A.Custom exceptions should extend Error to indicate fatal errors.

B.Custom exception classes should be declared final to prevent subclassing.

C.Custom exceptions must implement the Exception interface.

D.It is good practice to provide a constructor that takes a String message and a Throwable cause.

E.When calling super(cause) in a custom exception constructor, the cause is automatically set.

AnswersD, E

Common to have such constructor.

Why this answer

It is a well-established best practice in Java to provide a constructor that accepts both a String message and a Throwable cause, enabling precise error reporting and chaining of exceptions. This allows developers to pass a human-readable description along with the underlying cause, which is essential for debugging and logging.

Exam trap

The trap here is that candidates often confuse the requirement to extend Throwable (or a subclass) with implementing a nonexistent Exception interface, or they mistakenly think that custom exceptions must be declared final to prevent misuse, when in fact Java allows and encourages subclassing of custom exceptions for more granular error handling.

Full explanation →

178

MCQhard

Assuming the code runs in a multithreaded environment, which statement best describes the behavior?

A.The code will compile but throw an exception at runtime because of the use of parallel stream with stateful lambda.

B.It prints the doubled numbers in order (2, 4, 6, 8) and results contains [1,2,3,4] in that order.

C.It may produce a ConcurrentModificationException because results is modified while iterating.

D.It prints the doubled numbers in a non-deterministic order and results may contain missing or duplicate entries.

AnswerD

Correct: Parallel stream processes elements concurrently, so the order of map execution is non-deterministic. The shared results list is not thread-safe, leading to data corruption.

Why this answer

Using a parallel stream with a stateful lambda (e.g., modifying an external `results` list inside `peek` or `forEach`) introduces data races and non-deterministic behavior. The `peek` operation is not synchronized, so the order of printed doubled numbers is unpredictable, and concurrent modifications to the shared `results` list can cause missing or duplicate entries due to race conditions.

Exam trap

Oracle often tests the misconception that ConcurrentModificationException is the only risk when modifying a collection from multiple threads, but the actual trap here is that parallel streams with stateful lambdas cause data races leading to missing or duplicate entries, not necessarily an exception.

How to eliminate wrong answers

Option A is wrong because the code compiles and does not throw an exception solely due to using a parallel stream with a stateful lambda; the issue is data corruption, not an exception. Option B is wrong because parallel streams do not guarantee encounter order for non-terminal operations like `peek`, and the `results` list is not thread-safe, so neither the printed numbers nor the list order is deterministic. Option C is wrong because `ConcurrentModificationException` is typically thrown when a collection is structurally modified while being iterated via its own iterator, but here the modification occurs via `add` on a separate thread, which may cause race conditions but not necessarily that specific exception; the primary risk is missing or duplicate entries, not a guaranteed exception.

Full explanation →

179

MCQeasy

Examine the code: List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); for (String s : list) { list.remove(s); } What is the outcome?

A.A ConcurrentModificationException is thrown

B.The loop completes successfully and list becomes empty

C.An IllegalStateException is thrown

D.The loop completes successfully and list contains [B]

AnswerA

Modifying list during iteration with for-each throws exception.

Why this answer

The for-each loop internally uses an Iterator to traverse the list. When the list is structurally modified (via `list.remove()`) during iteration without using the iterator's own `remove()` method, the iterator detects a concurrent modification and throws a `ConcurrentModificationException`. This is a fail-fast behavior of the `ArrayList` iterator.

Exam trap

The trap here is that candidates often assume the for-each loop will safely remove elements one by one, not realizing that the implicit iterator throws an exception on structural modification.

How to eliminate wrong answers

Option B is wrong because the loop does not complete successfully; the exception is thrown before the list becomes empty. Option C is wrong because `IllegalStateException` is not thrown in this scenario; it is typically thrown when calling `remove()` on an iterator without a preceding `next()`. Option D is wrong because the loop does not complete and the list is not left containing [B]; the exception interrupts execution before any such state is reached.

Full explanation →

180

Multi-Selecteasy

Which TWO statements are true about ArrayList in Java 17? (Choose two.)

Select 2 answers

A.It implements the List interface

B.It implements the Set interface

C.It implements the Queue interface

D.It extends AbstractList

E.It is synchronized

AnswersA, D

ArrayList implements List.

Why this answer

ArrayList implements the List interface, which is a core part of the Java Collections Framework. This allows ArrayList to be used polymorphically wherever a List is expected, providing ordered, index-based access to elements.

Exam trap

The trap here is that candidates often confuse ArrayList's lack of synchronization with thread safety, or mistakenly think it implements Set or Queue due to its membership in the Collections Framework, but ArrayList is strictly a List implementation.

Full explanation →

181

Multi-Selectmedium

Which TWO of the following are checked exceptions in Java?

Select 2 answers

A.SQLException

B.ArithmeticException

C.ArrayIndexOutOfBoundsException

D.NullPointerException

E.IOException

AnswersA, E

SQLException is a checked exception.

Why this answer

A is correct because `SQLException` is a subclass of `java.lang.Exception` (which is a checked exception class) and does not extend `RuntimeException`. Checked exceptions must be either caught or declared in the method signature; `SQLException` is commonly thrown when database access errors occur, such as connection failures or SQL syntax errors.

Exam trap

The trap here is that candidates often confuse runtime exceptions (unchecked) with checked exceptions, mistakenly thinking that any exception that can occur at runtime is checked, but the key distinction is whether the exception class extends `RuntimeException` or not.

Full explanation →

182

MCQhard

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?

A.Deserialization succeeds and the new field is set to its default value.

B.Deserialization succeeds only if the new field is marked transient.

C.Deserialization throws StreamCorruptedException due to missing field.

D.Deserialization throws InvalidClassException because the class definition has changed.

AnswerA

With matching serialVersionUID, deserialization maps fields; new fields get default values.

Why this answer

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.

Exam trap

The trap here is that candidates often assume any class change (like adding a field) will break deserialization, but the exam tests that a matching serialVersionUID allows the new field to be silently defaulted, not that it causes an exception.

How to eliminate wrong answers

Option B is wrong because marking the new field transient is not required for deserialization to succeed; the field will be set to its default value regardless of the transient modifier. Option C is wrong because StreamCorruptedException is thrown only when the stream data is corrupted or the stream header is invalid, not when a field is missing due to a class evolution. Option D is wrong because InvalidClassException is thrown only when the serialVersionUIDs differ between the local class and the stream, not when fields are added or removed while the UID remains the same.

Full explanation →

183

MCQeasy

Which resource declaration order in try-with-resources is valid when both a FileInputStream and a BufferedInputStream wrapping it need to be closed automatically?

A.try (FileInputStream fis = new FileInputStream("a")) { BufferedInputStream bis = new BufferedInputStream(fis); ... }

B.try (FileInputStream fis = new FileInputStream("a"); BufferedInputStream bis = new BufferedInputStream(fis)) { ... }

C.try (BufferedInputStream bis = new BufferedInputStream(fis); FileInputStream fis = new FileInputStream("a")) { ... }

D.try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a"))) { ... }

AnswerB

Both resources are declared in order; fis is closed after bis as resources are closed in reverse order.

Why this answer

In a try-with-resources statement, resources are declared in order and closed in reverse order. By declaring FileInputStream first and then BufferedInputStream wrapping it, both resources are properly closed automatically, with the BufferedInputStream closed first (ensuring its buffer is flushed) and then the FileInputStream.

Exam trap

Oracle often tests the misconception that resources declared inside the try block (not in the resource list) are automatically closed, or that the order of declaration in try-with-resources does not matter for wrapping streams.

How to eliminate wrong answers

Option A is wrong because the BufferedInputStream is declared inside the try block, not in the resource declaration list, so it is not automatically closed by try-with-resources; it must be explicitly closed, which defeats the purpose. Option C is wrong because it attempts to use variable 'fis' before it is declared (compilation error), and the order of declaration is invalid as the wrapped stream must be declared before the wrapper. Option D is wrong because although it compiles and closes the anonymous FileInputStream, it does not declare a separate FileInputStream variable, so if you need to access the underlying stream (e.g., for getChannel()), you cannot; also, the anonymous resource is closed correctly but the pattern is less flexible.

Full explanation →

184

Multi-Selecthard

Which two statements are true about FileInputStream? (Select two.)

Select 2 answers

A.It supports mark() and reset().

B.It extends java.io.InputStream.

C.It implements java.io.Closeable.

D.It reads data in big-endian order.

E.It can be used to read characters.

AnswersB, C

FileInputStream is a subclass of InputStream.

Why this answer

FileInputStream directly extends java.io.InputStream, inheriting its abstract methods for reading bytes from a file. Option C is correct because FileInputStream implements java.io.Closeable, which extends AutoCloseable, allowing it to be used in try-with-resources statements for automatic resource management.

Exam trap

The trap here is that candidates often confuse FileInputStream with BufferedInputStream or DataInputStream, assuming it supports mark/reset or reads data in a specific byte order, when in fact it is a simple unbuffered byte stream with no such capabilities.

Full explanation →

185

MCQmedium

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?

A.Use a FileInputStream wrapped in a BufferedInputStream with a 8 KB buffer

B.Read the entire file into a byte array using Files.readAllBytes()

C.Use a FileReader wrapped in a BufferedReader to read lines

D.Use a RandomAccessFile to read the file in segments

AnswerA

This reads the file in chunks with a small buffer, minimizing memory footprint.

Why this answer

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.

Exam trap

The trap here is that candidates often confuse 'least memory' with 'fastest performance' and choose Files.readAllBytes() for simplicity, or they incorrectly assume RandomAccessFile is more memory-efficient, when in fact buffered streaming is the standard low-memory approach for large binary files.

How to eliminate wrong answers

Option B is wrong because Files.readAllBytes() reads the entire file into a single byte array, which would require at least 1 GB of heap memory, defeating the goal of minimal memory usage. Option C is wrong because FileReader and BufferedReader are designed for character-based text files, not binary data; reading a binary file as characters would corrupt the data and still buffer large amounts unnecessarily. Option D is wrong because RandomAccessFile is primarily for random access and seeking within a file, not for sequential streaming; it still requires managing file pointers and does not inherently reduce memory usage compared to a buffered stream.

Full explanation →

186

MCQeasy

You are designing a logging framework for a distributed application. The framework must support multiple output destinations (console, file, network socket) and allow clients to dynamically add new destinations at runtime without modifying existing code. Currently, the application uses a single static Logger class with methods like logToConsole(String msg) and logToFile(String msg). The team needs to refactor the code to adhere to the Open/Closed Principle and support extensibility. After reviewing the requirements, you propose using a combination of an interface and a strategy pattern. However, a senior developer argues that using a simple enum with abstract methods would be sufficient. Which course of action best adheres to object-oriented design principles and allows the most flexibility for future extensions?

A.Keep the existing static methods but add a new method for each destination as needed. Use conditional logic to select the destination at runtime.

B.Refactor Logger to be an interface, and implement concrete destination classes (ConsoleLogger, FileLogger, SocketLogger). Use dependency injection to pass the desired destination to the Logger client.

C.Create an enum LogDestination with values CONSOLE, FILE, SOCKET, each overriding an abstract log(String) method. The Logger class uses a static method that accepts a LogDestination and calls its log method.

D.Refactor Logger to be an abstract class with an abstract log method, and create subclasses for each destination. Use a factory method to instantiate the correct subclass.

AnswerB

This follows the strategy pattern and Open/Closed Principle, allowing new destinations to be added without modifying existing code.

Why this answer

Refactors Logger to be an interface and uses dependency injection, allowing clients to pass any implementation. This adheres to the Open/Closed Principle because new destinations can be added by creating new classes implementing Logger without modifying existing code. Option C (using an enum with abstract methods) violates OCP because adding a new destination requires modifying the enum.

Option A (keeping static methods and adding new ones) also requires modification of the Logger class. Option D (abstract class with subclasses and factory) still requires modifying the factory when adding new destinations, reducing flexibility.

Full explanation →

187

MCQmedium

A program reads user input as a string and needs to parse it into an integer, handling invalid input gracefully. Which code snippet correctly uses try-catch to parse and prints the result or 'Invalid number'?

A.try { int num = Integer.valueOf(input).intValue(); System.out.println(num); } catch (Exception e) { System.out.println("Invalid number"); }

B.int num = Integer.parseInt(input); System.out.println(num);

C.if (input.matches("\\d+")) { int num = Integer.parseInt(input); System.out.println(num); } else { System.out.println("Invalid number"); }

D.try { int num = Integer.parseInt(input); System.out.println(num); } catch (NumberFormatException e) { System.out.println("Invalid number"); }

AnswerD

Correct: Catches the specific exception and prints an error message.

Why this answer

It uses `Integer.parseInt(input)` which throws a `NumberFormatException` for invalid input, and the catch block specifically catches that exception to print 'Invalid number'. This is the standard, idiomatic Java approach for parsing integers with error handling, as it directly addresses the requirement without unnecessary overhead or false positives.

Exam trap

The trap here is that candidates often choose Option C (regex validation) thinking it's more efficient or 'cleaner', but they overlook that the regex `\d+` fails for negative numbers and other valid integer formats, while the try-catch approach in D is both correct and idiomatic for Java.

How to eliminate wrong answers

Option A is wrong because `Integer.valueOf(input).intValue()` is redundant (valueOf returns an Integer, then intValue unboxes it) and catches the overly broad `Exception` type, which is poor practice and could mask unrelated errors. Option B is wrong because it has no error handling at all; if the input is not a valid integer, `Integer.parseInt` will throw a `NumberFormatException` and the program will crash. Option C is wrong because the regex `\d+` does not account for optional leading minus signs (negative numbers) or leading zeros, so it would incorrectly reject valid integers like '-5' or accept invalid strings like empty input (if input is empty, matches returns false, but the logic is still flawed for negative numbers).

Full explanation →

188

MCQeasy

Given the code snippet: List<String> list = new ArrayList<>(List.of("A","B","C")); list.add("D"); System.out.println(list.size()); What is the result?

A.5

B.UnsupportedOperationException

C.4

D.Compilation fails

E.3

AnswerC

Correct: the new ArrayList is mutable, so add works, size is 4.

Why this answer

The code creates an ArrayList from a fixed-size list returned by List.of() using the ArrayList constructor, which creates a new mutable list containing the elements "A", "B", "C". The subsequent call to list.add("D") successfully appends the element, resulting in a list of size 4. The ArrayList constructor copies the elements, so the original immutable list is not modified.

Exam trap

The trap here is that candidates mistakenly think the list returned by List.of() is directly used, leading them to expect an UnsupportedOperationException, but the ArrayList constructor creates a separate mutable copy, so the add() succeeds.

How to eliminate wrong answers

Option A is wrong because the list contains only 4 elements after adding "D", not 5. Option B is wrong because UnsupportedOperationException would occur if add() were called directly on the list returned by List.of(), but here the list is wrapped in a new ArrayList, which is fully mutable. Option D is wrong because the code compiles without errors; all types and method calls are valid.

Option E is wrong because the list initially has 3 elements from List.of(), but after adding "D", the size becomes 4, not 3.

Full explanation →

189

MCQhard

Which statement about the code is correct?

A.A compilation error occurs in the Triangle class because Triangle is not listed in the permits clause.

B.A compilation error occurs because Circle must be declared final.

C.A compilation error occurs because Shape must be declared abstract.

D.The code compiles successfully.

AnswerA

Sealed classes require that all direct subclasses be listed in the permits clause.

Why this answer

In a sealed class hierarchy, the `permits` clause must list all direct subclasses. If `Triangle` extends `Shape` but is not listed in the `permits` clause of `Shape`, the compiler will report an error. The sealed class mechanism enforces that only explicitly permitted subclasses may extend the sealed class.

Exam trap

The trap here is that candidates often overlook the requirement that every direct subclass of a sealed class must be explicitly listed in the `permits` clause, assuming that simply extending the sealed class is sufficient.

How to eliminate wrong answers

Option B is wrong because `Circle` does not need to be declared `final`; it can be `sealed`, `non-sealed`, or `final`, but the error here is unrelated to `Circle`'s declaration. Option C is wrong because `Shape` is already declared `sealed`, which implicitly makes it abstract, so no explicit `abstract` modifier is required. Option D is wrong because the code does not compile due to the missing `Triangle` in the `permits` clause.

Full explanation →

190

Multi-Selectmedium

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

Select 2 answers

A.Comparator's compare method returns a boolean.

B.Comparator can be used to sort a list in multiple ways.

C.A class implementing Comparable must override equals().

D.Comparable is used to define a natural ordering of objects.

E.Comparator is in java.lang package.

AnswersB, D

True: Multiple Comparators can define different orderings.

Why this answer

The Comparator interface allows you to define multiple different comparison strategies (e.g., by name, by age, by salary) for the same class, enabling sorting of a list in multiple ways. Option D is correct because the Comparable interface is used to define a natural ordering of objects (e.g., String's lexicographic order, Integer's numeric order) by implementing the compareTo method.

Exam trap

The trap here is that candidates often confuse the return type of Comparator.compare (int) with a boolean, or mistakenly think Comparable forces an override of equals, when in fact only compareTo is required.

Full explanation →

191

MCQhard

A company runs a Java 17 microservice that processes real-time financial transactions. The application receives a large number of transactions per second, each with a timestamp, amount, and type. The current implementation uses a sequential stream to filter and aggregate transactions into a Map<TransactionType, DoubleSummaryStatistics>. The team observes high latency and CPU spikes during peak loads. They suspect the stream pipeline is inefficient. The pipeline code is: Map<TransactionType, DoubleSummaryStatistics> stats = transactions.stream() .filter(t -> t.getTimestamp().isAfter(Instant.now().minusSeconds(60))) .collect(Collectors.groupingBy(Transaction::getType, Collectors.summarizingDouble(Transaction::getAmount))); The transactions list is an ArrayList that is frequently modified by other threads (adding new transactions). The system has multiple CPU cores available. Which of the following changes is the MOST effective way to improve performance while maintaining correctness?

A.Use .stream().parallel() with a custom thread pool and ensure the stream source is not modified during operation.

B.Use .parallelStream() on a snapshot (new ArrayList<>(transactions)) and keep the same collector.

C.Replace ArrayList with CopyOnWriteArrayList and use .parallelStream() with the same collector.

D.Replace the collector with Collectors.groupingByConcurrent() and use .parallelStream() directly on the original list.

AnswerB

Correct. The snapshot eliminates concurrent modification issues, and parallel processing improves throughput.

Why this answer

Taking a snapshot via new ArrayList<>(transactions) provides a consistent, immutable view for the stream, reducing contention and allowing parallelStream to leverage multiple cores. However, the copy operation itself is not thread-safe and can throw ConcurrentModificationException if the list is being modified simultaneously. Despite this risk, option B is the most effective among the choices because it attempts to isolate the stream from concurrent modifications and uses a parallel-friendly collector.

To guarantee correctness, additional synchronization would be required, but none of the other options offer a better combination of performance and safety.

Full explanation →

192

Multi-Selectmedium

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

Select 2 answers

A.Resources are closed in the order they are declared.

B.If both the try block and the close method throw exceptions, the close exception is suppressed.

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

D.Resources must implement AutoCloseable.

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

AnswersB, D

Suppressed exception mechanism.

Why this answer

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.

Exam trap

The trap here is that candidates often assume resources close in declaration order (A) or that only one resource is allowed (C), but the exam tests the reverse close order and the ability to manage multiple resources, as well as the precise timing of resource closure relative to catch blocks.

Full explanation →

193

MCQeasy

What is the result of attempting to compile and run the following code? ```java import java.util.*; List<String> list = Arrays.asList("A", "B"); list.removeIf(s -> s.startsWith("A")); System.out.println(list); ```

A.[A, B]

B.[A]

C.[B]

D.Compilation fails

E.Runtime exception

AnswerE

Correct. `Arrays.asList` returns a fixed-size list; calling `removeIf` throws `UnsupportedOperationException`.

Why this answer

The code compiles successfully because `removeIf` is a default method in `Collection` and the predicate is a valid lambda. However, `Arrays.asList` returns a fixed-size list backed by the array, and `removeIf` attempts to modify the list structurally, which throws `UnsupportedOperationException` at runtime. Therefore, the correct answer is E: Runtime exception.

Exam trap

A common mistake is to focus on the lambda syntax and assume the code compiles and runs, outputting [B]. However, Arrays.asList returns a fixed-size list, so removeIf throws UnsupportedOperationException at runtime.

How to eliminate wrong answers

Option A is wrong because the list does not become [A, B] after removal; the code throws an exception before any removal. Option B is wrong because the list does not become [A]; the exception prevents any modification. Option C is wrong because the list does not become [B]; the exception occurs before the removal operation completes.

Option D is wrong because the code compiles successfully; `removeIf` is a valid method on `List` and the lambda is syntactically correct.

Full explanation →

194

MCQhard

A financial application uses Java SE 17 with a custom date format. The requirement is to parse strings like "2023-12-31T23:59:59.999Z" into an Instant. The existing code uses SimpleDateFormat with pattern "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'" and then calls parse(). It works fine in single-threaded testing, but in production under load, intermittent parsing failures occur with DateTimeParseException or wrong values. The application is multi-threaded and reuses the same formatter instance. Which single change should be made to fix the issue while maintaining performance?

A.Wrap the parse call in a synchronized block

B.Use a ThreadLocal<SimpleDateFormat> to give each thread its own instance

C.Replace SimpleDateFormat with DateTimeFormatter.ISO_INSTANT and use Instant.from()

D.Create a new SimpleDateFormat instance for each parse call

AnswerC

Thread-safe and correct for ISO 8601.

Why this answer

`SimpleDateFormat` is not thread-safe, and reusing a single instance across multiple threads causes race conditions leading to parsing failures. Replacing it with `DateTimeFormatter.ISO_INSTANT` (which is immutable and thread-safe) and using `Instant.from()` directly parses the ISO 8601 string without any synchronization overhead, maintaining performance while fixing the concurrency bug.

Exam trap

The trap here is that candidates often choose `ThreadLocal<SimpleDateFormat>` (Option B) because it technically fixes the thread-safety issue, but they overlook that the modern `java.time` API is the recommended, simpler, and more performant solution for Java SE 17, and that the exam expects you to prefer the new API over patching the old one.

How to eliminate wrong answers

Option A is wrong because wrapping the parse call in a `synchronized` block would serialize all parsing operations, severely degrading performance under load and defeating the purpose of multi-threading. Option B is wrong because while `ThreadLocal<SimpleDateFormat>` would fix thread-safety, it still uses the legacy `SimpleDateFormat` class which is error-prone and less efficient than the modern `java.time` API; it also adds unnecessary complexity. Option D is wrong because creating a new `SimpleDateFormat` instance for each parse call would work but imposes significant object creation overhead and garbage collection pressure, harming performance in a high-throughput production environment.

Full explanation →

195

Multi-Selecthard

Which two statements about the enhanced for-each loop in Java are true? (Choose two.)

Select 2 answers

A.It requires the target to implement the Iterable interface, except for arrays.

B.It can safely modify the underlying collection during iteration.

C.It can be used to iterate directly over a Stream object.

D.It can be used to iterate over an array.

E.It provides an implicit counter variable that can be accessed.

AnswersA, D

For arrays, the loop works directly; for other objects, they must implement Iterable.

Why this answer

The enhanced for-each loop requires the target to implement the Iterable interface, except for arrays, which are handled natively by the compiler using index-based iteration. This is specified in the Java Language Specification (JLS §14.14.2), where arrays are a special case that does not require Iterable.

Exam trap

The trap here is that candidates often think the enhanced for-each loop can safely modify collections because it 'hides' the iterator, but it actually exposes the same fail-fast behavior as explicit iterator usage.

Full explanation →

196

MCQeasy

A developer is designing a loop to iterate through an array of integers and stop processing when the value -1 is encountered. Which loop construct should be used?

A.for(int i : array) { if(i == -1) exit; }

B.for(int i : array) { if(i == -1) return; }

C.for(int i : array) { if(i == -1) break; }

D.for(int i : array) { if(i == -1) continue; }

AnswerC

The break statement immediately exits the loop, which is the correct way to stop processing upon encountering -1.

Why this answer

The `break` statement immediately terminates the loop when the value -1 is encountered, which is exactly what the requirement specifies. In Java, `break` exits the innermost loop or switch statement, making it the appropriate control flow mechanism for stopping iteration upon a condition.

Exam trap

The trap here is that candidates often confuse `break` with `continue` or mistakenly use `return` or `exit` to exit a loop, not realizing that `break` is the precise mechanism for loop termination without affecting the rest of the method or JVM.

How to eliminate wrong answers

Option A is wrong because `exit` is not a valid Java keyword or statement; the correct syntax would be `System.exit(0)`, but that would terminate the entire JVM, not just the loop. Option B is wrong because `return` exits the current method, not just the loop, which would prematurely end the enclosing method and is too broad for simply stopping iteration. Option D is wrong because `continue` skips the current iteration and proceeds to the next element, which does not stop the loop when -1 is found.

Full explanation →

197

MCQmedium

What is the output of the code in the exhibit?

A.1,234.57 €

B.€1,234.57

C.€ 1.234,57

D.1.234,57 €

AnswerD

Correct: German format with comma as decimal.

Why this answer

The code uses `NumberFormat.getCurrencyInstance(Locale.GERMANY)`, which formats currency according to the German locale. In Germany, the currency symbol (€) is placed after the amount, a comma is used as the decimal separator, and a period is used as the thousands separator. Thus, 1234.5678 is rounded to two decimal places using half-even rounding and displayed as '1.234,57 €'.

Exam trap

The trap here is that many candidates assume the euro symbol always appears before the amount (like in the US or UK), but the German locale places it after the amount, and the decimal separator is a comma, not a period.

How to eliminate wrong answers

Option A is wrong because it places the currency symbol after the amount but uses a comma as the thousands separator and a period as the decimal separator, which is the format for locales like the US, not Germany. Option B is wrong because it places the currency symbol before the amount with a period as the decimal separator, which is typical for English locales (e.g., US or UK), not for Germany. Option C is wrong because it places the currency symbol before the amount with a comma as the decimal separator, which is not the standard German format; in Germany, the symbol is placed after the amount.

Full explanation →

198

MCQmedium

What is the output of the following code? int i=5; do { System.out.print(i); i--; } while(i>0);

A.54321

B.Compilation error

C.543210

D.5432

AnswerA

The loop prints each number from 5 down to 1.

Why this answer

The do-while loop executes the body first, printing the current value of i (5), then decrements i to 4. The loop continues while i > 0, so it prints 5, 4, 3, 2, 1, and stops when i becomes 0, as the condition i > 0 is false. This results in the output "54321".

Exam trap

The trap here is that candidates often mistakenly think the loop prints 0 because they overlook that the condition is checked after the body executes, and the loop exits when i becomes 0 without printing it.

How to eliminate wrong answers

Option B is wrong because the code compiles successfully; there is no syntax error in the do-while loop or variable declaration. Option C is wrong because the loop condition is i > 0, so when i becomes 0, the loop terminates before printing 0, thus the output is "54321" not "543210". Option D is wrong because the loop prints all values from 5 down to 1, not stopping at 2; the condition i > 0 ensures i=1 is printed before the loop ends.

Full explanation →

199

MCQhard

Your team manages a high-throughput financial transaction system running on Java 17. Recently, the application experiences intermittent slowdowns and increased CPU usage during peak hours. Monitoring reveals that exception handling code is invoked frequently due to validation errors in incoming data. The system uses a central exception handler that logs every exception and throws a custom ApplicationException. In many places, the code catches generic Exception and rethrows the custom exception after logging. Additionally, method signatures include throws Exception. The team wants to improve performance and maintainability without changing the external behavior significantly. Which course of action best addresses the performance and maintainability issues?

A.Change all catch blocks to catch Throwable and ignore irrecoverable errors to reduce logging.

B.Add a try-catch block around every method call that might throw an exception to handle locally.

C.Define specific custom checked exception classes for each validation error and catch them precisely, avoiding generic Exception catches.

D.Wrap all exceptions in a single custom unchecked exception to simplify exception handling.

AnswerC

Precise catch reduces unnecessary handling and improves performance.

Why this answer

Catching generic `Exception` forces the JVM to build a full stack trace for every validation error, which is expensive in a high-throughput system. By defining specific custom checked exception classes and catching them precisely, the team reduces unnecessary stack trace generation and makes the code more maintainable by clearly documenting which errors are expected. This approach aligns with Java best practices for exception handling, improving both performance and code clarity without altering external behavior.

Exam trap

The trap here is that candidates often think wrapping all exceptions in a single unchecked exception simplifies code (Option D), but the exam tests the principle that precise exception handling improves both performance and maintainability, while broad catches or unchecked wrappers degrade them.

How to eliminate wrong answers

Option A is wrong because catching `Throwable` includes `Error` subclasses (e.g., `OutOfMemoryError`), which are irrecoverable and should not be caught or ignored; doing so can mask critical JVM failures and violate Java's exception hierarchy design. Option B is wrong because adding a try-catch around every method call that might throw an exception leads to excessive nesting, code duplication, and still does not address the root cause of generic `Exception` catches; it also degrades performance by adding unnecessary control flow overhead. Option D is wrong because wrapping all exceptions in a single custom unchecked exception (e.g., extending `RuntimeException`) eliminates compile-time checking, making it harder to handle specific validation errors and potentially hiding bugs; it also forces callers to either catch a broad type or let exceptions propagate unchecked, which is the opposite of maintainability.

Full explanation →

200

MCQhard

Which is true about CopyOnWriteArrayList?

A.It is not thread-safe.

B.Iterators reflect concurrent modifications.

C.Modifications are expensive as they create a new array.

D.It is optimized for frequent modifications.

AnswerC

Each modification copies the underlying array.

Why this answer

CopyOnWriteArrayList is a thread-safe variant of ArrayList where all mutative operations (add, set, remove, etc.) are implemented by making a fresh copy of the underlying array. This design makes modifications expensive because each modification requires copying the entire array, but it provides safe iteration without locking. Option C correctly identifies that modifications are expensive due to the array copy.

Exam trap

The trap here is that candidates often assume 'thread-safe' collections like CopyOnWriteArrayList allow iterators to see concurrent modifications (like ConcurrentHashMap does), but CopyOnWriteArrayList iterators are snapshot-based and do not reflect modifications after creation.

How to eliminate wrong answers

Option A is wrong because CopyOnWriteArrayList is explicitly thread-safe; it uses a volatile reference and a copy-on-write strategy to ensure visibility and atomicity without external synchronization. Option B is wrong because iterators on CopyOnWriteArrayList reflect a snapshot of the array at the time the iterator was created; they do not see concurrent modifications after creation. Option D is wrong because CopyOnWriteArrayList is optimized for frequent reads and infrequent modifications; modifications are expensive due to array copying, so it is not optimized for frequent modifications.

Full explanation →

201

MCQhard

A Java application uses FileChannel to copy a file to a remote network drive. The developer wants to ensure atomic file replacement on the destination. Which approach is correct?

A.Delete the destination file, then rename the temporary file.

B.Use Files.move() with StandardCopyOption.ATOMIC_MOVE.

C.Use FileChannel.transferTo() to write directly.

D.Use Files.copy() with REPLACE_EXISTING option.

AnswerB

Requests atomic move; throws exception if not supported.

Why this answer

`Files.move()` with `StandardCopyOption.ATOMIC_MOVE` guarantees that the file replacement on the destination file system is atomic — either the entire move succeeds or the original state remains intact. This is essential for remote network drives where partial writes or concurrent access could leave the destination in an inconsistent state. The `ATOMIC_MOVE` option leverages file system–level atomic rename operations (e.g., NFS or SMB support) to ensure no intermediate state is visible.

Exam trap

The trap here is that candidates often assume `Files.copy()` with `REPLACE_EXISTING` or `FileChannel.transferTo()` provides atomicity because they replace the destination, but neither guarantees that the replacement is atomic — only `ATOMIC_MOVE` ensures the entire operation is indivisible at the file system level.

How to eliminate wrong answers

Option A is wrong because deleting the destination file and then renaming a temporary file is not atomic — a crash or concurrent access between the delete and rename can leave the destination missing or in an inconsistent state. Option C is wrong because `FileChannel.transferTo()` performs a direct, non-atomic copy that does not guarantee atomic replacement; it writes data in chunks and can leave a partial file on the destination if interrupted. Option D is wrong because `Files.copy()` with `REPLACE_EXISTING` replaces the destination file but does so as a non-atomic copy operation, meaning the destination may be overwritten partially or left in an inconsistent state if the copy fails.

Full explanation →

202

MCQeasy

A developer creates a Java application that uses the new 'jpackage' tool to create an installer for Windows. The application is modular and has a main class declared in module-info. Which option is required to specify the main class when using jpackage?

A.-classpath

B.--module-path

C.--main-jar

D.--module

AnswerD

For modular applications, jpackage uses --module to specify the main module, and the application's main class is derived from the module descriptor.

Why this answer

For a modular application with a main class declared in module-info, jpackage requires the `--module` option to specify the module name and, optionally, the main class (e.g., `--module com.example/com.example.Main`). This is because jpackage uses the module system to resolve the entry point, not a classpath or JAR-based approach.

Exam trap

The trap here is that candidates confuse `--module` with `--module-path` or `--main-jar`, mistakenly thinking the main class must be specified via a JAR or classpath even when the module system already declares it.

How to eliminate wrong answers

Option A is wrong because `-classpath` is a legacy option for specifying class paths in non-modular applications, and jpackage does not support it for modular applications. Option B is wrong because `--module-path` is used to specify the location of module directories or JARs, not to declare the main class. Option C is wrong because `--main-jar` is used for non-modular applications packaged as JARs, not for modular applications where the main class is defined in module-info.

Full explanation →

203

MCQmedium

Given an enum Direction { NORTH, SOUTH, EAST, WEST } and a variable d of type Direction, which code snippet correctly uses a switch expression to map each direction to an abbreviation (N, S, E, W) without using a default branch?

A.switch (d) { case NORTH -> "N"; case SOUTH -> "S"; case EAST -> "E"; case WEST -> "W"; }

B.switch (d) { case NORTH: yield "N"; case SOUTH: yield "S"; case EAST: yield "E"; case WEST: yield "W"; }

C.switch (d) { case NORTH -> "N"; case SOUTH -> "S"; case EAST -> "E"; }

D.switch (d) { case NORTH: yield "N"; case SOUTH: yield "S"; case EAST: yield "E"; default: yield "W"; }

AnswerA

Correct arrow syntax covering all enum values.

Why this answer

It uses the arrow syntax in a switch expression, which requires that all possible enum values are covered without a default branch. Since Direction has exactly four constants and each is mapped to a yield value via the arrow, the switch is exhaustive and compiles successfully.

Exam trap

The trap here is that candidates often confuse switch statements with switch expressions, assuming colon syntax with yield is valid, or they forget that switch expressions must be exhaustive when no default is provided, leading them to choose an option with missing cases or an unnecessary default.

How to eliminate wrong answers

Option B is wrong because it uses colon syntax with yield, which is valid only in a switch expression, but the colon syntax requires a default branch when the switch is not exhaustive; however, the real issue is that the colon syntax with yield is not allowed in a switch expression—only arrow syntax or colon syntax with break/return are permitted in switch statements, and yield is only for switch expressions with arrow syntax. Option C is wrong because it omits the case for WEST, making the switch non-exhaustive for the enum Direction, which causes a compilation error since switch expressions must cover all enum constants. Option D is wrong because it includes a default branch, which violates the requirement to map each direction without using a default branch.

Full explanation →

204

MCQmedium

A developer creates a module `com.example.app` that requires `java.sql` and `com.example.util`. The module is compiled and packaged into a JAR. When launching the application with `java --module-path app.jar:lib --module com.example.app`, it fails with `java.lang.module.ResolutionException: Module com.example.util not found`. What is the most likely cause?

A.The module `com.example.util` is an automatic module and requires specific flags.

B.The module `com.example.util` is not in the module path.

C.The module `com.example.util` is a named module but not exported.

D.The module `com.example.util` is on the classpath and not visible to module system.

AnswerB

The module path must include all required modules explicitly.

Why this answer

The error `Module com.example.util not found` indicates that the module system cannot locate `com.example.util` on the module path. Since the command specifies `--module-path app.jar:lib`, the JAR for `com.example.util` must be present in the `lib` directory (or another directory on that path). If it is missing or not in the correct location, the module resolution fails.

Option B correctly identifies that the module is simply not on the module path.

Exam trap

Oracle often tests the distinction between module resolution failures (missing module) and access control failures (module found but not exported), so candidates may incorrectly choose an option about exports or classpath visibility when the actual issue is that the module JAR is simply not present on the module path.

How to eliminate wrong answers

Option A is wrong because automatic modules do not require special flags to be found; they are resolved automatically when placed on the module path. Option C is wrong because a named module that is not exported would cause an `IllegalAccessError` at runtime, not a `ResolutionException` at startup. Option D is wrong because placing a module on the classpath makes it invisible to the module system for `requires` directives; the module system only resolves modules from the module path, not the classpath.

Full explanation →

205

Multi-Selectmedium

Which TWO are valid ways to create an immutable list in Java 17? (Choose two.)

Select 2 answers

A.Arrays.asList("a", "b")

B.List.of(List.of("a", "b"))

C.Collections.unmodifiableList(new ArrayList<>(List.of("a", "b")))

D.List.copyOf(Arrays.asList("a", "b"))

E.new ArrayList<>(List.of("a", "b"))

AnswersC, D

Wraps list to be unmodifiable.

Why this answer

`Collections.unmodifiableList()` wraps a mutable list in an unmodifiable view, preventing any structural modifications. Option D is correct because `List.copyOf()` creates an immutable list from an existing collection, throwing `NullPointerException` if any element is null. Both produce lists that cannot be modified after creation.

Exam trap

Oracle often tests the distinction between an unmodifiable view (which can be circumvented if the backing list is accessible) and a truly immutable list (which cannot be changed by any means), and candidates mistakenly think `Arrays.asList()` or `new ArrayList<>()` are immutable.

Full explanation →

206

Multi-Selecthard

Which TWO statements about the try-with-resources statement are correct? (Choose two.)

Select 2 answers

A.The resource class must implement AutoCloseable.

B.The resource variable must be declared as final.

C.Resources are closed in the reverse order of their declaration.

D.A try-with-resources statement cannot have a finally block.

E.Resources are closed before the try block executes.

AnswersA, C

Correct: only AutoCloseable resources are allowed.

Why this answer

The try-with-resources statement requires that each resource implements the AutoCloseable interface (or its subinterface Closeable). This interface defines the close() method, which is automatically invoked by the JVM when the try block completes, ensuring proper resource management without explicit finally blocks.

Exam trap

The trap here is that candidates often think resources must be declared with the final keyword (Option B) or that finally blocks are prohibited (Option D), but the exam tests the exact JLS rules: resources are effectively final, and finally blocks are allowed but execute after resource closure.

Full explanation →

207

MCQeasy

What happens when a finally block throws an exception?

A.The JVM logs both exceptions and then terminates the thread.

B.The exception from the try block is propagated and the finally exception is ignored.

C.Both exceptions are reported as suppressed exceptions of a new exception.

D.The exception from the try block is suppressed and the finally exception is reported.

AnswerD

The exception from finally takes precedence, the try exception is lost unless caught as suppressed.

Why this answer

When a finally block throws an exception, the JVM suppresses the exception that was thrown from the try block (if any) and propagates the exception thrown from the finally block. This behavior is defined in the Java Language Specification (JLS §14.20.2) and ensures that the finally block's exception takes precedence, as the finally block is executed after the try block completes abruptly.

Exam trap

The trap here is that candidates often assume both exceptions are lost or that the try-block exception always propagates, but the Java Language Specification mandates that the finally-block exception takes precedence, with the try-block exception being suppressed.

How to eliminate wrong answers

Option A is wrong because the JVM does not log both exceptions and terminate the thread; instead, it suppresses the try-block exception and propagates the finally-block exception. Option B is wrong because the exception from the try block is not propagated; it is suppressed, and the finally exception is reported instead. Option C is wrong because both exceptions are not reported as suppressed exceptions of a new exception; only the try-block exception is suppressed, and the finally-block exception is the one thrown, with the try-block exception added as a suppressed exception to the finally-block exception (if the finally-block exception is a subtype of Throwable that supports suppression).

Full explanation →

208

Multi-Selecthard

Which two of the following are valid ways to create a LocalDate representing the current date in the system's default timezone? (Choose two.)

Select 2 answers

A.LocalDate.from(Instant.now())

B.new LocalDate()

C.LocalDate.now()

D.LocalDate.ofEpochDay(System.currentTimeMillis() / (24*60*60*1000))

E.LocalDate.ofInstant(Instant.now(), ZoneId.systemDefault())

AnswersC, E

Correct: Uses the system's default timezone.

Why this answer

`LocalDate.now()` is the standard, straightforward method to obtain the current date in the system's default timezone, as defined in the Java Time API (JSR-310). It internally uses the system clock and the default timezone to return a `LocalDate` instance without requiring any additional parameters.

Exam trap

The trap here is that candidates often assume `LocalDate.from(Instant.now())` should work because both are date/time types, but they fail to recognize that `Instant` lacks timezone and date fields, causing a runtime exception, while `new LocalDate()` is a common misconception from other Java classes that have public constructors.

Full explanation →

209

MCQmedium

Given the exhibit showing a compilation error at line 5 of Test.java, which of the following code fragments could be at that line?

A.FileInputStream fis = new FileInputStream("test.txt");

B.int x = 5;

C.try { ... } catch (Exception e) { }

D.System.out.println("Hello");

AnswerA

FileInputStream constructor throws FileNotFoundException (subclass of IOException).

Why this answer

The code at line 5 is a checked exception (FileNotFoundException) that must be handled or declared. The compilation error indicates that the method containing line 5 does not handle or declare this checked exception, which is required by the Java compiler.

Exam trap

The trap here is that candidates often forget that checked exceptions must be handled or declared, and mistakenly think any code that throws an exception will compile as long as it is inside a method, ignoring the compiler's requirement for checked exception handling.

How to eliminate wrong answers

Option B is wrong because assigning an int literal to a variable does not throw any checked exception and would not cause a compilation error at line 5. Option C is wrong because a try-catch block is syntactically valid and would not cause a compilation error on its own; the error is likely due to an unhandled checked exception inside the try block, not the catch clause itself. Option D is wrong because printing a string literal does not throw any checked exception and would compile without error.

Full explanation →

210

MCQmedium

A team implements a stream pipeline that processes a large dataset in parallel. They use a stateful lambda expression inside the map operation to maintain a count. What is the most likely outcome?

A.The pipeline will produce correct results if the stateful lambda is synchronized.

B.The pipeline will produce non-deterministic results due to race conditions.

C.The pipeline will throw a ConcurrentModificationException.

D.The pipeline will always produce the same result regardless of parallelism.

AnswerB

Stateful lambdas in parallel streams are discouraged because they introduce shared mutable state that leads to race conditions and unpredictable results.

Why this answer

Using a stateful lambda (one that mutates shared mutable state) inside a parallel stream's map operation introduces race conditions. The map operation is intended to be stateless and non-interfering; when multiple threads concurrently update a shared counter without proper synchronization, the result becomes non-deterministic and unpredictable.

Exam trap

The trap here is that candidates assume synchronization or thread-safety fixes the issue, but the Streams API's contract requires stateless lambdas for correctness in parallel pipelines, and synchronization does not restore deterministic behavior or guarantee correct results.

How to eliminate wrong answers

Option A is wrong because even if the stateful lambda is synchronized, the synchronization will cause severe contention and may still produce incorrect results if the lambda is not properly thread-safe or if the ordering of updates is not guaranteed; the Java Streams API explicitly discourages stateful lambdas in parallel pipelines. Option C is wrong because ConcurrentModificationException is thrown when a collection is structurally modified while being iterated, not from a stateful lambda in a map operation that merely updates a counter. Option D is wrong because the pipeline will not always produce the same result; the non-determinism arises from the unpredictable interleaving of thread updates to the shared mutable state.

Full explanation →

211

Multi-Selecthard

Which three of the following statements about the switch expression in Java 17 are correct?

Select 3 answers

A.A switch expression with arrow syntax does not require break.

B.A switch expression with colon syntax can use yield to return a value.

C.A switch expression cannot be used with an enum type.

D.A switch expression must include a default branch even if all cases are covered.

E.A switch expression must be exhaustive.

AnswersA, B, E

Arrow syntax implicitly prevents fall-through, so break is unnecessary.

Why this answer

In a switch expression with arrow syntax (->), each branch is a single expression or block that is automatically terminated, eliminating the need for a break statement. The arrow syntax implicitly prevents fall-through, making the code more concise and less error-prone.

Exam trap

The trap here is that candidates often confuse the requirement for a default branch in switch expressions with the behavior of switch statements, mistakenly thinking a default is always mandatory even when all cases are covered.

Full explanation →

212

MCQhard

A financial application processes transactions in batches. Each transaction is represented as a Transaction object with fields: long id, BigDecimal amount, LocalDateTime timestamp. Transactions are stored in a List<Transaction> in the order they arrive. The system needs to frequently check if a transaction with a specific id exists, and also needs to iterate through transactions in chronological order. The list currently contains millions of transactions, and the existence check is becoming a performance bottleneck because it currently uses a linear search. The system must also maintain insertion order for iteration. Which approach best improves the performance of the existence check while maintaining the required iteration order?

A.Keep List<Transaction> and add a separate HashSet<Long> of ids for fast lookup. Use the list for iteration.

B.Replace List<Transaction> with LinkedHashMap<Long, Transaction> mapping id to transaction. Iterate using values() which preserves insertion order.

C.Keep List<Transaction> and sort it by id. Use Collections.binarySearch() for lookup.

D.Replace List<Transaction> with TreeMap<Long, Transaction> mapping id to transaction. Iterate using values() which returns in natural key order.

AnswerB

LinkedHashMap<Long, Transaction> provides O(1) key-based lookup for existence checks and its values() iterator returns entries in insertion order, exactly matching the requirement. This is the best combination of performance and simplicity.

Why this answer

LinkedHashMap maintains insertion order for iteration via its values() view, while providing O(1) key-based lookup for the existence check. This directly addresses the performance bottleneck of linear search in a List without sacrificing the required chronological iteration order.

Exam trap

The trap here is that candidates may confuse TreeMap's natural ordering with insertion order, or assume that sorting a List and using binary search is the best optimization, overlooking the O(1) lookup advantage of hash-based structures like LinkedHashMap.

How to eliminate wrong answers

Option A is wrong because it introduces a separate HashSet<Long> for fast lookup, but this requires manual synchronization to keep the set and list consistent, and the existence check still needs to search the list if the set is not maintained correctly; it adds complexity without a built-in guarantee of order preservation. Option C is wrong because sorting a List by id and using binary search provides O(log n) lookup, which is slower than O(1) hash-based lookup, and sorting by id does not preserve insertion order for iteration unless the list is re-sorted after each addition, which is inefficient. Option D is wrong because TreeMap iterates in natural key order (sorted by id), not insertion order, which violates the requirement to iterate in chronological order.

Full explanation →

213

MCQhard

A team is developing a real-time data processing pipeline that reads sensor data from a message queue. The pipeline uses a flatMap operation that calls an external geocoding service for each sensor reading. The external service has a rate limit of 10 requests per second and is slow (150ms average response time). The current code: sensorStream.parallelStream() .flatMap(reading -> getGeocode(reading).stream()) .forEach(system.out::println); The application is overloaded because parallel stream fires many concurrent requests, exceeding the rate limit and causing failures. They need to process all sensor data but must respect the rate limit. Which approach should they use?

A.Use a sequential stream with a custom rate limiter (e.g., a semaphore) that blocks when the limit is reached.

B.Reduce the parallelism level by using a custom thread pool with a fixed number of threads.

C.Use filter to drop some sensor readings to reduce the load.

D.Use a sequential stream and hope the processing completes within the time window.

AnswerA

A sequential stream combined with a rate limiter ensures requests are sent at a controlled pace, respecting the external service limits.

Why this answer

Using a sequential stream with a custom rate limiter (e.g., a Semaphore configured to allow only 10 permits per second) ensures that the external geocoding service is called at a controlled rate, preventing rate-limit violations. The sequential stream processes elements one at a time, and the rate limiter blocks the thread when the limit is reached, naturally throttling requests to stay within the 10 requests/second limit while still processing all data.

Exam trap

The trap here is that candidates often assume that reducing parallelism (Option B) is sufficient to control request rates, but they overlook that even a small fixed thread pool can still exceed a low rate limit if requests are made too quickly, and that a rate limiter with temporal control is required to precisely throttle requests per second.

How to eliminate wrong answers

Option B is wrong because reducing parallelism with a fixed thread pool still allows concurrent requests (up to the pool size), which can exceed the 10 requests/second rate limit if the pool size is greater than 1 and requests are made faster than the rate limit allows; it does not provide fine-grained temporal control over request timing. Option C is wrong because using filter to drop some sensor readings would lose data, which violates the requirement to process all sensor data. Option D is wrong because using a sequential stream without any rate-limiting mechanism does not guarantee that the processing rate will stay within the 10 requests/second limit; the stream may still process requests faster than the limit allows, leading to rate-limit failures.

Full explanation →

214

MCQeasy

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

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

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

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

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

AnswerB

Correct syntax; resource is closed automatically.

Why this answer

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.

Exam trap

The trap here is that candidates often forget that try-with-resources requires the resource variable to be declared with its type inside the parentheses, and they mistakenly think a pre-declared variable or a variable without a type declaration is valid.

How to eliminate wrong answers

Option A is wrong because it uses a traditional try-finally block without try-with-resources, requiring manual close() call and risking resource leaks if an exception occurs before the finally block. Option C is wrong because it declares the FileInputStream inside the try block, making it inaccessible in the finally block for closing, leading to a compilation error. Option D is wrong because it omits the resource type declaration (FileInputStream) in the try-with-resources header, causing a compilation error as the variable must be declared with its type.

Full explanation →

215

MCQeasy

A Java application packaged as a JAR file with a manifest containing `Main-Class: com.example.Main` is correctly run using `java -jar app.jar`. However, when run with `java -cp app.jar com.example.Main`, it throws a `NoClassDefFoundError` for a class `com.example.helper.Util`. What is the most likely cause?

A.The Util class is missing from the JAR.

B.The JAR's manifest Class-Path entry is not being honored when using -cp.

C.The -jar option automatically adds the JAR's dependencies to the classpath.

D.The main class name is misspelled.

AnswerB

When using -cp, the Class-Path from manifest is ignored; you must explicitly include dependencies.

Why this answer

When using `java -jar`, the JVM reads the manifest's `Class-Path` entry to locate dependencies. However, when using `-cp` (or `-classpath`), the manifest's `Class-Path` is ignored; the classpath is determined solely by the `-cp` argument. Since `com.example.helper.Util` is not on the explicit classpath, a `NoClassDefFoundError` occurs.

This is a fundamental difference in how the JVM resolves classpaths between the two launch modes.

Exam trap

Oracle often tests the misconception that the manifest's `Class-Path` is always honored regardless of how the JAR is launched, when in fact `-cp` completely overrides it.

How to eliminate wrong answers

Option A is wrong because if the Util class were missing from the JAR, the error would occur with both `-jar` and `-cp`; the fact that `-jar` works proves the class is present. Option C is wrong because `-jar` does not automatically add dependencies to the classpath; it only uses the manifest's `Class-Path` entries, which are not transitive or automatic. Option D is wrong because a misspelled main class would cause a `NoClassDefFoundError` for the main class itself, not for a helper class, and the question states the main class is correctly specified.

Full explanation →

216

MCQeasy

A lambda expression that takes two integers and returns a boolean indicating whether the first is greater than the second is best represented by which functional interface?

A.BiFunction<Integer, Integer, Boolean>

B.Predicate<Integer>

C.BinaryOperator<Boolean>

D.BiPredicate<Integer, Integer>

AnswerD

Correct. BiPredicate<Integer, Integer> is the functional interface for two input arguments returning a boolean.

Why this answer

BiPredicate<Integer, Integer> is a functional interface that takes two arguments (both Integer) and returns a boolean, which exactly matches the lambda expression's signature (int, int) -> boolean. The lambda can be written as (a, b) -> a > b, and BiPredicate is the standard interface for such two-argument boolean-valued operations.

Exam trap

The trap here is that candidates often confuse BiPredicate with BiFunction or Predicate, mistakenly thinking a two-argument boolean operation can be represented by a single-argument Predicate or by a BiFunction that returns a Boolean, but the exam tests the precise functional interface that matches the lambda's signature and return type without unnecessary boxing.

How to eliminate wrong answers

Option A is wrong because BiFunction<Integer, Integer, Boolean> takes two Integer arguments and returns a Boolean object, but it is not the best representation; it requires boxing/unboxing and is less idiomatic than BiPredicate, which directly returns a primitive boolean. Option B is wrong because Predicate<Integer> takes only one Integer argument and returns a boolean, but the lambda requires two integers, so it cannot represent the operation. Option C is wrong because BinaryOperator<Boolean> takes two Boolean arguments and returns a Boolean, but the lambda takes two integers, not Booleans, and returns a boolean; it is semantically incorrect for comparing integers.

Full explanation →

217

Multi-Selecteasy

Which TWO access modifiers can be applied to a top-level class in Java? (Choose two.)

Select 2 answers

A.static

B.package-private (no modifier)

C.protected

D.private

E.public

AnswersB, E

Top-level classes can have default access.

Why this answer

In Java, a top-level class can only have two access modifiers: public or package-private (no modifier). Package-private is the default access level when no modifier is specified, allowing the class to be accessible only within its own package. This is defined by the Java Language Specification (JLS §8.1.1).

Exam trap

Oracle often tests the misconception that static or protected can be applied to top-level classes, confusing them with modifiers for nested classes or class members, which is a common trap in Java access modifier questions.

Full explanation →

218

MCQhard

Refer to the exhibit. A security policy file is configured as shown. The application in app.jar tries to read a file named "${user.home}/data/db.properties". What is the result?

A.Access is denied because the FilePermission for data files is missing.

B.Access is denied because app.jar's AllPermission is not sufficient.

C.Access is allowed because the first grant includes read permission for logs/-, which covers data.

D.Access is allowed because app.jar has AllPermission.

AnswerD

AllPermission overrides any restrictions.

Why this answer

The security policy grants AllPermission to app.jar, which supersedes any specific file permissions. AllPermission implies every possible permission, including read access to any file, regardless of path restrictions. Therefore, the application can read '${user.home}/data/db.properties' without denial.

Exam trap

The trap here is that candidates focus on the specific FilePermission grants and miss that AllPermission in the second grant renders all other permission checks irrelevant, leading them to incorrectly choose options based on path mismatches.

How to eliminate wrong answers

Option A is wrong because the FilePermission for data files is irrelevant when AllPermission is granted; AllPermission overrides all specific permission checks. Option B is wrong because AllPermission is the most powerful permission in the Java security model, granting all access rights, so it is sufficient for any operation. Option C is wrong because the first grant's read permission for logs/- does not cover the data directory; 'logs/-' only applies to files under the logs directory, not 'data/db.properties', but this is moot due to AllPermission.

Full explanation →

219

MCQmedium

Refer to the exhibit. What is the output?

A.[one, two, three, four]

B.[two]

C.[two, three]

D.[one, four]

AnswerC

Filter with startsWith("t") keeps 'two' and 'three'.

Why this answer

The code uses `dropWhile` on a stream of strings, which drops elements from the stream as long as the predicate (string length < 5) is true. Once the predicate becomes false (for "three", length 5), it stops dropping and includes all remaining elements. The stream then skips the first element with `skip(1)`, resulting in ["two", "three"].

Exam trap

The trap here is confusing `dropWhile` with `filter` — candidates often think `dropWhile` removes all elements matching the predicate, but it only removes the leading prefix until the first non-match, then includes everything after.

How to eliminate wrong answers

Option A is wrong because it assumes the stream processes all elements and collects them unchanged, ignoring the `dropWhile` and `skip` operations. Option B is wrong because it incorrectly thinks `dropWhile` removes all elements that match the predicate, leaving only "two" (which does not match), but `dropWhile` stops dropping after the first non-matching element. Option D is wrong because it mistakenly believes `dropWhile` removes all matching elements and then `skip(1)` removes the first remaining, but the actual behavior preserves "two" and "three".

Full explanation →

220

MCQmedium

A developer uses a parallel stream to process a large collection and wants to collect results into a List while preserving encounter order. Which of the following collectors will guarantee order preservation?

A.collect(Collectors.toUnmodifiableList())

B.collect(Collectors.toList())

C.collect(Collectors.toMap(Function.identity(), v->v))

D.collect(ArrayList::new, List::add, List::addAll)

E.collect(Collectors.toCollection(TreeSet::new))

AnswerD

This custom collector preserves encounter order because it adds elements sequentially in the accumulator and merges lists in order.

Why this answer

The custom collector using `ArrayList::new`, `List::add`, and `List::addAll` explicitly specifies an insertion-ordered collection (`ArrayList`) and uses the combiner `List::addAll`, which preserves the encounter order when merging partial results from parallel streams. The `Collectors.toList()` and `Collectors.toUnmodifiableList()` do not guarantee order preservation in parallel streams, as their internal implementations may use non-ordered structures like `HashSet` during accumulation.

Exam trap

The trap here is that candidates assume `Collectors.toList()` always preserves encounter order, but the Java specification explicitly states it does not guarantee order in parallel streams, and the exam tests this subtle distinction.

How to eliminate wrong answers

Option A is wrong because `Collectors.toUnmodifiableList()` does not guarantee encounter order preservation in parallel streams; its internal implementation may use a non-ordered intermediate structure. Option B is wrong because `Collectors.toList()` makes no ordering guarantees in parallel streams; the specification explicitly states that it does not preserve encounter order. Option C is wrong because `Collectors.toMap()` uses a `HashMap` by default, which does not maintain insertion order, and the merge function is not provided, causing an `IllegalStateException` on duplicate keys.

Option E is wrong because `TreeSet` sorts elements by their natural order or a comparator, not by encounter order, thus destroying the original stream order.

Full explanation →

221

Multi-Selecthard

Which TWO statements are true about the Stream API and lambda expressions in Java 17?

Select 2 answers

A.The Stream API does not modify the original data source.

B.Lambda expressions can capture variables that are effectively final.

C.A stream can be consumed by multiple terminal operations sequentially.

D.Intermediate operations on a stream are executed eagerly.

E.Lambda expressions introduce a new level of scope, similar to an anonymous inner class.

AnswersA, B

Streams operate on a view of the data; they do not modify the underlying collection or array.

Why this answer

The Stream API is designed to work on a view of the data, not the data itself. Operations like filter, map, and collect produce new streams or results without altering the original collection, array, or I/O source. This non-interference guarantee is a core principle of the Stream API, ensuring safe parallel execution and functional programming style.

Exam trap

The trap here is that candidates often confuse the lazy evaluation of intermediate operations with eager execution, or mistakenly believe a stream can be reused after a terminal operation, leading them to select options C or D.

Full explanation →

222

Multi-Selecteasy

Which TWO of the following are unchecked exceptions? (Choose two.)

Select 2 answers

A.SQLException

B.Exception

C.NullPointerException

D.ArrayIndexOutOfBoundsException

E.IOException

AnswersC, D

NullPointerException extends RuntimeException, making it an unchecked exception. It does not need to be handled or declared.

Why this answer

NullPointerException (option C) is an unchecked exception because it extends RuntimeException, which means it is not checked at compile time. The Java compiler does not require you to handle or declare NullPointerException, making it an unchecked exception.

Exam trap

The trap here is that candidates often confuse 'Exception' (the superclass) as unchecked, but Exception itself is a checked exception; only RuntimeException and its subclasses are unchecked.

Full explanation →

223

Multi-Selecthard

Which THREE statements are true about the enhanced for loop in Java?

Select 3 answers

A.If the underlying collection is modified during iteration, the loop will continue without error.

B.The enhanced for loop internally uses an iterator for collections.

C.The enhanced for loop can iterate over arrays.

D.The loop variable cannot be modified inside the loop body.

E.The loop variable must be declared final in the loop header.

AnswersB, C, D

For Iterable objects, it uses Iterator.

Why this answer

The enhanced for loop (for-each) over a collection internally uses an Iterator obtained from the collection's iterator() method. This is specified in the Java Language Specification (JLS 14.14.2) and is the mechanism that allows sequential access to each element without exposing the iterator directly.

Exam trap

The trap here is that candidates often confuse the enhanced for loop's inability to modify the loop variable with a requirement to declare it final, or they mistakenly believe that structural modifications during iteration are safe.

Full explanation →

224

MCQmedium

Given two named modules where module com.example.app requires module com.example.lib, which packages of com.example.lib are readable by com.example.app?

A.All packages except those explicitly concealed

B.All packages of com.example.lib

C.Only the packages opened by com.example.lib

D.Only the packages exported by com.example.lib

AnswerD

A module reads only exported packages of required modules.

Why this answer

In the Java module system, a module can only access packages from another module that are explicitly exported using the `exports` directive in the module's `module-info.java` file. Since `com.example.app` requires `com.example.lib`, only the packages exported by `com.example.lib` are readable; unexported packages remain encapsulated and inaccessible.

Exam trap

The trap here is that candidates confuse `opens` with `exports`, thinking that opening a package for reflection also makes it readable, but `opens` only grants reflective access and does not allow compile-time or direct read access.

How to eliminate wrong answers

Option A is wrong because the Java module system does not have a concept of 'concealed' packages; instead, packages are either exported or not, and all non-exported packages are implicitly encapsulated. Option B is wrong because requiring a module does not grant access to all its packages; only those explicitly exported are readable. Option C is wrong because 'opened' packages (via the `opens` directive) are for deep reflection at runtime, not for compile-time or read access; readability requires `exports`, not `opens`.

Full explanation →

Oracle Certified Professional Java SE 17 Developer 1Z0-829 (1Z0-829) — Questions 151–225