Free Oracle 1z0-830 Practice Exam with Questions & Answers

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

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

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,protected memberscan only be accessedwithin the same packageor bysubclasses, but there is a key restriction:

A protected member of a superclass is only accessible through inheritance in a subclass but not through an instance of the superclass that is declared outside the package.

Why does compilation fail?

In the MiniVan class, the following line causes acompilation error:

java

Car car = new Car();

car.brand = "Peugeot 807";

The brand field isprotectedin Car, which means it isnot accessible via an instance of Car outside the vehicule.parent package.

Even though MiniVan extends Car, itcannotaccess brand using a Car instance (car.brand) because car is declared as an instance of Car, not MiniVan.

The correct way to access brand inside MiniVan is through inheritance (this.brand or super.brand).

Corrected Code

If we change the MiniVan class like this, it will compile and run successfully:

java

package vehicule.child;

import vehicule.parent.Car;

public class MiniVan extends Car {

public static void main(String[] args) {

MiniVan minivan = new MiniVan(); // Access via inheritance

minivan.brand = "Peugeot 807";

System.out.println(minivan.brand);

}

}

This would output:

nginx

Peugeot 807

Key Rule from Oracle Java Documentation

Protected membersof a class are accessible withinthe same packageand tosubclasses, butonly through inheritance, not through a superclass instance declared outside the package.

References:

Java SE 21 & JDK 21 - Controlling Access to Members of a Class

Java SE 21 & JDK 21 - Inheritance Rules

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

In this code, an ArrayDeque named deque is created, and the integers 1 and 2 are added to it using the offer method. The offer method inserts the specified element at the end of the deque.

State of deque after offers:[1, 2]

The peek method retrieves, but does not remove, the head of the deque, returning 1. Therefore, i1 is assigned the value 1.

State of deque after peek:[1, 2]

Value of i1:1

The poll method retrieves and removes the head of the deque, returning 1. Therefore, i2 is assigned the value 1.

State of deque after poll:[2]

Value of i2:1

Another peek operation retrieves the current head of the deque, which is now 2, without removing it. Therefore, i3 is assigned the value 2.

State of deque after second peek:[2]

Value of i3:2

The System.out.println statement then outputs the values of i1, i2, and i3, resulting in 1 1 2.