Free Oracle Java SE 21 Developer Professional Sample Questions

Correct answer: A — true false true

• A. `s1` and `s2` are both string literals, so the compiler resolves them to the same interned reference in the string pool, making `s1 == s2` true. `s3` is created with `new String(...)`, producing a distinct heap object, so `s1 == s3` is false; calling `intern()` on `s3` returns the pooled reference for "Java", which is the same object as `s1`, making `s1 == s4` true.
• B. This assumes `new String("Java")` also produces the pooled reference, but the `new` keyword explicitly forces allocation of a separate heap object distinct from anything in the string pool. `s1 == s3` must therefore be false, not true.
• C. This assumes string literals are not automatically pooled, but the Java compiler always interns literal strings, so `s1` and `s2` refer to the identical pooled object and their comparison must be true, not false.
• D. This correctly identifies that `s1 == s3` is false but incorrectly assumes `intern()` returns a fresh object rather than the existing pooled reference. `intern()` specifically looks up and returns the canonical pooled instance, so `s1 == s4` must be true.

Correct answers: A, B, G — The `\s` escape represents a single space character and prevents that trailing space from being stripped as incidental whitespace.; A backslash placed immediately before a line terminator suppresses that line break, joining the current line with the next one.; Three consecutive double-quote characters can appear inside the body of a text block as long as at least one of them is escaped, for example `\"""`.

• A. The `\s` escape is interpreted as a plain space character during the final escape-processing step of text block compilation, after incidental trailing whitespace has already been stripped. Placing it at the end of a line preserves spaces that would otherwise be removed, since the line no longer ends in raw whitespace once the escape sequence is present.
• B. A trailing backslash immediately followed by a line terminator tells the compiler to omit that specific line terminator from the resulting string, effectively continuing the text onto the next source line. This is commonly used to keep long lines readable in source code without introducing an actual line break in the value.
• C. Standard character escapes remain fully functional inside text blocks and are processed the same way as in ordinary string literals. Text blocks add new escapes like `\s` on top of the existing ones rather than disabling any of them.
• D. The `\s` escape can appear anywhere within a line, not just at the start; its most common use is specifically at the end of a line to preserve trailing spaces. There is no restriction limiting it to the first character.
• E. Text blocks automatically insert a line terminator after each source line as part of incidental whitespace processing, so explicit `\n` escapes are not required to produce multi-line output. Line breaks come from the physical line structure of the source text block itself.
• F. The incidental indentation is determined by examining the leading whitespace of every non-blank content line as well as the line containing the closing delimiter, then taking the smallest value found. Looking only at the first line would produce incorrect results whenever a later line is indented less.
• G. Because an unescaped run of three double quotes would be interpreted as the closing delimiter, embedding literal triple quotes inside the body requires escaping at least one of the three quote characters. This lets the sequence appear as ordinary text rather than terminating the text block.

Correct answer: B — 5.0 because binary numeric promotion converts both operands to double

• 5 because the conditional operator keeps the type of the chosen branch. When both branches of a conditional expression are numeric but of different types, the compiler applies binary numeric promotion to the whole expression rather than preserving the chosen branch's original type.
• 5.0 because binary numeric promotion converts both operands to double. Since one branch is int and the other is double, the conditional expression's type is promoted to double, so the selected int value 5 is converted to 5.0 before printing.
• 2.5 because the second operand always determines the result type. The second operand's type does not automatically win; both branches are combined through numeric promotion regardless of which branch is actually selected at runtime.
• Compilation fails because the two branches have different types. Mixing int and double in a conditional expression is legal because numeric promotion rules define a common result type, so this compiles without error.
• 5 because int has higher precedence than double in a conditional expression. There is no precedence ranking between int and double here; numeric promotion always widens the narrower type, so double, not int, wins the promotion.

Correct answer: B — -2147483648 because the addition overflows and wraps around via two's complement

• 2147483648 because int silently promotes to long during the addition. Java does not automatically promote int arithmetic to long; the operation stays within 32-bit int arithmetic and overflows instead of widening.
• -2147483648 because the addition overflows and wraps around via two's complement. Adding 1 to Integer.MAX_VALUE overflows the 32-bit signed int range and wraps around to Integer.MIN_VALUE due to two's complement representation, silently, with no exception.
• A compilation error occurs since Math.addExact is required for boundary values. The plain `+` operator compiles and runs fine on boundary values; Math.addExact is only needed when overflow detection via an exception is desired.
• An ArithmeticException is thrown at runtime because the result exceeds int range. Ordinary arithmetic operators never throw on overflow; only the `Exact` methods in Math, such as addExact, throw ArithmeticException on overflow.
• 0 because overflow always resets an int variable back to its default value. Overflow does not reset a variable to a default value; it wraps around according to two's complement rules, producing Integer.MIN_VALUE here.

Correct answers: A, B, C — Instant.now().truncatedTo(ChronoUnit.DAYS) sets the time-of-day fields to midnight while keeping the same UTC date.; Instant supports the plus(Duration) method to add an exact number of seconds and nanoseconds to it.; ChronoUnit.DAYS.between(instant1, instant2) computes the number of complete 24-hour periods between two instants.

• A. truncatedTo with ChronoUnit.DAYS zeroes out everything smaller than a day, leaving the instant at the start of its UTC day; Instant has no time-zone concept, so this midnight is always expressed in UTC.
• B. Instant is designed around exact elapsed time, so plus(Duration) simply adds the specified seconds and nanoseconds to the underlying epoch value without any calendar interpretation.
• C. Because Instant has no calendar fields, ChronoUnit.DAYS.between treats a day as a fixed 24-hour block of elapsed time and counts how many such blocks fit between the two instants.
• D. atZone(ZoneId) is precisely the supported way to convert an Instant into a ZonedDateTime, combining the instant with zone rules to derive local fields; this conversion is valid and commonly used.
• E. Instant and LocalDate belong to unrelated parts of the temporal type hierarchy and are not directly comparable to each other; Instant models an elapsed-time point, not a calendar date.
• F. Instant has no plusDays method because it has no notion of a calendar day tied to a time zone; date-based arithmetic like this belongs to zone-aware or local types, not to Instant.

Correct answer: A — `a` produces a short zone name such as PST or PDT, while `b` produces the zone ID such as America/Los_Angeles.

• A. The pattern letter z formats a short, human-readable zone name like PST or PDT depending on the date, while the pattern letter V is defined to output the full zone ID string such as America/Los_Angeles.
• B. Neither pattern letter is defined to produce a numeric offset by itself; that behavior belongs to pattern letters like x, X, or Z, so this description does not match z or V.
• C. This swaps the actual behavior of the two pattern letters: z is the short zone-name letter and V is the zone-ID letter, not the other way around.
• D. The pattern letter z is a valid and commonly used zone-name symbol in DateTimeFormatter, so formatting with it succeeds rather than throwing an exception.
• E. The localized GMT offset format is produced by the pattern letter O, not by z or V, so neither of these two outputs matches a GMT-style string.

Correct answer: A — ```java switch (x) { case 1 -> System.out.println("one"); case 2 -> System.out.println("two"); default -> System.out.println("other"); } ```

• A. Every label in this switch block uses the arrow form, which is a legal, consistent style that the grammar permits without mixing label kinds.
• B. This mixes an arrow-labeled rule with colon-labeled statement groups in the same switch block, which the grammar forbids; a block must use either all arrow labels or all colon labels.
• C. This switch is used as a statement, not assigned to a variable, so it is not a switch expression; yield is only valid when the enclosing switch produces a value, making this construct illegal here.
• D. The rule `case 2 -> (x + 1);` is not a valid statement expression on its own; a parenthesized arithmetic expression cannot stand alone as a statement, so this fails to compile.

Correct answers: B, C, F — The 1,000,000-byte array `largeData` cannot be garbage collected at point P, because it is reachable through the surviving `Cache` instance.; Declaring `Snapshot` as a `static` nested class instead of a non-static inner class would remove the implicit reference to `Cache`, letting the `Cache` instance become eligible once `held` no longer holds it.; At point P, the `Cache` instance created inside `register` remains reachable, because the `Snapshot` object stored in `held` implicitly references its enclosing `Cache` instance.

• A. A `static` field is itself a garbage collection root, but the objects it references are still subject to ordinary reachability tracking; nothing about being referenced from a static field exempts an object from collection.
• B. `largeData` is an instance field of the still-reachable `Cache` object, so it is reachable by the same chain that keeps `Cache` itself alive, and it cannot be collected until that chain is broken.
• C. A static nested class carries no implicit outer reference, so a `Snapshot` declared that way would not keep the `Cache` instance reachable, letting `Cache` become eligible once nothing else refers to it.
• D. Local variables only keep their referents reachable while the method invocation that declared them is on the call stack; once `register` returns, `cache` no longer exists as a root.
• E. The implicit outer reference is stored as a field on the inner class instance itself and persists for as long as that inner instance exists, independent of whether the method that created it has returned.
• F. Every non-static inner class instance carries an implicit reference to the enclosing instance that created it, so as long as the `Snapshot` object is reachable via `held`, its `Cache` instance stays reachable too.
• G. `held` still refers to the `Snapshot` object at point P, so it remains reachable regardless of whether the local variable `cache` that originally created it has gone out of scope.

Correct answer: A — sides=0

• A. Square's implicit constructor calls super(), and Shape's constructor invokes the overridden report(), which runs using Square's dynamic dispatch before the sides field initializer has executed, so sides still holds its default value of 0.
• B. The sides field initializer only runs after the superclass constructor returns, but report() is called from inside Shape's constructor, before that initializer has a chance to run, so 4 is not yet assigned.
• C. Dynamic dispatch means the overridden version in Square runs even when invoked from the superclass constructor, so the original Shape implementation never executes here.
• D. This code compiles cleanly: Square has an implicit no-arg constructor, @Override correctly matches report()'s signature, and there is no syntax or type error present.

Correct answer: A — `BigDecimal` is itself an immutable class, so there is no risk of a caller mutating the shared referenced object through either the constructor argument or the returned reference

• A. This is correct: defensive copying exists specifically to protect against a shared mutable object being changed after the fact; since `BigDecimal` instances cannot be mutated once created, storing and returning the same reference introduces no risk to the `Salary` object's immutability.
• B. This is incorrect because many classes besides `String` are mutable (e.g. `Date`, `ArrayList`), and conversely `String` itself is immutable in Java, so the premise about which classes need defensive copies is backwards.
• C. This is incorrect because a getter returning a reference to a mutable object is not inherently safe; the safety in this scenario comes specifically from `BigDecimal`'s own immutability, not from the mere presence of a getter method.
• D. This is incorrect because object references, including `BigDecimal` references, are still reference values in Java; the field and a caller's variable can indeed refer to the identical heap object, it's just that mutating that object isn't possible.

Correct answer: A — The class fails to compile because `translate` reassigns the `final` fields `x` and `y`; it should instead return a brand-new `Point` built from `x + dx` and `y + dy`, leaving the original object's fields untouched

• A. This is correct: `x += dx` and `y += dy` are compound assignments to `final` fields outside of the constructor, which the compiler rejects; the fix is to compute the translated coordinates and return them wrapped in a new `Point` instance, leaving `x` and `y` on the original object untouched.
• B. This is incorrect because returning `this` has no bearing on whether the method's body is legal; the compile error caused by reassigning `final` fields occurs regardless of what the method returns.
• C. This is incorrect because ordinary instance methods do not need to be declared `final` for a class to be immutable, and adding `final` to `getX`/`getY` would not address the actual compile error, which is the illegal field reassignment in `translate`.
• D. This is incorrect because `final` fields can only be assigned once, during construction (or, for instance fields, within instance initializers or the constructor); no exception exists that allows reassignment merely because the reassigning code is inside the same class.

Correct answer: B — `long` prints because widening a primitive `int` to `long` is a strict invocation match, which the compiler resolves before considering any variable-arity overload.

• A. Argument count matching is not the deciding factor here; phase order is. A candidate reachable through widening in the strict phase is chosen before the compiler ever considers a variable-arity candidate, regardless of count.
• B. This is correct because widening `int` to `long` is allowed in the strict invocation phase without boxing or varargs, so `size(long)` is found applicable first and is selected over the varargs overload.
• C. There is no ambiguity because resolution stops once a candidate is found applicable in an earlier phase; the varargs candidate in the later phase is never even considered once the widening match succeeds.
• D. The element type mismatch is not why `long` prints; the reason is that phase-based resolution finds and selects the widening match before variable-arity invocation is ever attempted, regardless of element types involved.

Correct answers: A, C, E — Interface `P` is a functional interface because it declares exactly one abstract method.; Interface `Q` is a functional interface because default methods do not count toward the abstract method total.; Interface `S` is a functional interface because `equals` duplicates a public method already declared in `Object` and is therefore excluded from the abstract method count.

• A. `P` declares only the single abstract method `run` with no other methods, which is precisely the minimal shape of a functional interface.
• B. Default methods are never counted as abstract methods since they already carry an implementation, so adding `log` to `Q` does not disqualify it from being a functional interface.
• C. Because a default method supplies its own body, it is excluded from the abstract method count, leaving `run` as the only abstract method and making `Q` a valid functional interface.
• D. A lambda expression implements exactly one abstract method, and `R` declares two independent abstract methods, `run` and `stop`, so no single lambda body can satisfy both and `R` cannot be a functional interface.
• E. Abstract methods that match the signature of a public method already found on `Object`, such as `equals(Object)`, are excluded when counting abstract methods for the functional interface check, leaving only `run` and making `S` a valid functional interface.
• F. A lambda expression can only target an abstract instance method, and `T` declares no abstract method at all, only a static one, so there is nothing for a lambda to implement and `T` is not a functional interface.

Correct answer: A — An abstract class cannot be instantiated directly, but it may declare constructors, concrete methods, and instance fields that are inherited and used by its concrete subclasses.

• A. Abstract classes exist precisely to provide shared constructors, concrete method implementations, and fields for subclasses to inherit, while being barred from direct instantiation via `new`.
• B. Abstract classes can and often do declare constructors; those constructors run via `super()` calls from subclass constructors even though the abstract class itself can never be instantiated directly.
• C. A class can be declared `abstract` even if every method it declares is concrete; doing so simply prevents direct instantiation, and the compiler does not require at least one abstract method.
• D. An abstract class can be extended by another abstract class, deferring implementation of remaining abstract methods further down the hierarchy until a concrete subclass eventually provides them.
• E. The `abstract` modifier and the `sealed` modifier are independent language features; declaring a class `abstract` has no automatic effect on whether it is sealed, non-sealed, or unrestricted.

Correct answer: A — `applyDiscount(MembershipTier.GOLD);` compiles, because `MembershipTier` implements `Discountable` and every constant is an instance of that enum type.

• A. This is correct: `MembershipTier` declares `implements Discountable`, so each constant such as `GOLD` is-a `Discountable` and can be passed anywhere that type is expected.
• B. This is incorrect because widening a subtype reference to an implemented interface type is ordinary polymorphism in Java and applies to enum constants exactly as it does to any other object.
• C. This is incorrect because `MembershipTier.class` is a `Class<MembershipTier>` object describing the type itself, not an instance of `Discountable`, so it does not satisfy the parameter type.
• D. This is incorrect because `values()` returns a `MembershipTier[]` array, and an array type is never automatically convertible to a single element of an interface type.
• E. This is incorrect because `Discountable` has no method body, and even as a functional interface it requires a lambda or concrete implementing class rather than a bare `new` expression on the interface itself.

Correct answer: A — `2`

• A. When a `finally` block contains its own `return`, that return statement discards any pending return (or exception) from the try block and becomes the value the method actually returns, so `compute()` returns 2.
• B. The `try` block's `return 1` is scheduled but not yet completed when `finally` runs; because `finally` itself returns, it overrides the pending value from `try`, so 1 is never the final result.
• C. This is a legal, if discouraged, pattern in Java; overriding a return value from within `finally` does not raise any exception, it simply changes the returned value silently.
• D. A `return` statement inside a `finally` block is syntactically legal in Java and compiles without error, even though most style guides discourage the pattern.
• E. Only one value can ever be returned from a method invocation; the `finally` block's return supersedes the try block's return before it takes effect, so only 2 is produced, not both values in sequence.

Correct answer: A — The list is a fixed-size view backed by the array; `set(index, value)` updates the array, while `add` or `remove` throws `UnsupportedOperationException`.

• A. `Arrays.asList` returns a fixed-size list backed directly by the given array. Because it shares storage with the array, `set` writes through to the array, but the list cannot grow or shrink, so `add` and `remove` throw `UnsupportedOperationException`.
• B. The returned list is a view, not a copy; it shares the same backing storage as the array. Since it is fixed-size, `add` and `remove` are unsupported rather than triggering a resize.
• C. Unlike `List.of`, which is fully immutable, `Arrays.asList` permits element replacement via `set`; only structural changes such as adding or removing elements are disallowed.
• D. The list is a live view backed by the same array, so direct changes to the array elements are immediately visible through the list; nothing about the wrapping is lazy or a disconnected snapshot.

Correct answer: A — `grid[2]` is `null` and `grid[1].length` is `3`, because declaring `new int[3][]` allocates only the outer array, leaving each row unassigned until explicitly initialized.

• A. `new int[3][]` creates only the outer array with three slots, each defaulting to `null` since row arrays are objects; `grid[2]` was never assigned, so it remains `null`, while `grid[1]` was explicitly assigned three elements, giving it a length of `3`.
• B. Java does not auto-initialize unassigned rows in a jagged array to empty arrays; an unassigned row reference defaults to `null`, and accessing its length or elements without first assigning it would throw `NullPointerException`.
• C. Jagged arrays in Java allow each row to have an independent length set individually; `grid[1]` keeps the length of the array literal explicitly assigned to it, `3`, and does not inherit a size from any other row.
• D. Declaring `new int[3][]` is valid Java syntax for creating a jagged two-dimensional array with an unspecified inner dimension; no exception occurs simply from this declaration or from assigning individual rows afterward.

Correct answer: A — It always contains entries for both the true and false keys, even when one of the two partitions has no matching elements.

• A. partitioningBy is documented to always produce mappings for both possible Boolean keys; if no elements match one side of the predicate, that key still maps to an empty list rather than being absent.
• B. Omitting an empty partition would contradict the guaranteed two-key structure of the returned map; both keys are always present regardless of how many elements land in each bucket.
• C. The returned map type is not specified to be a TreeMap and there is no documented ordering guarantee between the two Boolean keys in the result.
• D. No exception is thrown in this scenario; the predicate outcome simply determines whether one of the two guaranteed keys maps to an empty list instead of a populated one.

Correct answers: A, B, C — If products is empty, mostExpensive is Optional.empty() rather than the call throwing an exception at runtime.; The supplied BinaryOperator must be associative for the result to be well-defined if the stream is later run in parallel.; If comparing prices ever causes the accumulator to produce a null reduced value, a NullPointerException is thrown, since reduce disallows a null result.

• A. The single-argument reduce overload is documented to return an empty Optional when the stream has no elements, rather than throwing, since there is nothing to seed the accumulation with.
• B. Any BinaryOperator passed to reduce must be associative for the reduction to yield a consistent result regardless of how the runtime splits and recombines the stream during parallel execution.
• C. reduce is specified to throw NullPointerException if the reduced value would be null, since Optional cannot hold a null element, so a null-producing accumulation surfaces as an exception rather than a silently empty result.
• D. The overload used here is the one-argument BinaryOperator form, which intentionally has no identity parameter; an identity value is only required by the other reduce overloads, so this code compiles as written.
• E. The single-argument reduce overload uses the same BinaryOperator as both accumulator and combiner internally, so it is fully valid on a parallel stream without requiring a separate combiner argument.
• F. When multiple elements tie under the comparator, which one is ultimately retained is not guaranteed to be the first encountered, especially under parallel execution where partial results are combined in an unspecified order.

Correct answers: A, B, C — `isEmpty.and(isShort)` evaluates `isEmpty` first and only evaluates `isShort` when `isEmpty` returns `true`, short-circuiting otherwise.; `isEmpty.or(isShort)` evaluates `isShort` only when `isEmpty` returns `false`, short-circuiting otherwise, like the logical `||` operator.; `isEmpty.negate()` returns a new predicate that tests `true` for exactly the strings that `isEmpty` tests `false` for.

• A. `Predicate.and` is specified to behave like the logical `&&` operator: it short-circuits, so the second predicate is only invoked when the first one returns `true`.
• B. `Predicate.or` mirrors the logical `||` operator: the second predicate is only invoked when the first one returns `false`, avoiding unnecessary evaluation once a `true` result is already known.
• C. `negate()` returns a predicate whose result is the logical complement of the original for every input, so it is `true` exactly where the original predicate would have returned `false`.
• D. `and` short-circuits rather than evaluating unconditionally; if the first predicate already returns `false`, the second predicate is skipped entirely.
• E. `Predicate` methods like `negate` are functional and return a brand-new `Predicate` instance rather than modifying the receiver, so the original `isEmpty` reference continues to behave exactly as before.
• F. `and`, `or`, and `negate` are default methods provided by the `Predicate` interface itself; implementers only need to supply the single abstract `test` method, not these combinators.
• G. `Predicate.and` returns another `Predicate<T>` operating on the same single input type, not a `BiPredicate`; both predicates are still applied to the same one argument.

Correct answers: A, C, F — It can read every other module on the module path as well as every other class on the classpath, without needing explicit `requires` directives.; Named modules cannot declare a plain `requires` on the unnamed module, because the unnamed module has no fixed, referenceable name.; It cannot itself declare `exports`, `opens`, `requires`, or other module directives, since it has no module descriptor at all.

• A. The unnamed module exists to preserve classpath-style behavior; it automatically reads every module on the module path and sees every classpath class, mirroring pre-module-system access.
• B. Named modules do not automatically read the unnamed module, so exposing all packages from the unnamed module's side has no effect; named modules cannot see into it unless they resort to classpath tricks outside the module system.
• C. The unnamed module lacks a stable, declarable name, so a named module's `module-info.java` has no syntax for expressing a `requires` on it directly.
• D. There is no wildcard syntax for targeting unnamed-module callers inside a module declaration's `opens ... to` clause; that kind of access is granted only through command-line options, not source-level directives.
• E. Classpath code is not subject to the module system's strong encapsulation; classic classpath-era reflective and same-package access rules continue to apply to the unnamed module.
• F. Because it has no `module-info.java`, the unnamed module cannot express any module directive; its access characteristics come entirely from being treated specially by the module system, not from any descriptor.

Correct answers: A, B, C — Every class loaded from the classpath (not the module path) belongs to the unnamed module.; The unnamed module reads every other module on the module path, including all named and automatic modules.; The unnamed module exports all of its packages, making them accessible to any module that reads it.

• A. Classes on the classpath are not attributed to any named module, so the JVM groups them into the unnamed module.
• B. The unnamed module implicitly reads the entire module graph, both explicit and automatic modules, so classpath code can still see application and platform APIs.
• C. The unnamed module exports every one of its packages unconditionally, mirroring the permissive behavior classpath code had before the module system existed.
• D. By default, named modules do not read the unnamed module; a named module must opt in with a mechanism like `--add-reads` naming `ALL-UNNAMED` to see classpath classes.
• E. The unnamed module has no name at all, which is precisely why it cannot appear on the right-hand side of a `requires` clause in any module descriptor.
• F. Each class loader gets its own unnamed module rather than the JVM sharing a single one, so a JVM using multiple class loaders can have multiple unnamed modules simultaneously.
• G. `--add-reads ALL-UNNAMED=<module>` on the command line is exactly the mechanism used to grant the unnamed module readability of a specific named module, so this blanket denial is incorrect.
• H. Because the unnamed module has no name, it cannot be the target of a `requires` directive in any `module-info.java`; only automatic and explicit modules can be required by name.

Correct answers: A, B, C — In a bottom-up approach, a library deep in the dependency tree can be fully modularized only after every library it depends on has already been modularized or is otherwise safe to require directly.; In a top-down approach, the top-level application module can be created first while its unconverted dependencies are added to the module path as automatic modules.; A bottom-up migration typically produces a shorter list of automatic modules remaining on the module path at any given point, since dependencies are converted before their consumers.

• A. Bottom-up migration works from the leaves inward, so a library can only become a clean named module once its own dependencies are already resolvable as real modules rather than requiring workarounds.
• B. Top-down migration modularizes the application first and lets its still-unconverted dependencies sit on the module path as automatic modules until they too are converted, which is the defining trade-off of this approach.
• C. Because bottom-up migration converts dependencies before the modules that consume them, at any point in the process fewer of the remaining unconverted pieces need to be bridged in as automatic modules.
• D. Top-down migration explicitly relies on automatic modules as a bridge for dependencies that are not yet modularized; it does not force every dependency to convert immediately, so this guarantee is false.
• E. Both strategies can use automatic modules as a temporary bridge for whichever pieces are not yet converted; bottom-up migration is not restricted from using them either, so this restriction is false.
• F. Since bottom-up migration works inward from the leaves, the top-level application is naturally the last component converted, so it keeps running as the unnamed module the longest.

Correct answers: B, C, F — `future.isCancelled()` now returns `true`, reflecting that the task was cancelled before it completed normally.; The worker thread running the task is interrupted, which typically makes the blocking `Thread.sleep` call throw.; `future.get()` after this call throws a `CancellationException` rather than returning a result.

• A. Passing `true` to `cancel` specifically allows cancellation of a task that has already started, not just one still waiting in a queue. Since the task was running, `cancel(true)` returns `true` here, not `false`.
• B. Once cancellation succeeds, `isCancelled()` reports `true` for that `Future` from then on. This reflects that the task was stopped rather than allowed to finish and produce its normal result.
• C. `cancel(true)` interrupts the worker thread executing the task if it is running, and `Thread.sleep` responds to interruption by throwing `InterruptedException`. This is the standard mechanism by which a running blocking call is unwound during cancellation.
• D. Cancellation is itself a terminal outcome for a `Future`; once cancelled, `isDone()` returns `true` just as it would for normal completion or an execution failure. It does not remain `false` after a successful cancellation.
• E. A cancelled task's `Future` does not silently return `null`; retrieving its result after cancellation throws an exception instead of yielding a placeholder value. Treating cancellation as equivalent to a `null` result would hide that the task never completed.
• F. After a `Future` has been cancelled, calling `get()` throws `CancellationException` rather than returning any value, since the underlying task's result was never produced. This is the documented behavior for retrieving results from a cancelled `Future`.
• G. `ExecutorService` has no built-in retry mechanism; a cancelled task is simply abandoned and never automatically resubmitted. Any retry logic would have to be implemented explicitly by the calling code.

Correct answer: A — `findFirst()`, because it always returns the element that is first in the stream's encounter order even when the pipeline runs across multiple threads.

• A. Correct: `findFirst()` is specified to honor the stream's encounter order regardless of whether the pipeline runs sequentially or in parallel, which is required here since the order-first element must be returned deterministically.
• B. This is incorrect: `findAny()` is intentionally unconstrained by encounter order for better performance, so it may return any matching element rather than specifically the first one in source order.
• C. This is incorrect: `findFirst()` does not force a fallback to sequential execution; it still runs across the parallel pipeline's threads but coordinates results to honor encounter order.
• D. This is incorrect: `findAny()` explicitly does not guarantee encounter order, trading that guarantee for potential speed, so it cannot be relied on to match `findFirst()` results.

Correct answer: A — The write lock acquisition blocks indefinitely (or times out with `tryLock`) because upgrading from a held read lock to the write lock is not supported

• A. `ReentrantReadWriteLock` does not support upgrading a held read lock to a write lock; attempting it while other readers might hold the read lock (including this thread) causes the write lock acquisition to block or time out, so the thread must release the read lock first.
• B. There is no automatic upgrade path from read to write lock in `ReentrantReadWriteLock`; the documented pattern for this class explicitly states downgrading write-to-read is possible but upgrading read-to-write is not.
• C. No exception is thrown for this sequence; the acquisition simply blocks (or times out with a timed `tryLock`) rather than failing fast with a monitor-state exception.
• D. The lock implementation has no mechanism to forcibly revoke another thread's held read lock; write lock acquisition instead waits for all outstanding read locks to be released normally.

Correct answer: A — `readLine()` returns `null`.

• A. BufferedReader.readLine() is documented to return null when the end of the stream is reached, which is the standard sentinel used to terminate reading loops.
• B. readLine() does not throw EOFException on reaching the end of the stream; that exception is associated with DataInputStream methods like readFully or readUTF, not BufferedReader.
• C. An empty string is a valid return value representing a blank line within the file content, not a signal of end-of-stream, so it cannot be used to detect EOF.
• D. The integer -1 sentinel is used by byte- and character-level read methods such as InputStream.read() or Reader.read(), not by the line-based readLine() method, which returns a String or null.

Correct answer: A — `DataOutputStream` wrapping a `FileOutputStream` for writing, and `DataInputStream` wrapping a `FileInputStream` for reading.

• A. DataOutputStream provides typed methods like writeInt and writeDouble that encode primitives in a compact binary format, and DataInputStream provides the matching readInt and readDouble methods to decode them, which is the correct pairing.
• B. PrintWriter and BufferedReader operate on text representations of values via print/println and readLine, requiring manual parsing back to primitives rather than a compact binary format with typed reads.
• C. ObjectOutputStream and ObjectInputStream require byte streams, not character Writers or Readers, as their constructor arguments, so this pairing does not compile as described.
• D. FileWriter only exposes character-based write methods for text and has no typed methods for writing primitives like int or double in binary form.

Correct answer: A — The field holds `null`, because a transient field is excluded from the serialized stream and is left at its default value on deserialization.

• A. The `transient` modifier tells `ObjectOutputStream` to skip writing that field's value, so nothing about the token is present in the stream. On deserialization the field is simply left at its type's default value, which is `null` for a `String`.
• B. No such class-level cache exists for transient fields; the JVM does not retain or restore their runtime values across serialization boundaries. Once excluded from the stream, the value is gone unless custom code writes it separately.
• C. Marking a field `transient` is fully legal on a `Serializable` class and is the standard mechanism for excluding sensitive or non-serializable state. No exception is thrown because of this modifier alone.
• D. `ObjectOutputStream` does not substitute any placeholder text for transient fields; it simply omits them from the stream entirely. The field keeps its type's default value after reconstruction, not an empty string.
• E. Transient fields are ordinary instance fields for all purposes except the serialization mechanism, so each `Session` object keeps its own independent field slot. There is no shared static storage implied by the `transient` keyword.

Correct answer: A — It prints "/etc/settings.conf", because resolving an absolute path against any base simply returns that absolute path unchanged

• It prints "/etc/settings.conf", because resolving an absolute path against any base simply returns that absolute path unchanged. When the argument passed to resolve is already absolute, resolve returns that argument unchanged and discards the base path entirely, which matches this output.
• It prints "/opt/app/config/etc/settings.conf", because resolve always appends the second path's elements onto the base path. This would be the outcome only if the second path were relative; because it is absolute, resolve does not append it onto the base path this way.
• It prints "/opt/app/config/settings.conf", because resolve keeps only the base directory and the final file name of the second path. This assumes only the file name from the second path is appended to the base, but resolve never extracts a trailing element like that from an absolute argument.
• It throws an exception, because resolve requires the second argument to be relative when the base path is already absolute. resolve does not validate or reject absolute arguments; it simply short-circuits and returns the absolute argument, so no exception occurs here.

Correct answers: A, B, C — The doubled single quotes (`''`) in `"It''s"` produce a literal apostrophe in the output, rendering `"It's"`.; The braces wrapped in single quotes, `'{0}'`, are treated as literal text and are not substituted with the argument.; The final formatted output is `"It's 50 percent, not {0}"`.

• A. In `MessageFormat` pattern syntax, two consecutive single quotes are the escape sequence for a literal single quote character, so `"It''s"` renders as `"It's"` in the output.
• B. Text enclosed in a matching pair of single quotes is treated as a literal string rather than being interpreted as a placeholder, so `'{0}'` is emitted as the literal characters `{0}` instead of being substituted.
• C. Combining the doubled-quote escape for the apostrophe with the quoted literal braces, the unquoted `{0}` is substituted with `50` while the quoted `{0}` stays literal, producing exactly this combined string.
• D. Mixing quoted and unquoted brace occurrences in the same pattern is valid syntax; `MessageFormat` processes each independently rather than rejecting the pattern with an exception.
• E. Doubled single quotes are the documented escape for producing one literal quote character, not for producing no character at all, so the apostrophe is retained in the output.
• F. Quoting is scoped to the specific text between a pair of quote marks; it does not globally disable substitution for other occurrences of the same argument index elsewhere in the pattern.

Correct answers: A, C, D — Calling logger.fine("message") is functionally equivalent to calling logger.log(Level.FINE, "message") directly; logger.log(Level.WARNING, "failed", exception) records the supplied Throwable alongside the message for output; Convenience methods like logger.warning(String) have a Supplier<String> overload so the message is computed lazily only if enabled

• A. The named convenience methods such as fine are documented as shorthand that simply calls the general log method with the corresponding named level, so the two calls behave identically.
• B. The logging API's convenience methods are documented to tolerate null for most arguments, including the message, rather than throwing on a null message parameter.
• C. The overload accepting a Throwable is specifically documented to associate that exception with the LogRecord so handlers and formatters can include stack trace information in the output.
• D. Logger provides Supplier-based overloads on its convenience methods precisely so that expensive message construction can be deferred and skipped entirely when the level check would suppress the record anyway.
• E. The severe method still goes through the same level-filtering logic as every other convenience method; it is not exempt from being suppressed if a logger's configured level were somehow set above SEVERE.
• F. CONFIG's documented integer value (700) is lower than WARNING's (900), meaning CONFIG is actually less severe, not more, contradicting the claim made here.
• G. OFF represents the highest possible integer value in the Level hierarchy, intended to suppress logging entirely, not the lowest; describing it as the lowest severity misstates its purpose and value.

Correct answer: A — The usage is reasonable: `"rawtypes"` covers the raw `list` declaration, and `"unchecked"` covers the cast to `List<String>`, addressing two distinct warnings.

• A. `"rawtypes"` and `"unchecked"` are distinct, separately recognized warning categories in javac; using a raw `List` type triggers the rawtypes warning, and casting to a parameterized type triggers the unchecked warning, so both keys are needed to cover both diagnostics.
• B. Raw type usage and unchecked casts are tracked as separate warning kinds by the compiler; suppressing `"unchecked"` alone does not also suppress `"rawtypes"` warnings, so both values genuinely serve a purpose here rather than one being redundant.
• C. `@SuppressWarnings`'s `value` element is declared as `String[]`, and Java's array-initializer shorthand allows curly-brace syntax for array-valued annotation elements, so supplying multiple strings in braces compiles correctly.
• D. `@SuppressWarnings`'s `@Target` includes `LOCAL_VARIABLE` among other element kinds, so annotating a local variable declaration is valid and does suppress warnings that would otherwise be reported for the initialization on that line.

Correct answer: A — Provide an explicit type witness, `process(Collections.<String>emptyList())`, telling the compiler which type argument to use for `emptyList()`.

• A. This is correct: an explicit type witness supplies the type argument directly to the generic method call, letting the compiler resolve `Collections.<String>emptyList()` to `List<String>` and match the expected parameter type.
• B. Diamond inference relies on target-type context such as a variable declaration or assignment; when a generic method call is passed directly as an argument without such context, the diamond operator would face the same inference difficulty here.
• C. `Collections.emptyList()` already returns a properly parameterized `List<Object>`-compatible reference in this context, not a raw type, so an explicit cast is unnecessary and does not address the underlying type-inference failure.
• D. `Collections.emptyList()` does not have an overload that accepts a `Class` object, so this call would not compile at all, rather than resolving the type-inference ambiguity.