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

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

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

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, two LocalDate instances are created representing May 4, 2023, and May 4, 2024. The Period.between() method is used to calculate the period between these two dates, and the Duration.between() method is used to calculate the duration between them.

Period Calculation:

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

Duration Calculation:

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

Exception Details:

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

Correct Usage:

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

java

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

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

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

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

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

Conclusion:

The output of the given code will be:

pgsql

P1Y

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

Therefore, the correct answer is D:

nginx

P1Y

UnsupportedTemporalTypeException

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

In this code, two StringBuffer objects, us and uk, are created with the values "US" and "UK", respectively. A stream is then created from these objects using Stream.of(us, uk).

The collect method is used with Collectors.joining("-", "=", ""). The joining collector concatenates the elements of the stream into a single String with the following parameters:

Delimiter ("-"):Inserted between each element.

Prefix ("="):Inserted at the beginning of the result.

Suffix (""):Inserted at the end of the result.

Therefore, the elements "US" and "UK" are concatenated with "-" between them, resulting in "US-UK". The prefix "=" is added at the beginning, resulting in the final output =US-UK.

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

Correct module descriptor file name

A module declaration must be placed inside a file namedmodule-info.java.

The incorrect filename module-info.perfumery.shop.javais invalid(Option A).

The incorrect filename module.javais invalid(Option C).

Correct module declaration

The module declaration must match the name of the module (perfumery.shop).

The requires perfumery.provider; directive specifies that perfumery.shop depends on perfumery.provider.

The exports perfumery.shop.eaudeparfum; statement allows the perfumery.shop.eaudeparfum package to beaccessible by other modules.

The incorrect syntax exports perfumery.shop.eaudeparfum.*; in Option A isinvalid, as wildcards (*) arenot allowedin module exports.

Thus, the correct answer is:File name: module-info.java

References:

Java SE 21 - Modules

Java SE 21 - module-info.java File

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.

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

1. private Access Modifier

The private access modifiercan only be used for inner classes(nested classes).

Top-level classes cannot be private.

Example ofinvaliduse:

java

private class MyClass {} // Compilation error

Example ofvaliduse (for inner class):

java

class Outer {

private class Inner {}

}

2. protected Access Modifier

Top-level classes cannot be protected.

protectedonly applies to members (fields, methods, and constructors).

Example ofinvaliduse:

java

protected class MyClass {} // Compilation error

Example ofvaliduse (for methods/fields):

java

class Parent {

protected void display() {}

}

3. public Access Modifier

Atop-level class can be public, butonly one public class per file is allowed.

Example ofvaliduse:

java

public class MyClass {}

Example ofinvaliduse:

java

public class A {}

public class B {} // Compilation error: Only one public class per file

4. final Modifier

finalcan be used with classes, but not all kinds of classes.

Interfaces cannot be final, because they are meant to be implemented.

Example ofinvaliduse:

java

final interface MyInterface {} // Compilation error

Thus,none of the statements are fully correct, making the correct answer:None

References:

Java SE 21 - Access Modifiers

Java SE 21 - Class Modifiers

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.

java.io.Console is used for interactive input from the console.

Existing Methods in java.io.Console

reader() → Returns a Reader object.

readLine() → Reads a line of text from the console.

readLine(String fmt, Object... args) → Reads a formatted line.

readPassword() → Reads a password, returning a char[].

readPassword(String fmt, Object... args) → Reads a formatted password.

read() Does Not Exist

Consoledoes not have a read() method.

If character-by-character reading is required, use:

java

Console console = System.console();

Reader reader = console.reader();

int c = reader.read(); // Reads one character

read() is available inReader, butnot in Console.

Thus, the correct answer is:read() does not exist.

References:

Java SE 21 - Console API

Java SE 21 - Reader API

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

❌Compilation Fails

frenchAuthors is declared as List,notArrayList.

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

Fix:

java

Map> authorsMap1 = new HashMap<>();

authorsMap1.put("FR", frenchAuthors);

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

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

❌Compilation Fails

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

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

Fix:Remove the wildcard:

java

Map> authorsMap2 = new HashMap<>();

authorsMap2.put("FR", frenchAuthors);

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

Compiles Successfully

The var keyword allows the compiler to infer the type.

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

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

Compiles Successfully

Valid declaration:HashMap can be assigned to Map.

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

Correct syntax:

java

Map> authorsMap4 = new HashMap>();

authorsMap4.put("FR", frenchAuthors);

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

Compiles Successfully

HashMap> isa valid instantiation.

Correct usage:

java

Map> authorsMap5 = new HashMap<>();

authorsMap5.put("FR", frenchAuthors);

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

References:

Java SE 21 - Generics and Type Inference

Java SE 21 - var Keyword

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

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

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

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

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

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

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

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

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

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

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