1Z0-829 — frequently asked questions

In parallel streams, the combiner merges partial results. Here, it combines "wTable" and "wChair".

Yes, since it uses a two-argument reduce without a combiner on a small list, the order of addition doesn't change the final string for this specific case.

No. Volatile ensures visibility of changes across threads but does not impose any ordering or mutual exclusion on execution flow.

AtomicInteger uses CAS (Compare-And-Swap) instructions at the hardware level, allowing non-blocking increments without acquiring locks.

Only if it is explicitly suffixed with an uppercase L (e.g., 0b1101_1010L). Otherwise, it is always an int.

The value 0b1101_1010 (218 decimal) fits comfortably within the positive range of a 32-bit signed int.

You can, but it restricts further extension to only the permitted subclasses listed in the permits clause. Use 'non-sealed' to allow unrestricted implementation.

No, 'public' is optional. The critical requirement is the sealing modifier (sealed, non-sealed, or final) when extending another sealed type.

Because C does not override mB(), the inherited implementation from B is used. Polymorphism only applies to overridden methods.

No. The variable v is statically typed as B. To call mC(), you must re-bind v to a variable of type C using another instanceof check, as shown with v1.

It does append. The first write adds '01234567'. The second write adds '89'. The total is '0123456789'.

It would write the entire 8-char buffer every time, including old data, leading to corrupted output like '0123456789234567'.

myTextBlk1's closing quotes are on the same line as the text, so no newline is added. myTextBlk2's closing quotes are on a new line, adding an implicit newline.

No. intern() ensures that strings with identical values share the same reference, but it does not change the value of the string itself.

No, Strings are immutable. replace() returns a new string; the original variable remains unchanged unless reassigned.

Because the variable 'a' was never updated with the result of replace(), so it still points to the original string containing 'Java' at index 7.

No. Threads in waiting or blocked states are inactive and yield the CPU to other threads until they become runnable.

It moves to the runnable state to contend for the monitor lock or CPU resources, not directly to terminated.

In Java, switch statements do not automatically stop after a match unless a break statement is explicitly used. Without break, execution falls through to the next case.

No, missing break statements are valid Java syntax. They enable intentional fall-through behavior, so the code compiles successfully.

Switch expressions use the arrow (->) syntax and automatically terminate after the first match, unlike switch statements which require break to prevent fall-through.

No, break statements are not required in switch expressions. They are designed to return a value immediately upon matching a case.

In parallel streams, the accumulator is applied to partitions. Each partition starts with the identity, so 5 is added per partition before combining results.

Yes, addition is associative. However, using the identity argument incorrectly causes it to be added to each partition's initial state, inflating the total.

Because x++ modifies the local parameter variable, which shadows the instance variable. The instance variable is untouched.

It explicitly references the instance field of the current object, bypassing any local variable with the same name.

It returns 1 by coincidence because the element 'e3' is located at index 1 (the midpoint) of the array [e1, e3, e2]. This is undefined behavior and not guaranteed.

No. The Java documentation explicitly requires the list to be sorted in ascending order. Using it on an unsorted list produces undefined results.

String parsing methods do not accept underscore separators; they are only supported in source code numeric literals.

No, =+ is not a standard compound operator. It is likely a typo for += in the exam question text.

The variable c is incremented via c++. It starts at -1 (from XOR), so the comparison uses -1, then c becomes 0. The printed value is the post-incremented c.

& always evaluates both operands. && short-circuits if the left operand is false. Here, the second line uses &&, but both sides were true anyway.

Version numbers (typically trailing digits and hyphens) are stripped from the filename before transforming special characters.

JPMS requires that all non-alphanumeric characters in the resulting name be replaced with dots to form valid module names.

Bottom-up migration starts from leaf modules and moves up, potentially keeping unnamed modules on the classpath until dependencies are resolved. Top-down moves all modules to the module path from the start.

Yes, but they must be converted to automatic modules or named modules and placed on the module path. The key is that all modules end up on the module path in top-down migration.

Because the transition back to standard time means the same local hour exists in two different UTC offsets. Advancing the instant moves you to the later occurrence.

It uses the Smarter Algorithm by default, preferring the earlier offset for ambiguous times unless specified otherwise, affecting how arithmetic operations resolve.

Because the list has 3 elements, valid indices are 0, 1, and 2. Index 3 is out of bounds.

No, it returns a standard Java List which is strictly zero-based.

Java does not implicitly narrow a double literal (15.25) to a float. It must be explicitly cast or suffixed with 'f'.

It is called when no other more specific method signature matches the provided arguments, such as when all args are doubles.

No. Overloaded methods are resolved at compile time based on the declared parameter types, regardless of the actual object instance.

The code is valid Java. The compiler can clearly distinguish between the two runs methods by their argument types Animal and Dog.

Private methods in interfaces have package-private-like scope restricted to the interface itself, so they cannot be called from outside.

No, static methods must be called using the interface name (e.g., IFace.m3()). Calling them via an instance is a compilation error.

It truncates (chops off) lower units. It does not round to the nearest unit.

Because the login time is strictly before the logout time, the !isBefore check fails, triggering the else block.

No, it must be strictly private to be recognized by the serialization runtime.

They are not restored from the stream and revert to their default initialization values (e.g., 0.0 for double).

Java deserialization restores object state directly from the byte stream without invoking constructors to ensure security and efficiency, bypassing initialization logic.

Not automatically. You would need to implement a custom readObject method that manually triggers constructor-like logic, but this is rare and complex.

AutoCloseable is an interface, so you must use 'implements'. 'extends' is only for classes.

The code might compile but won't print 'Close'. The try-with-resources calls close(), so it must be implemented.

ISO-8601 standardizes duration representation. 5000 milliseconds is exactly 5 seconds, so it converts to the base unit 'S' prefixed by 'PT'.

No. Period uses only the 'P' prefix (e.g., P6D) because it represents calendar-based dates. Duration uses 'PT' to separate the date part from the time part.

No. p = null only sets the variable p to null. p1 still holds a valid reference to the original object.

Because p1 = p makes both variables point to the same object instance in memory. Changes to the object are visible through any reference.

Records are designed to be immutable data carriers. Non-static fields would break the implicit immutability and canonical constructor contract.

Yes, a standard class allows non-static instance fields, but the question specifically asks how to fix the record code.

valueOf returns the enum constant object Forecast.CLOUDY. When printed, Java calls the object's toString() method, which is overridden to return 'SNOWY'.

Yes, ordinal() returns the index of the enum constant in the declaration order. SUNNY is the first constant, so its ordinal is 0.

Option A assumes all objects linked to t1 become unreachable. However, in this scenario, only one specific object loses its last reference, while others may remain reachable through different paths.

t1 acts as a root or intermediate node. When t1's reference is lost or modified, it triggers the reachability check for the objects it directly pointed to, determining their survival.