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

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

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

(BufferedWriter writer = new BufferedWriter("file.txt") is incorrect.)

Theincorrect statementisoption Bbecause BufferedWriterdoes nothave a constructor that accepts a String (file name) directly. The correct way to use BufferedWriter is to wrap it around a FileWriter, like this:

java

try (BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"))) {

writer.write("Hello");

}

Evaluation of Other Options:

Option A (Files.write)→ Correct

Uses Files.write() to write bytes to a file.

Efficient and concise method for writing small text files.

Option C (FileOutputStream)→ Correct

Uses a FileOutputStream to write raw bytes to a file.

Works for both text and binary data.

Option D (PrintWriter)→ Correct

Uses PrintWriter for formatted text output.

Option F (FileWriter)→ Correct

Uses FileWriter to write text data.

Option E (None of the suggestions)→ Incorrect becauseoption Bis incorrect.

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.

In this code, two lists l1 and l2 are created and initialized as follows:

l1 Initialization:

Created using List.of("a", "b"), which returns an immutable list containing the elements "a" and "b".

Wrapped with new ArrayList<>(...) to create a mutable ArrayList containing the same elements.

l2 Initialization:

Created using Collections.singletonList("c"), which returns an immutable list containing the single element "c".

Wrapped with new ArrayList<>(...) to create a mutable ArrayList containing the same element.

State of Lists Before Collections.copy:

l1: ["a", "b"]

l2: ["c"]

Collections.copy(l1, l2):

The Collections.copy method copies elements from the source list (l2) into the destination list (l1). The destination list must have at least as many elements as the source list; otherwise, an IndexOutOfBoundsException is thrown.

In this case, l1 has two elements, and l2 has one element, so the copy operation is valid. After copying, the first element of l1 is replaced with the first element of l2:

l1 after copy: ["c", "b"]

l2.set(0, "d"):

This line sets the first element of l2 to "d".

l2 after set: ["d"]

Final State of Lists:

l1: ["c", "b"]

l2: ["d"]

The System.out.println(l1); statement outputs the current state of l1, which is ["c", "b"]. Therefore, the correct answer is C: [c, b].

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

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

Comprehensive and Detailed In-Depth Explanation:

Understanding Java Module Compilation (javac)

Java modules are compiled using the javac command with specific options to specify:

Where the source files are located (--module-source-path)

Where required dependencies (external modules) are located (-p / --module-path)

Where the compiled output should be placed (-d)

Breaking Down the Correct Compilation Command

css

CopyEdit

javac --module-source-path src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop

--module-source-path src → Specifies the directory where module sources are located.

-p lib/com.eiffel.membership.jar → Specifies the module path (JAR dependency in lib).

-d out → Specifies the output directory for compiled .class files.

-m com.eiffeltower.shop → Specifies the module to compile (com.eiffeltower.shop).

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

In the provided code, the class ThisCalls has two constructors:

No-Argument Constructor (ThisCalls()):

This constructor calls the boolean constructor with this(true);.

Boolean Constructor (ThisCalls(boolean flag)):

This constructor attempts to call the no-argument constructor with this();.

This setup creates a circular call between the two constructors:

The no-argument constructor calls the boolean constructor.

The boolean constructor calls the no-argument constructor.

Such a circular constructor invocation leads to a compile-time error in Java, specifically "recursiveconstructor invocation." The Java Language Specification (JLS) states:

"It is a compile-time error for a constructor to directly or indirectly invoke itself through a series of one or more explicit constructor invocations involving this."

Therefore, the code will not compile due to this recursive constructor invocation.

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

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.

In this code, the strip() method is used to remove leading and trailing whitespace from strings. The strip() method, introduced in Java 11, is Unicode-aware and removes all leading and trailing characters that are considered whitespace according to the Unicode standard.

docs.oracle.com

Analysis of Each Statement:

First Statement:

java

String s = " ";

System.out.print("[" + s.strip());

The string s contains four spaces.

Applying s.strip() removes all leading and trailing spaces, resulting in an empty string.

The output is "[" followed by the empty string, so the printed result is "[".

Second Statement:

java

s = " hello ";

System.out.print("," + s.strip());

The string s is now " hello ".

Applying s.strip() removes all leading and trailing spaces, resulting in "hello".

The output is "," followed by "hello", so the printed result is ",hello".

Third Statement:

java

s = "h i ";

System.out.print("," + s.strip() + "]");

The string s is now "h i ".

Applying s.strip() removes the trailing spaces, resulting in "h i".

The output is "," followed by "h i" and then "]", so the printed result is ",h i]".

Combined Output:

Combining all parts, the final output is:

css

[,hello,h i]

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

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

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

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, a list of integers integers is created containing the elements 0, 1, and 2. A stream is then created from this list, and the following operations are performed in sequence:

peek(System.out::print):

The peek method is an intermediate operation that allows performing an action on each element as it is encountered in the stream. In this case, System.out::print is used to print each element. However, since peek is intermediate, the printing occurs only when a terminal operation is executed.

limit(2):

The limit method is another intermediate operation that truncates the stream to contain no more than the specified number of elements. Here, it limits the stream to the first 2 elements.

forEach(i -> {}):

The forEach method is a terminal operation that performs the given action on each element of the stream. In this case, the action is an empty lambda expression (i -> {}), which does nothing for each element.

The sequence of operations can be visualized as follows:

Original Stream Elements: 0, 1, 2

After peek(System.out::print): Elements are printed as they are encountered.

After limit(2): Stream is truncated to 0, 1.

After forEach(i -> {}): No additional action; serves to trigger the processing.

Therefore, the output of the code is 01, corresponding to the first two elements of the list being printed due to the peek operation.

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.