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

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.

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 DoubleSummaryStatistics class in Java is part of the java.util package and is used to collect and summarize statistics for a stream of double values. Let's analyze how the methods work:

Initialization and Data Insertion

stats1.accept(4.5); → Adds 4.5 to stats1.

stats1.accept(6.0); → Adds 6.0 to stats1.

stats2.accept(3.0); → Adds 3.0 to stats2.

stats2.accept(8.5); → Adds 8.5 to stats2.

Combining stats1 and stats2

stats1.combine(stats2); merges stats2 into stats1, resulting in one statistics summary containing all values {4.5, 6.0, 3.0, 8.5}.

Calculating Output Values

Sum= 4.5 + 6.0 + 3.0 + 8.5 = 22.0

Max= 8.5

Average= (22.0) / 4 = 5.5

Thus, the output is:

yaml

Sum: 22.0, Max: 8.5, Avg: 5.5

References:

Java SE 21 & JDK 21 - DoubleSummaryStatistics

Java SE 21 - Streams and Statistical Operations

The var keyword and identifier rules:

The var keyword is used for local variable type inference introduced inJava 10.

However,Java does not allow _ (underscore) as an identifiersinceJava 9.

If we try to use _ as a variable name, the compiler will throw an error:

pgsql

error: as of release 9, '_' is a keyword, and may not be used as an identifier

The $ symbol as an identifier:

The $ characteris a valid identifierin Java.

However, since _ is not allowed, the codefails to compile before even reaching $.

Thus,the correct answer is "Compilation fails."

References:

Java SE 21 - var Local Variable Type Inference

Java SE 9 - Restrictions on _ Identifier

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.

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

Understanding Variable Assignments

java

Integer frenchRevolution = 1789;

Object o1 = new String("1789");

Object o2 = frenchRevolution;

frenchRevolution = null;

frenchRevolution is an Integer with value1789.

o1 is aString with value "1789".

o2 storesa reference to frenchRevolution, which is an Integer (1789).

frenchRevolution = null;only nullifies the reference, but o2 still holds the Integer 1789.

Calling toString() on o2

java

Object o3 = o2.toString();

o2 refers to an Integer (1789).

Integer.toString() returns theString representation "1789".

o3 is assigned "1789" (String).

Evaluating o1.equals(o3)

java

System.out.println(o1.equals(o3));

o1.equals(o3) isequivalent to:

java

"1789".equals("1789")

Since both areequal strings, the output is:

arduino

true

Thus, the correct answer is:true

References:

Java SE 21 - Integer.toString()

Java SE 21 - String.equals()

In this code, a HashMap is instantiated using the var keyword:

java

var ceo = new HashMap<>();

The diamond operator <> is used without explicit type arguments. While the diamond operatorallows the compiler to infer types in many cases, when using var, the compiler requires explicit type information to infer the variable's type.

Therefore, the code will not compile because the compiler cannot infer the type of the HashMap when both var and the diamond operator are used without explicit type parameters.

To fix this issue, provide explicit type parameters when creating the HashMap:

java

var ceo = new HashMap();

Alternatively, you can specify the variable type explicitly:

java

Map

contentReference[oaicite:0]{index=0}

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.

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

In Java, FileOutputStream and ObjectOutputStream are used for writing data to files, but they have different purposes and methods. Let's analyze each statement:

fos.write("Today");

The FileOutputStream class is designed to write raw byte streams to files. The write method in FileOutputStream expects a parameter of type int or byte[]. Since "Today" is a String, passing it directly to fos.write("Today"); will cause a compilation error because there is no write method in FileOutputStream that accepts a String parameter.

fos.writeObject("Today");

The FileOutputStream class does not have a method named writeObject. The writeObject method is specific to ObjectOutputStream. Therefore, attempting to call fos.writeObject("Today"); will result in a compilation error.

oos.write("Today");

The ObjectOutputStream class is used to write objects to an output stream. However, it does not have a write method that accepts a String parameter. The available write methods in ObjectOutputStream are for writing primitive data types and objects. Therefore, oos.write("Today"); will cause a compilation error.

oos.writeObject("Today");

The ObjectOutputStream class provides the writeObject method, which is used to serialize objects and write them to the output stream. Since String implements the Serializable interface, "Today" can be serialized. Therefore, oos.writeObject("Today"); is valid and compiles successfully.

In summary, the only statement that compiles without errors is oos.writeObject("Today");.

References:

Java SE 21 & JDK 21 - ObjectOutputStream

Java SE 21 & JDK 21 - FileOutputStream

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

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

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 Java, the ConcurrentHashMap class provides several constructors that allow for the customization of its initial capacity, load factor, and concurrency level. To configure a ConcurrentHashMap with an initial capacity of 42 and a concurrency level of 10, you can use the following constructor:

java

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)

Parameters:

initialCapacity: The initial capacity of the hash table. This is the number of buckets that the hash table will have when it is created. In this case, it is set to 42.

loadFactor: A measure of how full the hash table is allowed to get before it is resized. The default value is 0.75, but in this case, it is set to 0.88.

concurrencyLevel: The estimated number of concurrently updating threads. This is used as a hint for internal sizing. In this case, it is set to 10.

Therefore, to create a ConcurrentHashMap with an initial capacity of 42, a load factor of 0.88, and a concurrency level of 10, you can use the following code:

java

var concurrentHashMap = new ConcurrentHashMap<>(42, 0.88f, 10);

Option Evaluations:

A. var concurrentHashMap = new ConcurrentHashMap(42);: This constructor sets the initial capacity to 42 but uses the default load factor (0.75) and concurrency level (16). It does not meet the requirement of setting the concurrency level to 10.

B. None of the suggestions.: This is incorrect because option E provides the correct configuration.

C. var concurrentHashMap = new ConcurrentHashMap();: This uses the default constructor, which sets the initial capacity to 16, the load factor to 0.75, and the concurrency level to 16. It does not meet the specified requirements.

D. var concurrentHashMap = new ConcurrentHashMap(42, 10);: This constructor sets the initial capacity to 42 and the load factor to 10, which is incorrect because the load factor should be a float value between 0 and 1.

E. var concurrentHashMap = new ConcurrentHashMap(42, 0.88f, 10);: This correctly sets the initial capacity to 42, the load factor to 0.88, and the concurrency level to 10, meeting all the specified requirements.

Therefore, the correct answer is option E.

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

Understanding java.util.function.Predicate<T>

The Predicate interface represents a function thattakes an input and returns a boolean(true or false).

It is often used for filtering operations in functional programming and streams.

Analyzing the Methods:

and(Predicate<? super T> other)→Default method

Combines two predicates usinglogical AND(&&).

java

Predicate startsWithA = s -> s.startsWith("A");

Predicate hasLength3 = s -> s.length() == 3;

Predicate combined = startsWithA.and(hasLength3);

❌isEqual(Object targetRef)→Static method

Not a default method, because it doesnot operate on an instance.

java

Predicate isEqualToHello = Predicate.isEqual("Hello");

negate()→Default method

Negates a predicate (! operator).

java

Predicate notEmpty = s -> !s.isEmpty();

Predicate isEmpty = notEmpty.negate();

❌not(Predicate<? super T> target)→Static method (introduced in Java 11)

Not a default method, since it is static.

or(Predicate<? super T> other)→Default method

Combines two predicates usinglogical OR(||).

❌test(T t)→Abstract method

Not a default method, because every predicatemust implement this method.

Thus, the correct answers are:and(Predicate<? super T> other), negate(), or(Predicate<? super T> other)

References:

Java SE 21 - Predicate Interface

Java SE 21 - Functional Interfaces

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

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.

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 Java's java.nio.file package, the Path class represents a file path in a file system. The Paths.get(String first, String... more) method is used to create a Path instance by converting a path string or URI.

In the provided code snippet, the Path object path is created with the string "C:\\home\\joe\\foo". This represents an absolute path on a Windows system.

The getName(int index) method of the Path class returns a name element of the path as a Path object. The index is zero-based, where index 0 corresponds to the first element in the path's name sequence. It's important to note that the root component (e.g., "C:\" on Windows) is not considered a name element and is not included in this sequence.

Therefore, for the path "C:\\home\\joe\\foo":

Root Component:"C:\"

Name Elements:

Index 0: "home"

Index 1: "joe"

Index 2: "foo"

When path.getName(0) is called, it returns the first name element, which is "home". Thus, the output of the System.out.println statement is home.