1z0-830 Dumps with Practice Exam Questions Answers

In this code, three static methods from the Boolean class are used: logicalAnd, logicalOr, and logicalXor. Each method takes two boolean arguments and returns a boolean result based on the respective logical operation.

Evaluation of Each Statement:

Boolean.logicalAnd(1 == 1, 2 < 1)

Operands:

1 == 1 evaluates to true.

2 < 1 evaluates to false.

Operation:

Boolean.logicalAnd(true, false) performs a logical AND operation.

The result is false because both operands must be true for the AND operation to return true.

Output:

System.out.print(false); prints false.

Boolean.logicalOr(1 == 1, 2 < 1)

Operands:

1 == 1 evaluates to true.

2 < 1 evaluates to false.

Operation:

Boolean.logicalOr(true, false) performs a logical OR operation.

The result is true because at least one operand is true.

Output:

System.out.print(true); prints true.

Boolean.logicalXor(1 == 1, 2 < 1)

Operands:

1 == 1 evaluates to true.

2 < 1 evaluates to false.

Operation:

Boolean.logicalXor(true, false) performs a logical XOR (exclusive OR) operation.

The result is true because exactly one operand is true.

Output:

System.out.print(true); prints true.

Combined Output:

Combining the outputs from each statement, the final printed result is:

nginx

falsetruetrue

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

Option A (sealed class Figure permits Rectangle {} and final class Rectangle extends Figure {}) - Valid

Why it compiles?

Figure issealed, meaning itmust explicitly declareits subclasses.

Rectangle ispermittedto extend Figure and isdeclared final, meaning itcannot be extended further.

This followsvalid sealed class rules.

Option B (sealed class Figure permits Rectangle {} and public class Rectangle extends Figure {}) -❌Invalid

Why it fails?

Rectangle extends Figure, but it doesnot specify if it is sealed, final, or non-sealed.

Fix:The correct declaration must be one of the following:

java

final class Rectangle extends Figure {} // OR

sealed class Rectangle permits OtherClass {} // OR

non-sealed class Rectangle extends Figure {}

Option C (final sealed class Circle extends Figure {}) -❌Invalid

Why it fails?

A class cannot be both final and sealedat the same time.

sealed meansit must have permitted subclasses, but final meansit cannot be extended.

Fix:Change final sealed to just final:

java

final class Circle extends Figure {}

Option D (public sealed class Figure permits Circle, Rectangle {} with final class Circle and non-sealed class Rectangle) - Valid

Why it compiles?

Figure issealed, meaning it mustdeclare its permitted subclasses(Circle and Rectangle).

Circle is declaredfinal, so itcannot have subclasses.

Rectangle is declarednon-sealed, meaningit can be subclassedfreely.

This correctly followsJava's sealed class rules.

Thus, the correct answers are:A, D

References:

Java SE 21 - Sealed Classes

Java SE 21 - Class Modifiers

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

In this code, two Optional objects are created:

o1 is an empty Optional.

o2 is an Optional containing the integer 1.

A stream is created from o1 and o2. The filter method retains only the Optional instances that are present (i.e., non-empty). This results in a stream containing only o2.

The findAny method returns an Optional describing some element of the stream, or an empty Optional if the stream is empty. Since the stream contains o2, findAny returns Optional[Optional[1]].

The flatMap method is then used to flatten this nested Optional. It applies the provided mapping function (o -> o) to the value, resulting in Optional[1].

Finally, o3.orElse(2) returns the value contained in o3 if it is present; otherwise, it returns 2. Since o3 contains 1, the output is 1.