Oracle 1z0-830 Java SE 21 Developer Professional Exam Practice Test

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

Understanding Optional.ofNullable(null)

Optional.ofNullable(null); creates an empty Optional (i.e., it contains no value).

Optional.of(null); would throw a NullPointerException, but ofNullable(null); safely creates an empty Optional.

Execution of orElse, orElseGet, and orElseThrow

orElse("Baguette")

Since optionalName is empty, "Baguette" is returned.

bread = "Baguette"

Output:"bread:Baguette"

orElseGet(() -> "Frog legs")

Since optionalName is empty, "Frog legs" is returned from the lambda expression.

dish = "Frog legs"

Output:", dish:Frog legs"

orElseThrow(() -> new Exception())

Since optionalName is empty, an exception is thrown.

The catch block catches this exception and prints ", no cheese.".

Thus, the final output is:

makefile

bread:Baguette, dish:Frog legs, no cheese.

References:

Java SE 21 & JDK 21 - Optional

Java SE 21 - Functional Interfaces

In this code, a Stream containing the elements "a" and "b" is processed using the collect method. The collect method is a terminal operation that performs a mutable reduction on the elements of the stream using a Collector. In this case, custom implementations for the supplier, accumulator, and combiner are provided.

Components of the collect Method:

Supplier:

() -> new StringBuilder("c")

This supplier creates a new StringBuilder initialized with the string "c".

Accumulator:

StringBuilder::append

This accumulator appends each element of the stream to the StringBuilder.

Combiner:

(a, b) -> b.append(a)

This combiner is used in parallel stream operations to merge two StringBuilder instances. It appends the contents of a to b.

Execution Flow:

Stream Elements:"a", "b"

Initial StringBuilder:"c"

Accumulation:

The first element "a" is appended to "c", resulting in "ca".

The second element "b" is appended to "ca", resulting in "cab".

Combiner:

In this sequential stream, the combiner is not utilized. The combiner is primarily used in parallel streams to merge partial results.

Final Result:

The StringBuilder contains "cab". Therefore, the output of the program is:

nginx

cab

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

In Java, method overloading allows multiple methods with the same name to exist in a class, provided they have different parameter lists (i.e., different number or types of parameters). However, having two methods with the exact same parameter list and only differing in return type is not permitted.

In the provided code, the FetchService class contains two fetch methods:

public String fetch()

public LocalDate fetch()

Both methods have identical parameter lists (none) but differ in their return types (String and LocalDate, respectively). This leads to a compilation error because the Java compiler cannot distinguish between the two methods based solely on return type.

The Java Language Specification (JLS) states:

"It is a compile-time error to declare two methods with override-equivalent signatures in a class."

In this context, "override-equivalent" means that the methods have the same name and parameter types, regardless of their return types.

Therefore, the code will fail to compile due to the duplicate method signatures, and the correct answer is B: Compilation fails.

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, a Stream of String elements is created containing the characters "J", "a", "v", and "a". The reduce method is then used with String::concat as the accumulator function.

The reduce method with a single BinaryOperator parameter performs a reduction on the elements of the stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any. In this case, it concatenates the strings in the stream.

Since the stream contains elements, the reduction operation concatenates them to form the string "Java". The result is wrapped in an Optional, resulting in Optional[Java]. The print statement outputs this Optional object, displaying Optional[Java].

The CopyOnWriteArrayList is a thread-safe variant of ArrayList in which all mutative operations (such as add, set, and remove) are implemented by creating a fresh copy of the underlying array. This design allows for safe iteration over the list without requiring external synchronization, as iterators operate over a snapshot of the array at the time the iterator was created. Consequently, modifications made to the list after the creation of an iterator are not reflected in that iterator.

docs.oracle.com

Evaluation of Options:

Option A:Correct. This statement accurately describes the behavior of CopyOnWriteArrayList.

Option B:Incorrect. CopyOnWriteArrayList is thread-safe and is designed to prevent interference among concurrent threads.

Option C:Incorrect. Iterators of CopyOnWriteArrayList do not reflect additions, removals, or changes made to the list after the iterator was created; they operate on a snapshot of the list's state at the time of their creation.

Option D:Incorrect. CopyOnWriteArrayList allows null elements.

Option E:Incorrect. Element-changing operations on iterators, such as remove, set, and add, are not supported in CopyOnWriteArrayList and will throw UnsupportedOperationException.

Understanding Try-With-Resources (AutoCloseable)

BoomBoom implements AutoCloseable, meaning its close() method isautomatically calledat the end of the try block.

Step-by-Step Execution

Step 1: Enter Try Block

java

try (BoomBoom boomBoom = new BoomBoom()) {

System.out.print("bim ");

throw new Exception();

}

"bim " is printed.

Anexception (Exception) is thrown, butbefore it is handled, the close() method is executed.

Step 2: close() is Called

java

@Override

public void close() throws Exception {

System.out.print("bam ");

throw new RuntimeException();

}

"bam " is printed.

A new RuntimeException is thrown, but it doesnot override the existing Exception yet.

Step 3: Exception Handling

java

} catch (Exception e) {

System.out.print("boom ");

}

The catch (Exception e)catches the original Exception from the try block.

"boom " is printed.

Final Output

nginx

bim bam boom

Theoriginal Exception is caught, not the RuntimeException from close().

TheRuntimeException from close() is ignoredbecause thecatch block is already handling Exception.

Thus, the correct answer is:bim bam boom

References:

Java SE 21 - Try-With-Resources

Java SE 21 - AutoCloseable Interface

In this code, a double variable amount is initialized to 42,000.00. The NumberFormat.getCompactNumberInstance(Locale.FRANCE, NumberFormat.Style.SHORT) method is used to obtain a compact number formatter for the French locale with the short style. The format method is then called to format the amount.

The compact number formatting is designed to represent numbers in a shorter form, based on the patterns provided for a given locale. In the French locale, the short style represents thousands with a lowercase 'k'. Therefore, 42,000 is formatted as 42 k.

Option Evaluations:

A. 42000E: This format is not standard in the French locale for compact number formatting.

B. 42 000,00 €: This represents the number as a currency with two decimal places, which is not the compact form.

C. 42000: This is the plain number without any formatting, which does not match the compact number format.

D. 42 k: This is the correct compact representation of 42,000 in the French locale with the short style.

Thus, option D (42 k) is the correct output.

Understanding TreeMap.subMap(fromKey, fromInclusive, toKey, toInclusive)

TreeMap.subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) returns aportion of the mapthat falls within the specified key range.

Thefirst boolean parameter(fromInclusive) determines if the fromKey should be included.

Thesecond boolean parameter(toInclusive) determines if the toKey should be included.

Given TreeMap Contents

CopyEdit

{1=Moulin Rouge, 2=Crazy Horse, 3=Paradis Latin, 4=Le Lido, 5=Folies Bergère}

Applying subMap(2, true, 5, false)

Includeskey 2 ("Crazy Horse")✅(fromInclusive = true)

Includeskey 3 ("Paradis Latin")✅

Includeskey 4 ("Le Lido")✅

Excludes key 5 ("Folies Bergère")❌(toInclusive = false)

Final Output

CopyEdit

{2=Crazy Horse, 3=Paradis Latin, 4=Le Lido}

Thus, the correct answer is:✅{2=Crazy Horse, 3=Paradis Latin, 4=Le Lido}

References:

Java SE 21 - TreeMap.subMap()

Java SE 21 - NavigableMap

In the provided code, four StringBuilder instances are being created using different constructors:

stringBuilder1: new StringBuilder()

This constructor creates an empty StringBuilder with an initial capacity of 16 characters.

stringBuilder2: new StringBuilder(10)

This constructor creates an empty StringBuilder with a specified initial capacity of 10 characters.

stringBuilder3: new StringBuilder("Java")

This constructor creates a StringBuilder initialized to the contents of the specified string "Java".

stringBuilder4: new StringBuilder(new char[]{'J', 'a', 'v', 'a'})

This line attempts to create a StringBuilder using a char array. However, the StringBuilder class does not have a constructor that accepts a char array directly. The available constructors are:

StringBuilder()

StringBuilder(int capacity)

StringBuilder(String str)

StringBuilder(CharSequence seq)

Since a char array does not implement the CharSequence interface, and there is no constructor that directly accepts a char array, this line will cause a compilation error.

To initialize a StringBuilder with a char array, you can convert the char array to a String first:

java

var stringBuilder4 = new StringBuilder(new String(new char[]{'J', 'a', 'v', 'a'}));

This approach utilizes the String constructor that accepts a char array, and then passes the resulting String to the StringBuilder constructor.

In Java, the Stream API provides several methods to create streams. However, not all approaches are valid.

In the provided code, we have two inner classes within the Test class:

Class A:

An inner (non-static) class.

Instances of A are associated with an instance of the enclosing Test class.

Class B:

A static nested class.

Instances of B are not associated with any instance of the enclosing Test class and can be instantiated without an instance of Test.

Evaluation of Statements:

A. A a = new A();

Invalid.Since A is a non-static inner class, it requires an instance of the enclosing class Test to be instantiated. Attempting to instantiate A without an instance of Test will result in a compilation error.

B. B b = new Test.B();

Valid.B is a static nested class and can be instantiated without an instance of Test. This syntax is correct.

C. A a = new Test.A();

Invalid.Even though A is referenced through Test, it is a non-static inner class and requires an instance of Test for instantiation. This will result in a compilation error.

D. B b = new Test().new B();

Invalid.While this syntax is used for instantiating non-static inner classes, B is a static nested class and does not require an instance of Test. This will result in a compilation error.

E. B b = new B();

Valid.Since B is a static nested class, it can be instantiated directly without referencing the enclosing class.

F. A a = new Test().new A();

Valid.This is the correct syntax for instantiating a non-static inner class. An instance of Test is created, and then an instance of A is created associated with that Test instance.

Therefore, the valid statements are B, E, and F.

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, the Test class has a static integer field count and a constructor that is declared with the synchronized modifier. In Java, the synchronized modifier can be applied to methods to control access to critical sections, but it cannot be applied directly to constructors. Attempting to declare a constructor as synchronized will result in a compilation error.

Compilation Error Details:

The Java Language Specification does not permit the use of the synchronized modifier on constructors. Therefore, the compiler will produce an error indicating that the synchronized modifier is not allowed in this context.

Correct Usage:

If you need to synchronize the initialization of instances, you can use a synchronized block within the constructor:

java

public class Test {

static int count;

Test() {

synchronized (Test.class) {

count++;

}

}

public static void main(String[] args) throws InterruptedException {

Runnable task = Test::new;

Thread t1 = new Thread(task);

Thread t2 = new Thread(task);

t1.start();

t2.start();

t1.join();

t2.join();

System.out.println(count);

}

}

In this corrected version, the synchronized block within the constructor ensures that the increment operation on count is thread-safe.

Conclusion:

The original program will fail to compile due to the illegal use of the synchronized modifier on the constructor. Therefore, the correct answer is E: Compilation fails.

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

Analyzing the thrower() Method Execution

java

int i = 0;

return i / i;

i / i evaluates to 0 / 0, whichthrows ArithmeticException (/ by zero).

Since catch (NumberFormatException e) doesnot matchArithmeticException, it is skipped.

The finally block always executes, printing:

nginx

Beaujolais Nouveau,

The exceptionpropagates backto main().

Handling the Exception in main()

java

try {

thrower();

System.out.print("Dom Pérignon, ");

} catch (Exception e) {

System.out.print("Chablis, ");

} finally {

System.out.print("Saint-Émilion");

}

Since thrower() throws ArithmeticException, it is caught by catch (Exception e).

"Chablis, "is printed.

Thefinally block always executes, printing "Saint-Émilion".

Final Output

nginx

Beaujolais Nouveau, Chablis, Saint-Émilion

Thus, the correct answer is:Beaujolais Nouveau, Chablis, Saint-Émilion

References:

Java SE 21 - Exception Handling

Java SE 21 - finally Block Execution

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.

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

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

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.

In Java, a lambda expression can be used where a target type is a functional interface. A functional interface is an interface that contains exactly one abstract method. This concept is also known as a Single Abstract Method (SAM) type.

Analyzing each interface:

Interface A: Contains a single default method ma(). Since default methods are not abstract, A has no abstract methods.

Interface B: Extends A and adds a static method mb(). Static methods are also not abstract, so B has no abstract methods.

Interface C: Extends B and declares two abstract methods: ma() (which overrides the default method from A) and mc(). Therefore, C has two abstract methods.

Interface D: Extends C and adds another abstract method md(). Thus, D has three abstract methods.

Interface E: Extends D and provides default implementations for ma(), mb(), and mc(). However, it does not provide an implementation for md(), leaving it as the only abstract method in E.

For an interface to be a functional interface, it must have exactly one abstract method. In this case, E has one abstract method (md()), so it qualifies as a functional interface. However, the question asks which interface can be the target of a lambda expression. Since E is a functional interface, it can be the target of a lambda expression.

Therefore, the correct answer is D (E).