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

In Java, array initialization can be performed in several ways, but certain syntaxes are invalid and will cause compilation errors. Let's analyze each declaration:

var array1 = new String[]{ "foo", "bar", "buz" };

This is a valid declaration. The var keyword allows the compiler to infer the type from the initializer. Here, new String[]{ "foo", "bar", "buz" } creates an anonymous array of String with three elements. The compiler infers array1 as String[]. This syntax is correct and compiles successfully.

var array2[] = { "foo", "bar", "buz" };

This declaration is invalid. While var can be used for type inference, appending [] after var is not allowed. The correct syntax would be either String[] array2 = { "foo", "bar", "buz" }; or var array2 = new String[]{ "foo", "bar", "buz" };. Therefore, this line will cause a compilation error.

var array3 = new String[3] { "foo", "bar", "buz" };

This declaration is invalid. In Java, when specifying the size of the array (new String[3]), you cannot simultaneously provide an initializer. The correct approach is either to provide the size without an initializer (new String[3]) or to provide the initializer without specifying the size (new String[]{ "foo", "bar", "buz" }). Therefore, this line will cause a compilation error.

var array4 = { "foo", "bar", "buz" };

This declaration is invalid. The array initializer { "foo", "bar", "buz" } can only be used in an array declaration when the type is explicitly provided. Since var relies on type inference and there's no explicit type provided here, this will cause a compilation error. The correct syntax would be String[] array4 = { "foo", "bar", "buz" };.

String array5[] = new String[]{ "foo", "bar", "buz" };

This is a valid declaration. Here, String array5[] declares array5 as an array of String. The initializer new String[]{ "foo", "bar", "buz" } creates an array with three elements. This syntax is correct and compiles successfully.

Therefore, the declarations that compile successfully are array1 and array5.

References:

Java SE 21 & JDK 21 - Local Variable Type Inference

Java SE 21 & JDK 21 - Arrays

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

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.

In Java,protected memberscan only be accessedwithin the same packageor bysubclasses, but there is a key restriction:

A protected member of a superclass is only accessible through inheritance in a subclass but not through an instance of the superclass that is declared outside the package.

Why does compilation fail?

In the MiniVan class, the following line causes acompilation error:

java

Car car = new Car();

car.brand = "Peugeot 807";

The brand field isprotectedin Car, which means it isnot accessible via an instance of Car outside the vehicule.parent package.

Even though MiniVan extends Car, itcannotaccess brand using a Car instance (car.brand) because car is declared as an instance of Car, not MiniVan.

The correct way to access brand inside MiniVan is through inheritance (this.brand or super.brand).

Corrected Code

If we change the MiniVan class like this, it will compile and run successfully:

java

package vehicule.child;

import vehicule.parent.Car;

public class MiniVan extends Car {

public static void main(String[] args) {

MiniVan minivan = new MiniVan(); // Access via inheritance

minivan.brand = "Peugeot 807";

System.out.println(minivan.brand);

}

}

This would output:

nginx

Peugeot 807

Key Rule from Oracle Java Documentation

Protected membersof a class are accessible withinthe same packageand tosubclasses, butonly through inheritance, not through a superclass instance declared outside the package.

References:

Java SE 21 & JDK 21 - Controlling Access to Members of a Class

Java SE 21 & JDK 21 - Inheritance Rules

In this code, we have two interfaces and a class with a main method:

WithDefaultMethod Interface:

Declares a default method print() that outputs "default".

WithStaticMethod Interface:

Extends WithDefaultMethod.

Declares a static method print() that outputs "static".

DefaultAndStaticMethods Class:

Contains the main method, which calls WithStaticMethod.print().

Key Points:

Static Methods in Interfaces:

Static methods in interfaces are not inherited by implementing or extending classes or interfaces. They belong solely to the interface in which they are declared.

Default Methods in Interfaces:

Default methods can be inherited by implementing classes, but they cannot be overridden by static methods in subinterfaces.

Execution Flow:

The main method calls WithStaticMethod.print().

This invokes the static method print() defined in the WithStaticMethod interface, which outputs "static".

Therefore, the program compiles successfully and prints static.

In Java, a lambda expression can have two forms for its body:

Single Expression:A concise form where the body consists of a single expression. The result of this expression is implicitly returned.

Example:

java

(a, b) -> a + b

In this example, (a, b) are the parameters, and a + b is the single expression that adds them together.

Statement Block:A more detailed form where the body consists of a block of statements enclosed in braces {}. Within this block, you can have multiple statements, and if a return value is expected, you must explicitly use the return statement.

Example:

java

(a, b) -> {

int sum = a + b;

System.out.println("Sum is: " + sum);

return sum;

}

In this example, the lambda body is a statement block that performs multiple actions: it calculates the sum, prints it, and then returns the sum.

Given the options:

A. Two statements:While a lambda body can contain multiple statements, they must be enclosed within a statement block {}. Simply having two statements without braces is not valid syntax for a lambda expression.

B. An expression and a statement:Similar to option A, if a lambda body contains more than one element (be it expressions or statements), they need to be enclosed in a statement block.

C. A statement block:This is correct. A lambda expression can have a body that is a statement block, allowing multiple statements enclosed in braces.

D. None of the above:This is incorrect since option C is valid.

E. Two expressions:As with options A and B, multiple expressions must be enclosed in a statement block to form a valid lambda body.

Therefore, the correct answer is C: A statement block.

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

1. Why Does Compilation Fail?

The error is in this line:

java

final Stream strings = Files.readAllLines(Paths.get("orders.csv"));

Files.readAllLines(Paths.get("orders.csv")) returns a List<String>,not a Stream<String>.

A List cannot be assigned to a Stream.

2. Correcting the Code

The correct way to create a stream from the file:

java

Stream strings = Files.lines(Paths.get("orders.csv"));

This correctly creates a Stream from the file.

3. Expected Output After Fixing

java

Files.lines(Paths.get("orders.csv"))

skip(1) // Skips the header row

limit(2) // Limits to first two data rows

forEach(System.out::println);

Output:

arduino

1,Kylian Mbappé,Keyboard,2,25.50

2,Teddy Riner,Mouse,1,15.99

Thus, the correct answer is:Compilation fails.

References:

Java SE 21 - Files.readAllLines

Java SE 21 - Files.lines

1. Valid Use Cases of var

var is alocal variable type inferencefeature.

The compilerinfers the type from the assigned value.

Example of valid use:

java

var a = 10; // Type inferred as int

var str = "Hello"; // Type inferred as String

2. Analyzing the Given Statements

Statement

Valid/Invalid

Reason

var a = 1;

Valid

Type inferred as int.

var b = 2, c = 3.0;

❌Invalid

var doesnot allow multiple declarationsin one statement.

var d[] = new int[4];

❌Invalid

Array brackets []are not allowedwith var.

var e;

❌Invalid

varrequires an initializer(cannot be declared without assignment).

var f = { 6 };

❌Invalid

{ 6 } is anarray initializer, which must have an explicit type.

var h = (g = 7);

Valid

g is assigned 7, and h gets its value.

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

References:

Java SE 21 - Local Variable Type Inference (var)

Java SE 21 - var Restrictions

Understanding the do-while Loop

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

The condition i++ > 0 increments iafterchecking.

Step-by-Step Execution

Iteration 1:

i = 0

Prints: "Chanel"

i++ updates i to 1

Condition 1 > 0is true, so the loop exits.

Why Doesn't the Loop Continue?

Since i starts at 0, the conditioni++ > 0 is false after the first iteration.

The loopexits immediately after printing "Chanel".

Final Output

nginx

Chanel

Thus, the correct answer is:Chanel

References:

Java SE 21 - do-while Loop

Java SE 21 - Post-Increment Behavior

In the provided code, a list abc is created containing the strings "a", "b", and "c". The first forEach operation attempts to convert each element to uppercase by assigning x = x.toUpperCase();. However, this assignment only changes the local variable x within the lambda expression and does not modify the elements in the original list abc. Strings in Java are immutable, meaning their values cannot be changed once created. Therefore, the original list remains unchanged.

The second forEach operation iterates over the original list and prints each element. Since the list was not modified, the output will be the concatenation of the original elements: abc.

To achieve the output ABC, you would need to collect the transformed elements into a new list, as shown below:

java

List abc = List.of("a", "b", "c");

List upperCaseAbc = abc.stream()

map(String::toUpperCase)

collect(Collectors.toList());

upperCaseAbc.forEach(System.out::print);

In this corrected version, the map operation creates a new stream with the uppercase versions of the original elements, which are then collected into a new list upperCaseAbc. The forEach operation then prints ABC.

In Java, the final keyword can be applied to classes, methods, and variables to impose certain restrictions.

Final Classes:

Definition:A class declared with the final keyword is known as a final class.

Purpose:Declaring a class as final prevents it from being subclassed. This is useful when you want to ensure that the class's implementation remains unchanged and cannot be extended or modified through inheritance.

Option Evaluations:

A. The final keyword in its declaration must go right before the class keyword.

This is correct. The syntax for declaring a final class is:

java

public final class ClassName {

// class body

}

However, this statement is about syntax rather than the core characteristic of a final class.

B. It must contain at least a final method.

Incorrect. A final class can have zero or more methods, and none of them are required to be declared as final. The final keyword at the class level prevents inheritance, regardless of the methods' finality.

C. It cannot be extended by any other class.

Correct. The primary characteristic of a final class is that it cannot be subclassed. Attempting to do so will result in a compilation error.

D. It cannot implement any interface.

Incorrect. A final class can implement interfaces. Declaring a class as final restricts inheritance but does not prevent the class from implementing interfaces.

E. It cannot extend another class.

Incorrect. A final class can extend another class. The final keyword prevents the class from being subclassed but does not prevent it from being a subclass itself.

Therefore, the correct statement about a final class is option C: "It cannot be extended by any other class."

In this code, the SmartPhone interface declares a method ring() with a boolean return type. The Iphone15 class implements the SmartPhone interface and provides an implementation for the ring() method.

However, in the Iphone15 class, the ring() method is declared without the public access modifier. In Java, when a class implements an interface, it must provide implementations for all the interface's methods with the same or a more accessible access level. Since interface methods are implicitly public, the implementing methods in the class must also be public. Failing to do so results in a compilation error.

Therefore, the Iphone15 class does not compile because the ring() method is not declared as public.

Understanding CopyOnWriteArrayList

CopyOnWriteArrayList is a thread-safe variant of ArrayList whereall mutative operations (add, set, remove, etc.) create a new copy of the underlying array.

This meansiterations will not reflect modifications made after the iterator was created.

Instead of modifying the existing array, a new copy is created for modifications, ensuring that readers always see a consistent snapshot.

Thread Execution Behavior

Thread 1 (Writer Thread)adds "D" to the list.

Thread 2 (Reader Thread)iterates over the list.

The reader thread gets a snapshot of the listbefore"D" is added.

The output may look like:

mathematica

Read element: A

Read element: B

Read element: C

Element added: D

"D" may not appear in the output of the reader threadbecause the iteration occurs on a snapshot before the modification.

Why doesn't it print all elements including changes?

Since CopyOnWriteArrayList doesnot allow changes to be visible during iteration, the reader threadwill not see "D"if it started iterating before "D" was added.

Thus, the correct answer is:"It prints all elements, but changes made during iteration may not be visible."

References:

Java SE 21 - CopyOnWriteArrayList

Understanding Constructors vs. Methods in Java

In Java, aconstructormustnot have a return type.

The followingis NOT a constructorbut aregular method:

java

void Versailles() { // This is NOT a constructor!

Correct way to define a constructor:

java

public Versailles() { // Constructor must not have a return type

Since there isno constructor explicitly defined,Java provides a default no-argument constructor, which does nothing.

Why Does Compilation Fail?

void Versailles() is interpreted as amethod,not a constructor.

This means the default constructor (which does nothing) is called.

Since the method Versailles() is never called, the object fields remain uninitialized.

If the constructor were correctly defined, the output would be:

nginx

Hall of Mirrors has 17 mirrors.

The gardens cover 800 hectares.

How to Fix It

java

public Versailles() { // Corrected constructor

this.mirrorsCount = 17;

this.gardensHectares = 800;

System.out.println("Hall of Mirrors has " + mirrorsCount + " mirrors.");

System.out.println("The gardens cover " + gardensHectares + " hectares.");

}

Thus, the correct answer is:Compilation fails at line n1.

References:

Java SE 21 - Constructors

Java SE 21 - Methods vs. Constructors

Understanding Sealed Classes in Java

Asealed classrestricts which other classes can extend it.

A sealed classmust explicitly declare its permitted subclassesusing the permits keyword.

Subclasses can be declared as:

sealed(restricts further extension).

non-sealed(removes the restriction, allowing unrestricted subclassing).

final(prevents further subclassing).

Analyzing the Given Code

Vehicle is declared as sealed with permits Car, Bike, meaning only Car and Bike can extend it.

Car is declared as non-sealed, which means itis no longer sealedand can have subclasses.

Bike is declared as final, meaningit cannot be subclassed.

Using isSealed() Method

vehicleClass.isSealed() →truebecause Vehicle is explicitly marked as sealed.

carClass.isSealed() →falsebecause Car is marked non-sealed.

bikeClass.isSealed() →falsebecause Bike is final, and a final class isnot considered sealed.

Final Output

csharp

Is Vehicle sealed? true; Is Car sealed? false; Is Bike sealed? false

Thus, the correct answer is:"Is Vehicle sealed? true; Is Car sealed? false; Is Bike sealed? false"

References:

Java SE 21 - Sealed Classes

Java SE 21 - isSealed() Method

Error in for Loop Initialization

The initialization part of a for loopcannot declare multiple variables with different types in a single statement.

Error:

java

for (int i = 0, int j = 3; i < j; i++) {

Fix:Declare variables separately:

java

for (int i = 0, j = 3; i < j; i++) {

lyrics.lines() in Java 21

The lines() method of String returns aStream<String>, splitting the string by line breaks.

Calling .toList() on a streamconverts it to a list.

Valid Code After Fixing the Loop:

java

var lyrics = """

Quand il me prend dans ses bras

Qu'il me parle tout bas

Je vois la vie en rose

""";

for (int i = 0, j = 3; i < j; i++) {

System.out.println(lyrics.lines()

toList()

get(i));

}

Expected Output After Fixing:

vbnet

Quand il me prend dans ses bras

Qu'il me parle tout bas

Je vois la vie en rose

Thus, the correct answer is:Compilation fails.

References:

Java SE 21 - String.lines()

Java SE 21 - for Statement Rules

In this program, the following operations are performed:

Paths Initialization:

Path p1 is set to "f1.txt".

Path p2 is set to "f2.txt".

File Move Operation:

Files.move(p1, p2); attempts to move (or rename) f1.txt to f2.txt.

File Delete Operation:

Files.delete(p1); attempts to delete f1.txt.

Analysis:

If f1.txt Does Not Exist:

The Files.move(p1, p2); operation will throw a NoSuchFileException because the source file f1.txt is missing.

If f1.txt Exists and f2.txt Does Not Exist:

The Files.move(p1, p2); operation will successfully rename f1.txt to f2.txt.

Subsequently, the Files.delete(p1); operation will throw a NoSuchFileException because p1 (now f1.txt) no longer exists after the move.

If Both f1.txt and f2.txt Exist:

The Files.move(p1, p2); operation will throw a FileAlreadyExistsException because the target file f2.txt already exists.

If f2.txt Exists While f1.txt Does Not:

Similar to the first scenario, the Files.move(p1, p2); operation will throw a NoSuchFileException due to the absence of f1.txt.

In all possible scenarios, an exception is thrown during the execution of the program.

In this code, a TreeSet named frenchCities is created and populated with the following cities: "Paris", "Marseille", "Lyon", "Lille", and "Toulouse". The TreeSet class in Java stores elements in a sorted order according to their natural ordering, which, for strings, is lexicographical order.

Sorted Order of Elements:

When the elements are added to the TreeSet, they are stored in the following order:

"Lille"

"Lyon"

"Marseille"

"Paris"

"Toulouse"

headSet Method:

The headSet(E toElement) method of the TreeSet class returns a view of the portion of this set whose elements are strictly less than toElement. In this case, frenchCities.headSet("Marseille") will return a subset of frenchCities containing all elements that are lexicographically less than "Marseille".

Elements Less Than "Marseille":

From the sorted order, the elements that are less than "Marseille" are:

"Lille"

"Lyon"

Therefore, the output of the System.out.println statement will be [Lille, Lyon].

Option Evaluations:

A. [Paris]: Incorrect. "Paris" is lexicographically greater than "Marseille".

B. [Paris, Toulouse]: Incorrect. Both "Paris" and "Toulouse" are lexicographically greater than "Marseille".

C. [Lille, Lyon]: Correct. These are the elements less than "Marseille".

D. Compilation fails: Incorrect. The code compiles successfully.

E. [Lyon, Lille, Toulouse]: Incorrect. "Toulouse" is lexicographically greater than "Marseille".

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

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