1z0-830 Sample Questions Answers

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

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

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

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, 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 program, the following operations are performed:

Paths Initialization:

Path p1 is set to "f1.txt".

Path p2 is set to "f2.txt".

File Move Operation:

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

File Delete Operation:

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

Analysis:

If f1.txt Does Not Exist:

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

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

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

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

If Both f1.txt and f2.txt Exist:

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

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

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

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

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

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

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

java

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

List upperCaseAbc = abc.stream()

map(String::toUpperCase)

collect(Collectors.toList());

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

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

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

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

Why does the compilation fail?

TheJava switch statement does not support primitive type pattern matchingin switch expressions as of Java 21.

The case pattern case int i -> "integer"; isinvalidbecausepattern matching with primitive types (like int or long) is not yet supported in switch statements.

The error occurs at case int i -> "integer";, leading to acompilation failure.

Correcting the Code

Since myVar is of type Object,autoboxing converts 0 into an Integer.

To make the code compile, we should use Integer instead of int:

java

Object myVar = 0;

String print = switch (myVar) {

case Integer i -> "integer";

case Long l -> "long";

case String s -> "string";

default -> "";

};

System.out.println(print);

Output:

bash

integer

Thus, the correct answer is:Compilation fails.

References:

Java SE 21 - Pattern Matching for switch

Java SE 21 - switch Expressions

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.

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

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

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

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

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

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