1z0-830 Java SE 21 Developer Professional Questions and Answers

Understanding do-while Execution

A do-while loopexecutes at least oncebefore checking the condition.

++counter < 3 increments counterbeforeevaluating the condition.

Step-by-Step Execution

Iteration 1:counter = 0, print "0", then ++counter becomes 1, condition 1 < 3 istrue.

Iteration 2:counter = 1, print "1", then ++counter becomes 2, condition 2 < 3 istrue.

Iteration 3:counter = 2, print "2", then ++counter becomes 3, condition 3 < 3 isfalse, so loop exits.

Final Output

0 1 2

Thus, the correct answer is:0 1 2

References:

Java SE 21 - Control Flow Statements

Java SE 21 - do-while Loop

Pattern Matching in switch

The switch expression introduced inJava 21supportspattern matchingfor different types.

However,a switch expression must be exhaustive, meaningit must cover all possible cases or provide a default case.

Why does compilation fail?

input is an Object, and the switch expression attempts to pattern-match it to String, Double, and Integer.

If input had been of another type (e.g., Float or Long), there would beno matching case, leading to anon-exhaustive switch.

Javarequires a default caseto ensure all possible inputs are covered.

Corrected Code (Adding a default Case)

java

Object input = 42;

String result = switch (input) {

case String s -> "It's a string with value: " + s;

case Double d -> "It's a double with value: " + d;

case Integer i -> "It's an integer with value: " + i;

default -> "Unknown type";

};

System.out.println(result);

With this change, the codecompiles and runs successfully.

Output:

vbnet

It's an integer with value: 42

Thus, the correct answer is:Compilation failsdue to a missing default case.

References:

Java SE 21 - Pattern Matching for switch

Java SE 21 - switch Expressions

In this code, three static methods from the Boolean class are used: logicalAnd, logicalOr, and logicalXor. Each method takes two boolean arguments and returns a boolean result based on the respective logical operation.

Evaluation of Each Statement:

Boolean.logicalAnd(1 == 1, 2 < 1)

Operands:

1 == 1 evaluates to true.

2 < 1 evaluates to false.

Operation:

Boolean.logicalAnd(true, false) performs a logical AND operation.

The result is false because both operands must be true for the AND operation to return true.

Output:

System.out.print(false); prints false.

Boolean.logicalOr(1 == 1, 2 < 1)

Operands:

1 == 1 evaluates to true.

2 < 1 evaluates to false.

Operation:

Boolean.logicalOr(true, false) performs a logical OR operation.

The result is true because at least one operand is true.

Output:

System.out.print(true); prints true.

Boolean.logicalXor(1 == 1, 2 < 1)

Operands:

1 == 1 evaluates to true.

2 < 1 evaluates to false.

Operation:

Boolean.logicalXor(true, false) performs a logical XOR (exclusive OR) operation.

The result is true because exactly one operand is true.

Output:

System.out.print(true); prints true.

Combined Output:

Combining the outputs from each statement, the final printed result is:

nginx

falsetruetrue

In this code, an ExecutorService is created with a fixed thread pool of size 2 using Executors.newFixedThreadPool(2). A Runnable task is defined to print "Task is complete" to the console.

The sequence of operations is as follows:

service.submit(task);

This submits the task to the executor service for execution. Since the thread pool has a size of 2 and no other tasks are running, this task will be executed promptly, printing "Task is complete" to the console.

service.shutdown();

This initiates an orderly shutdown of the executor service. In this state, the service stops accepting new tasks

In Java generics, wildcards are used to relax the type constraints of generic types. The extends wildcard () denotes an upper bounded wildcard, allowing any type that is a subclass of Type. Conversely, the super wildcard () denotes a lower bounded wildcard, allowing any type that is a superclass of Type.

Option A:

java

public List getListSuper() {

return new ArrayList();

}

Here, List represents a list that can hold IOException objects and objects of its supertypes. Since Exception is a superclass of IOException, ArrayList is compatible with List. Therefore, this method compiles successfully.

Option B:

java

public List getListExtends() {

return new ArrayList();

}

In this case, List represents a list that can hold objects of IOException and its subclasses. Since FileNotFoundException is a subclass of IOException, ArrayList is compatible with List. Thus, this method compiles successfully.

Option C:

java

public List getListExtends() {

return new ArrayList();

}

Here, List expects a list of IOException or its subclasses. However, Exception is a superclass of IOException, not a subclass. Therefore, ArrayList is not compatible with List, and this method will not compile.

Option D:

java

public List getListSuper() {

return new ArrayList();

}

In this scenario, List expects a list that can hold IOException objects and objects of its supertypes. Since FileNotFoundException is a subclass of IOException, ArrayList is not compatible with List, and this method will not compile.

Therefore, the methods in options A and B compile successfully, while those in options C and D do not.

Understanding LongStream.range(1, 1945).boxed().toList();

LongStream.range(1, 1945) generates a stream of numbersfrom 1 to 1944.

.boxed() converts the primitive long values to Long objects.

.toList() (introduced in Java 16)creates an immutable list.

Understanding Executors.newVirtualThreadPerTaskExecutor()

Java 21 introducedvirtual threadsto improve concurrency.

Executors.newVirtualThreadPerTaskExecutor()creates a new virtual thread per submitted task, allowing highly concurrent execution.

Execution Behavior

cannesFestivalfeatureFilms.stream().limit(25) → Limits the stream to thefirst 25 numbers(1 to 25).

.forEach(film -> executor.submit(() -> System.out.println(film)))

Each film is printed inside a virtual thread.

Virtual threads execute asynchronously, meaning numbers arenot guaranteed to print sequentially.

Output will contain numbers from 1 to 25, but their order is random due to concurrent execution.

Possible Output (Random Order)

python-repl

3

1

5

2

4

7

25

The ordermay differ in each rundue to concurrent execution.

Thus, the correct answer is:"Numbers from 1 to 25 randomly."

References:

Java SE 21 - Virtual Threads

Java SE 21 - Executors.newVirtualThreadPerTaskExecutor()

In this code, two LocalDate instances are created representing May 4, 2023, and May 4, 2024. The Period.between() method is used to calculate the period between these two dates, and the Duration.between() method is used to calculate the duration between them.

Period Calculation:

The Period.between() method calculates the amount of time between two LocalDate objects in terms of years, months, and days. In this case, the period between May 4, 2023, and May 4, 2024, is exactly one year. Therefore, p is P1Y, which stands for a period of one year. Printing p will output P1Y.

Duration Calculation:

The Duration.between() method is intended to calculate the duration between two temporal objects that have time components, such as LocalDateTime or Instant. However, LocalDate represents a date without a time component. Attempting to use Duration.between() with LocalDate instances will result in an UnsupportedTemporalTypeException because Duration requires time-based units, which LocalDate does not support.

Exception Details:

The UnsupportedTemporalTypeException is thrown when an unsupported unit is used. In this case, Duration.between() internally attempts to access time-based fields (like seconds), which are not supported by LocalDate. This behavior is documented in the Java Bug System underJDK-8170275.

Correct Usage:

To calculate the duration between two dates, including time components, you should use LocalDateTime or Instant. For example:

java

LocalDateTime start = LocalDateTime.of(2023, Month.MAY, 4, 0, 0);

LocalDateTime end = LocalDateTime.of(2024, Month.MAY, 4, 0, 0);

Duration d = Duration.between(start, end);

System.out.println(d); // Outputs: PT8784H

This will correctly calculate the duration as PT8784H, representing 8,784 hours (which is 366 days, accounting for a leap year).

Conclusion:

The output of the given code will be:

pgsql

P1Y

Exception in thread "main" java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit: Seconds

Therefore, the correct answer is D:

nginx

P1Y

UnsupportedTemporalTypeException

In this code, an ArrayDeque named deque is created, and the integers 1 and 2 are added to it using the offer method. The offer method inserts the specified element at the end of the deque.

State of deque after offers:[1, 2]

The peek method retrieves, but does not remove, the head of the deque, returning 1. Therefore, i1 is assigned the value 1.

State of deque after peek:[1, 2]

Value of i1:1

The poll method retrieves and removes the head of the deque, returning 1. Therefore, i2 is assigned the value 1.

State of deque after poll:[2]

Value of i2:1

Another peek operation retrieves the current head of the deque, which is now 2, without removing it. Therefore, i3 is assigned the value 2.

State of deque after second peek:[2]

Value of i3:2

The System.out.println statement then outputs the values of i1, i2, and i3, resulting in 1 1 2.

Why does the compilation fail?

TheJava switch statement does not support primitive type pattern matchingin switch expressions as of Java 21.

The case pattern case int i -> "integer"; isinvalidbecausepattern matching with primitive types (like int or long) is not yet supported in switch statements.

The error occurs at case int i -> "integer";, leading to acompilation failure.

Correcting the Code

Since myVar is of type Object,autoboxing converts 0 into an Integer.

To make the code compile, we should use Integer instead of int:

java

Object myVar = 0;

String print = switch (myVar) {

case Integer i -> "integer";

case Long l -> "long";

case String s -> "string";

default -> "";

};

System.out.println(print);

Output:

bash

integer

Thus, the correct answer is:Compilation fails.

References:

Java SE 21 - Pattern Matching for switch

Java SE 21 - switch Expressions

Option A (Map<String, ArrayList<String>> authorsMap1 = new HashMap<>();)

❌Compilation Fails

frenchAuthors is declared as List,notArrayList.

The correct way to declare a Map that allows storing List is to use List as the generic type,notArrayList.

Fix:

java

Map> authorsMap1 = new HashMap<>();

authorsMap1.put("FR", frenchAuthors);

Reason:The type ArrayList is more specific than List, and this would cause atype mismatcherror.

Option B (Map<String, ? extends List<String>> authorsMap2 = new HashMap<String, ArrayList<String>>();)

❌Compilation Fails

? extends Listmakes the map read-onlyfor adding new elements.

The line authorsMap2.put("FR", frenchAuthors); causes acompilation errorbecause wildcard (? extends List) prevents modifying the map.

Fix:Remove the wildcard:

java

Map> authorsMap2 = new HashMap<>();

authorsMap2.put("FR", frenchAuthors);

Option C (var authorsMap3 = new HashMap<>();)

Compiles Successfully

The var keyword allows the compiler to infer the type.

However,the inferred type is HashMap<Object, Object>, which may cause issues when retrieving values.

Option D (Map<String, List<String>> authorsMap4 = new HashMap<String, ArrayList<String>>();)

Compiles Successfully

Valid declaration:HashMap can be assigned to Map.

Using new HashMap>() with Map> isalloweddue to polymorphism.

Correct syntax:

java

Map> authorsMap4 = new HashMap>();

authorsMap4.put("FR", frenchAuthors);

Option E (Map<String, List<String>> authorsMap5 = new HashMap<String, List<String>>();)

Compiles Successfully

HashMap> isa valid instantiation.

Correct usage:

java

Map> authorsMap5 = new HashMap<>();

authorsMap5.put("FR", frenchAuthors);

Thus, the correct answers are:C, D, E

References:

Java SE 21 - Generics and Type Inference

Java SE 21 - var Keyword

In this code, the class Main contains both an instance variable instanceVar and a static variable staticVar. The sequence of initialization and execution is as follows:

Static Variable Initialization:

staticVar is declared and initialized to 666.

Static Block Execution:

The static block executes, updating staticVar to 42.

Instance Variable Initialization:

When a new instance of Main is created, instanceVar is initialized to the current value of staticVar, which is 42.

main Method Execution:

The main method creates a new instance of Main and prints the values of instanceVar and staticVar.

Therefore, the output of the program is 42 42.

In this code, the Calculable interface defines a single abstract method calculate that takes an int parameter and returns a long. The main method contains three lambda expressions assigned to variables c1, c2, and c3 of type Calculable.

Line 1:Calculable c1 = i -> i + 1;

This lambda expression takes an integer i and returns the result of i + 1. Since the expression i + 1 results in an int, and Java allows implicit widening conversion from int to long, this line compiles successfully.

Line 2:Calculable c2 = i -> Long.valueOf(i);

Here, the lambda expression takes an integer i and returns the result of Long.valueOf(i). The Long.valueOf(int i) method returns a Long object. However, Java allows unboxing of the Long object to a long primitive type when necessary. Therefore, this line compiles successfully.

Line 3:Calculable c3 = i -> { throw new ArithmeticException(); };

This lambda expression takes an integer i and throws an ArithmeticException. Since the method calculate has a return type of long, and throwing an exception is a valid way to exit the method without returning a value, this line compiles successfully.

Since all three lines adhere to the method signature defined in the Calculable interface and there are no type mismatches or syntax errors, the program compiles successfully.

To achieve the output "August 08", the SimpleDateFormat pattern must format the month in its full textual form and the day as a two-digit number.

Pattern Analysis:

MMMM: Represents the full name of the month (e.g., "August").

dd: Represents the day of the month as a two-digit number, with leading zeros if necessary (e.g., "08").

Therefore, the correct pattern to produce the desired output is MMMM dd.

Option Evaluations:

A. MM d: Formats the month as a two-digit number and the day as a single or two-digit number without leading zeros. For example, "08 8".

B. MM dd: Formats the month and day both as two-digit numbers. For example, "08 08".

C. MMMM dd: Formats the month as its full name and the day as a two-digit number. For example, "August 08".

D. MMM dd: Formats the month as its abbreviated name and the day as a two-digit number. For example, "Aug 08".

Thus, option C (MMMM dd) is the correct choice to match the output "August 08".

1. Why does the compilation fail?

The interface Special contains bar as int bar = 1;.

In Java, all interface fields are implicitly public, static, and final.

This means that bar is a constant (final variable).

The method add() contains bar--, which attempts to modify bar.

Since bar is final, it cannot be modified, causing acompilation error.

2. Correcting the Code

To make the code compile, bar must not be final. One way to fix this:

java

class SpecialImpl implements Special {

int bar = 1;

}

Or modify the add() method:

java

int add() {

return --foo + bar; // No modification of bar

}

Thus, the correct answer is:Compilation fails.

References:

Java SE 21 - Interfaces

Java SE 21 - Final Variables

Understanding ArrayDeque Behavior

ArrayDequeis a double-ended queue (deque), working as aFIFO (queue) and LIFO (stack).

Thedefault behaviorisqueue-like (FIFO)unless explicitly used as a stack.

Step-by-Step Execution

java

var deque = new ArrayDeque<>();

deque.add(1);

deque.add(2);

deque.add(3);

deque.add(4);

deque.add(5);

Deque after additions→ [1, 2, 3, 4, 5]

Operations Breakdown

deque.peek()→ Returns thehead(first element)without removal.

makefile

Output: 1

deque.poll()→ Removes and returns thehead.

go

Output: 1, Deque after poll → `[2, 3, 4, 5]`

deque.pop()→Same as removeFirst(); removes and returns thehead.

perl

Output: 2, Deque after pop → `[3, 4, 5]`

deque.element()→ Returns thehead(same as peek(), but throws an exception if empty).

makefile

Output: 3

Final Output

1 1 2 3

Thus, the correct answer is:1 1 2 3

References:

Java SE 21 - ArrayDeque

Java SE 21 - Queue Operations

The ServiceLoader class in Java is used to load service providers implementing a given service interface. The following methods are evaluated for their correctness in loading an implementation of MyService:

A. MyService service = ServiceLoader.load(MyService.class).iterator().next();

This method uses the ServiceLoader.load(MyService.class) to create a ServiceLoader instance for MyService. Calling iterator().next() retrieves the next available service provider. If no providers are available, a NoSuchElementException will be thrown. This approach is correct but requires handling the potential exception if no providers are found.

B. MyService service = ServiceLoader.load(MyService.class).findFirst().get();

This method utilizes the findFirst() method introduced in Java 9, which returns an Optional describing the first available service provider. Calling get() on the Optional retrieves the service provider if present; otherwise, a NoSuchElementException is thrown. This approach is correct and provides a more concise way to obtain the first service provider.

C. MyService service = ServiceLoader.getService(MyService.class);

The ServiceLoader class does not have a method named getService. Therefore, this method is incorrect and will result in a compilation error.

D. MyService service = ServiceLoader.services(MyService.class).getFirstInstance();

The ServiceLoader class does not have a method named services or getFirstInstance. Therefore, this method is incorrect and will result in a compilation error.

In summary, options A and B are correct methods to load an implementation of MyService using ServiceLoader.

The Java Platform Module System (JPMS), introduced in Java 9, modularizes the Java platform and applications. Understanding the behavior of named and unnamed modules is crucial.

B. The unnamed module exports all of its packages.

Correct. The unnamed module, which includes all code on the classpath, exports all of its packages. This means that any code can access the public types in these packages. However, the unnamed module cannot be explicitly required by named modules.

C. If a package is defined in both a named module and the unnamed module, then the package in the unnamed module is ignored.

Correct. In cases where a package is present in both a named module and the unnamed module, the version in the named module takes precedence. The package in the unnamed module is ignored to maintain module integrity and avoid conflicts.

F. If a request is made to load a type whose package is not defined in any known module, then the module system will attempt to load it from the classpath.

Correct. When the module system cannot find a requested type in any known module, it defaults to searching the classpath (i.e., the unnamed module) to locate the type.

Incorrect Options:

A. Code in an explicitly named module can access types in the unnamed module.

Incorrect. Named modules cannot access types in the unnamed module. The unnamed module can read from named modules, but the reverse is not allowed to ensure strong encapsulation.

D. We must add a module descriptor to make an application developed using a Java version prior to SE9 run on Java 11.

Incorrect. Adding a module descriptor (module-info.java) is not mandatory for applications developed before Java 9 to run on Java 11. Such applications can run in the unnamed module without modification.

E. The unnamed module can only access packages defined in the unnamed module.

Incorrect. The unnamed module can access all packages exported by all named modules, in addition to its own packages.

In this code, now is assigned the current date using LocalDate.now(). The goal is to format this date to the ISO week date format, which represents dates in the YYYY-'W'WW-E pattern, where:

YYYY: Week-based year

'W': Literal 'W' character

WW: Week number

E: Day of the week

Given that the present day is December 31, 2024, this date falls in the first week of the week-based year 2025. Therefore, the ISO week date representation would be 2025-W01-2, where '2' denotes Tuesday.

Among the provided formatters:

format1: This line attempts to create a DateTimeFormatter using a constructor, which is incorrect because DateTimeFormatter does not have a public constructor that accepts a pattern directly. This would result in a compilation error.

format2: This is correctly assigned the predefined DateTimeFormatter.ISO_WEEK_DATE, which formats dates in the ISO week date format.

format3: This line attempts to create a DateFormat instance using a field, which is incorrect because DateFormat does not have such a constructor. This would result in a compilation error.

format4: This line attempts to get a DateFormat instance using an integer field, which is incorrect because DateFormat.getDateInstance() does not accept such parameters. This would result in a compilation error.

Therefore, the only correct and applicable formatter is format2. Using format2 in the now.format() method will produce the desired output: 2025-W01-2.

In this code, there is a type mismatch between the DoubleStream and the Predicate.

DoubleStream: A sequence of primitive double values.

Predicate<Double>: A functional interface that operates on objects of type Double (the wrapper class), not on primitive double values.

The DoubleStream class provides a method anyMatch(DoublePredicate predicate), where DoublePredicate is a functional interface that operates on primitive double values. However, in the code, a Predicate is used instead of a DoublePredicate. This mismatch leads to a compilation error because anyMatch cannot accept a Predicate when working with a DoubleStream.

To correct this, the predicate should be defined as a DoublePredicate to match the primitive double type:

java

DoubleStream doubleStream = DoubleStream.of(3.3, 4, 5.25, 6.66);

DoublePredicate doublePredicate = d -> d < 5;

System.out.println(doubleStream.anyMatch(doublePredicate));

With this correction, the code will compile and print true because there are elements in the stream (e.g., 3.3 and 4.0) that are less than 5.

In this code, a Stream of String elements is created containing "United" and "States". A BinaryOperator named operator is defined to concatenate the first string (s1) with the uppercase version of the second string (s2). The reduce method is then used with "-" as the identity value and operator as the accumulator.

The reduce method processes the elements of the stream as follows:

Initial Identity Value: "-"

First Iteration:

Accumulator Operation: "-".concat("United".toUpperCase())

Result: "-UNITED"

Second Iteration:

Accumulator Operation: "-UNITED".concat("States".toUpperCase())

Result: "-UNITEDSTATES"

Therefore, the final result stored in result is "-UNITEDSTATES", and the output of theSystem.out.println(result); statement is -UNITEDSTATES.

In this program, we have two classes, A and B, both implementing the Serializable interface, and a Test class with the main method.

Program Flow:

Serialization:

An instance of class A is created and assigned to the variable a.

An ObjectOutputStream is created to write to the file "o.ser".

The object a is serialized and written to the file.

The ObjectOutputStream is closed.

Deserialization:

An ObjectInputStream is created to read from the file "o.ser".

The program attempts to read an object from the file and cast it to an instance of class B.

The ObjectInputStream is closed.

Analysis:

Serialization Process:

The object a is an instance of class A and is serialized into the file "o.ser".

Deserialization Process:

When deserializing, the program reads the object from the file and attempts to cast it to class B.

However, the object in the file is of type A, not B.

Since A and B are distinct classes with no inheritance relationship, casting an A instance to B is invalid.

Exception Details:

Attempting to cast an object of type A to type B results in a ClassCastException.

The exception message would be similar to:

pgsql

Exception in thread "main" java.lang.ClassCastException: class A cannot be cast to class B

Conclusion:

The program compiles successfully but throws a ClassCastException at runtime when it attempts to cast the deserialized object to class B.

The jdeps tool is a Java class dependency analyzer that can be used to understand the static dependencies of applications and libraries. It provides several command-line options to customize its behavior.

Valid jdeps Options:

--generate-open-module: Generates a module declaration (module-info.java) with open directives for the given JAR files or classes.

--list-deps: Lists the immediate dependencies of the specified classes or JAR files.

--generate-module-info: Generates a module declaration (module-info.java) for the given JAR files or classes.

--print-module-deps: Prints the module dependencies of the specified modules or JAR files.

--list-reduced-deps: Lists the reduced dependencies, showing only the packages that are directly depended upon.

Invalid Option:

--check-deps: There is no --check-deps option in the jdeps tool.

Conclusion:

Option A (--check-deps) is not a valid option of the jdeps command.