Oracle 1Z0-830 Online Practice Questions and Exam Preparation

Oracle 1Z0-830 Online Questions & Answers

• Question 81:

  Which of the following methods of java.util.function.Predicate are default methods ?

  A. and(Predicate
  B. isEqual(Object targetRef)
  C. negate()
  D. not(Predicate
  E. or(Predicate
  F. test(T t)
  A. and(Predicate
  C. negate()
  E. or(Predicate

  ---

  Explanation

  Understanding java.util.function.Predicate

  The Predicate interface represents a function that takes 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 other)#Default method

  Combines two predicates using logical AND (andand).

  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 does not 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 target) Static method (introduced in Java 11) #

  Not a default method, since it is static.

  or(Predicate other)#Default method

  Combines two predicates using logical OR (||).

  # test(T t) Abstract method #

  Not a default method, because every predicate must implement this method .

  Thus, the correct answers are:and(Predicate other), negate(), or(Predicate other)

  References:

  Java SE 21 - Predicate Interface

  Java SE 21 - Functional Interfaces

• Question 82:

  Which of the following suggestions compile?(Choose two.)

  A. java sealed class Figure permits Rectangle {} final class Rectangle extends Figure { float length, width; }
  B. java sealed class Figure permits Rectangle {} public class Rectangle extends Figure { float length, width; }
  C. java public sealed class Figure permits Circle, Rectangle {} final sealed class Circle extends Figure { float radius; } non-sealed class Rectangle extends Figure { float length, width; }
  D. java public sealed class Figure permits Circle, Rectangle {} final class Circle extends Figure { float radius; } non-sealed class Rectangle extends Figure { float length, width; }
  A. java sealed class Figure permits Rectangle {} final class Rectangle extends Figure { float length, width; }
  D. java public sealed class Figure permits Circle, Rectangle {} final class Circle extends Figure { float radius; } non-sealed class Rectangle extends Figure { float length, width; }

  ---

  Explanation

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

  Why it compiles?

  Figure is sealed , meaning it must explicitly declare its subclasses.

  Rectangle is permitted to extend Figure and is declared final , meaning it cannot be extended further.

  This follows valid 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 does not 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 means it must have permitted subclasses , but final means it 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 is sealed , meaning it must declare its permitted subclasses (Circle and Rectangle).

  Circle is declared final , so it cannot have subclasses .

  Rectangle is declared non-sealed , meaning it can be subclassed freely.

  This correctly follows Java's sealed class rules .

  Thus, the correct answers are:A, D

  References:

  Java SE 21 - Sealed Classes

  Java SE 21 - Class Modifiers

• Question 83:

  Given:

  java

  CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();

  list.add("A");

  list.add("B");

  list.add("C");

  // Writing in one thread

  new Thread(() -> {

  list.add("D");

  System.out.println("Element added: D");

  }).start();

  // Reading in another thread

  new Thread(() -> {

  for (String element : list) {

  System.out.println("Read element: " + element);

  }

  }).start();

  What is printed?

  A. It prints all elements, including changes made during iteration.
  B. It prints all elements, but changes made during iteration may not be visible.
  C. It throws an exception.
  D. Compilation fails.
  B. It prints all elements, but changes made during iteration may not be visible.

  ---

  Explanation

  Understanding CopyOnWriteArrayList

  CopyOnWriteArrayList is a thread-safe variant of ArrayList whereall mutative operations (add, set, remove, etc.) create a new copy of the underlying array .

  This meansiterations will not reflect modifications made after the iterator was created.

  Instead of modifying the existing array, a new copy is created for modifications, ensuring that readers always see a consistent snapshot.

  Thread Execution Behavior

  Thread 1 (Writer Thread)adds "D" to the list.

  Thread 2 (Reader Thread)iterates over the list.

  The reader thread gets a snapshot of the list before "D" is added.

  The output may look like:

  mathematica

  Read element: A

  Read element: B

  Read element: C

  Element added: D

  "D" may not appear in the output of the reader threadbecause the iteration occurs on a snapshot before the modification.

  Why doesn't it print all elements including changes?

  Since CopyOnWriteArrayList does not allow changes to be visible during iteration , the reader thread will not see "D" if it started iterating before "D" was added.

  Thus, the correct answer is:"It prints all elements, but changes made during iteration may not be visible."

  References:

  Java SE 21 - CopyOnWriteArrayList

• Question 84:

  Given:

  java

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

  abc.stream()

  .forEach(x -> {

  x = x.toUpperCase();

  });

  abc.stream()

  .forEach(System.out::print);

  What is the output?

  A. abc
  B. An exception is thrown.
  C. Compilation fails.
  D. ABC
  A. abc

  ---

  Explanation

  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.

• Question 85:

  Given:

  java

  System.out.print(Boolean.logicalAnd(1 == 1, 2 < 1));

  System.out.print(Boolean.logicalOr(1 == 1, 2 < 1));

  System.out.print(Boolean.logicalXor(1 == 1, 2 < 1));

  What is printed?

  A. truetruefalse
  B. falsetruetrue
  C. truefalsetrue
  D. truetruetrue
  E. Compilation fails
  C. truefalsetrue

  ---

  Explanation

  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

• Question 86:

  Which three of the following are correct about the Java module system?

  A. Code in an explicitly named module can access types in the unnamed module.
  B. The unnamed module exports all of its packages.
  C. If a package is defined in both a named module and the unnamed module, then the package in the unnamed module is ignored.
  D. We must add a module descriptor to make an application developed using a Java version prior to SE9 run on Java 11.
  E. The unnamed module can only access packages defined in the unnamed module.
  F. If a request is made to load a type whose package is not defined in any known module, then the module system will attempt to load it from the classpath.
  B. The unnamed module exports all of its packages.
  C. If a package is defined in both a named module and the unnamed module, then the package in the unnamed module is ignored.
  F. If a request is made to load a type whose package is not defined in any known module, then the module system will attempt to load it from the classpath.

  ---

  Explanation

  The Java Platform Module System (JPMS), introduced in Java 9, modularizes the Java platform and applications. Understanding the behavior of named and unnamed modules is crucial.

  B. The unnamed module exports all of its packages.

  Correct. The unnamed module, which includes all code on the classpath, exports all of its packages. This means that any code can access the public types in these packages. However, the unnamed module cannot be explicitly required by named modules.

  C. If a package is defined in both a named module and the unnamed module, then the package in the unnamed module is ignored.

  Correct. In cases where a package is present in both a named module and the unnamed module, the version in the named module takes precedence. The package in the unnamed module is ignored to maintain module integrity and avoid conflicts.

  F. If a request is made to load a type whose package is not defined in any known module, then the module system will attempt to load it from the classpath.

  Correct. When the module system cannot find a requested type in any known module, it defaults to searching the classpath (i.e., the unnamed module) to locate the type.

  Incorrect Options:

  A. Code in an explicitly named module can access types in the unnamed module. Incorrect. Named modules cannot access types in the unnamed module. The unnamed module can read from named modules, but the reverse is not allowed to ensure strong encapsulation.

  D. We must add a module descriptor to make an application developed using a Java version prior to SE9 run on Java 11.

  Incorrect. Adding a module descriptor (module-info.java) is not mandatory for applications developed before Java 9 to run on Java 11. Such applications can run in the unnamed module without modification.

  E. The unnamed module can only access packages defined in the unnamed module.

  Incorrect. The unnamed module can access all packages exported by all named modules, in addition to its own packages.

• Question 87:

  Given:

  java

  public class Test {

  public static void main(String[] args) throws IOException {

  Path p1 = Path.of("f1.txt");

  Path p2 = Path.of("f2.txt");

  Files.move(p1, p2);

  Files.delete(p1);

  }

  }

  In which case does the given program throw an exception?

  A. Neither files f1.txt nor f2.txt exist
  B. Both files f1.txt and f2.txt exist
  C. An exception is always thrown
  D. File f2.txt exists while file f1.txt doesn't
  E. File f1.txt exists while file f2.txt doesn't
  C. An exception is always thrown

  ---

  Explanation

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

• Question 88:

  Which of the following statements are correct?

  A. You can use 'private' access modifier with all kinds of classes
  B. You can use 'protected' access modifier with all kinds of classes
  C. You can use 'public' access modifier with all kinds of classes
  D. You can use 'final' modifier with all kinds of classes
  E. None
  E. None

  ---

  Explanation

  1.private Access Modifier

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

  Top-level classes cannot be private.

  Example of invalid use:

  java

  private class MyClass {} // Compilation error

  Example of valid use (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 of invalid use:

  java

  protected class MyClass {} // Compilation error

  Example of valid use (for methods/fields):

  java

  class Parent {

  protected void display() {}

  }

  3.public Access Modifier

  A top-level class can be public , but only one public class per file is allowed .

  Example of valid use:

  java

  public class MyClass {}

  Example of invalid use:

  java

  public class A {}

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

  4.final Modifier

  final can be used with classes, but not all kinds of classes .

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

  Example of invalid use:

  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

• Question 89:

  Which of the following isn't a correct way to write a string to a file?

  A. java Path path = Paths.get("file.txt"); byte[] strBytes = "Hello".getBytes(); Files.write(path, strBytes);
  B. java try (BufferedWriter writer = new BufferedWriter("file.txt")) { writer.write("Hello"); }
  C. java try (FileOutputStream outputStream = new FileOutputStream("file.txt")) { byte[] strBytes = "Hello".getBytes(); outputStream.write(strBytes); }
  D. java try (PrintWriter printWriter = new PrintWriter("file.txt")) { printWriter.printf("Hello %s", "James"); }
  E. None of the suggestions
  F. java try (FileWriter writer = new FileWriter("file.txt")) { writer.write("Hello"); }
  B. java try (BufferedWriter writer = new BufferedWriter("file.txt")) { writer.write("Hello"); }

  ---

  Explanation

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

  The incorrect statement option B is because BufferedWriter does not have 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 because option B is incorrect.

• Question 90:

  Given:

  java

  interface A {

  default void ma() {

  }

  }

  interface B extends A {

  static void mb() {

  }

  }

  interface C extends B {

  void ma();

  void mc();

  }

  interface D extends C {

  void md();

  }

  interface E extends D {

  default void ma() {

  }

  default void mb() {

  }

  default void mc() {

  }

  }

  Which interface can be the target of a lambda expression?

  A. None of the above
  B. C
  C. A
  D. E
  F. B
  G. D
  A. None of the above

  ---

  Explanation

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