Oracle 1Z0-830 Online Practice Questions and Exam Preparation

Oracle 1Z0-830 Online Questions & Answers

• Question 1:

  Which of the following text block declarations compiles?

  A. String s = """Hello "Java";""";
  B. String s = """Hello Java""";
  C. String s = """Hello Java";
  D. String s = """"Hello Java"""";
  B. String s = """Hello Java""";

  ---

  Explanation

  A text block starts and ends with triple quotes """. Option B uses correct delimiters and line breaks; the others have mismatched or extra quotes.

• Question 2:

  Given:

  java

  public static void main(String[] args) {

  try {

  throw new IOException();

  } catch (IOException e) {

  throw new RuntimeException();

  } finally {

  throw new ArithmeticException();

  }

  }

  What is the output?

  A. Compilation fails
  B. IOException
  C. RuntimeException
  D. ArithmeticException
  D. ArithmeticException

  ---

  Explanation

  In this code, the try block throws an IOException. The catch block catches this exception and throws a new RuntimeException. Regardless of exceptions thrown in the try or catch blocks, the finally block is always executed. In this case, the finally block throws an ArithmeticException.

  When an exception is thrown in a finally block, it overrides any previous exceptions that were thrown in the try or catch blocks. Therefore, the ArithmeticException thrown in the finally block is the exception that propagates out of the method. As a result, the program terminates with an ArithmeticException.

• Question 3:

  Which of the following does not exist?

  A. BooleanSupplier
  B. DoubleSupplier
  C. LongSupplier
  D. Supplier
  E. BiSupplier
  F. They all exist.
  E. BiSupplier

  ---

  Explanation

  1.Understanding Supplier Functional Interfaces

  The Supplier interface is part of java.util.function and provides valueswithout taking any arguments .

  Java also provides primitive specializations of Supplier:

  BooleanSupplier# Returns a boolean. Exists

  DoubleSupplier# Returns a double. Exists

  LongSupplier# Returns a long. Exists

  Supplier# Returns a generic T. Exists

  2.What about BiSupplier?

  There is no BiSupplier in Java.

  In Java, suppliers do not take arguments , so a bi-supplier does not exist.

  If you need a function that takes two arguments and returns a value , use BiFunction.

  Thus, the correct answer is:BiSupplier does not exist.

  References:

  Java SE 21 - Supplier

  Java SE 21 - Functional Interfaces

• Question 4:

  Given: java

  public class OuterClass {

  String outerField = "Outer field";

  class InnerClass {

  void accessMembers() {

  System.out.println(outerField);

  }

  }

  public static void main(String[] args) {

  System.out.println("Inner class:");

  System.out.println("------------");

  OuterClass outerObject = new OuterClass();

  InnerClass innerObject = new InnerClass(); // n1

  innerObject.accessMembers(); // n2

  }

  }

  What is printed?

  A. markdown Inner class: Outer field
  B. Nothing
  C. An exception is thrown at runtime.
  D. Compilation fails at line n1.
  E. Compilation fails at line n2.
  D. Compilation fails at line n1.

  ---

  Explanation

  Understanding Inner Classes in Java

  An inner class (non-static nested class)requires an instance of the outer class before it can be instantiated.

  Incorrect instantiationof the inner class at n1:

  java

  InnerClass innerObject = new InnerClass(); // Compilation error

  Since InnerClass is a non-static inner class, it must be created from an instance of OuterClass .

  Correct Way to Instantiate the Inner Class

  java

  OuterClass outerObject = new OuterClass();

  OuterClass.InnerClass innerObject = outerObject.new InnerClass(); // Correct

  This correctly associates the inner class with an instance of OuterClass.

  Why Does Compilation Fail?

  The error occurs at line n1 because InnerClass is being instantiated incorrectly .

  Thus, the correct answer is:Compilation fails at line n1.

  References:

  Java SE 21 - Nested and Inner Classes Java SE 21 - Accessing Outer Class Members

• Question 5:

  Given:

  java

  Object myVar = 0;

  String print = switch (myVar) {

  case int i -> "integer";

  case long l -> "long";

  case String s -> "string";

  default -> "";

  };

  System.out.println(print);

  What is printed?

  A. integer
  B. long
  C. string
  D. nothing
  E. It throws an exception at runtime.
  F. Compilation fails.
  F. Compilation fails.

  ---

  Explanation

  Why does the compilation fail?

  The Java switch statement does not support primitive type pattern matching in switch expressions as of Java 21. The case pattern case int i -> "integer"; is invalid because pattern 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 a compilation 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

• Question 6:

  Given:

  java

  void verifyNotNull(Object input) {

  boolean enabled = false;

  assert enabled = true;

  assert enabled;

  System.out.println(input.toString());

  assert input != null;

  }

  When does the given method throw a NullPointerException?

  A. A NullPointerException is never thrown
  B. Only if assertions are enabled and the input argument is null
  C. Only if assertions are disabled and the input argument is null
  D. Only if assertions are enabled and the input argument isn't null
  E. Only if assertions are disabled and the input argument isn't null
  C. Only if assertions are disabled and the input argument is null

  ---

  Explanation

  In the verifyNotNull method, the following operations are performed:

  Assertion to Enable Assertions:

  java

  boolean enabled = false;

  assert enabled = true;

  assert enabled;

  The variable enabled is initially set to false.

  The first assertion assert enabled = true; assigns true to enabled if assertions are enabled. If assertions are disabled, this assignment does not occur.

  The second assertion assert enabled; checks if enabled is true. If assertions are enabled and the previous assignment occurred, this assertion passes. If assertions are disabled, this assertion is ignored.

  Dereferencing the input Object:

  java

  System.out.println(input.toString());

  This line attempts to call the toString() method on the input object. If input is null, this will throw a NullPointerException.

  Assertion to Check input for null:

  java

  assert input != null;

  This assertion checks that input is not null. If input is null and assertions are enabled, this assertion will fail, throwing an AssertionError. If assertions are disabled, this assertion is ignored.

  Analysis:

  If Assertions Are Enabled:

  The enabled variable is set to true by the first assertion, and the second assertion passes.

  If input is null, calling input.toString() will throw a NullPointerException before the final assertion is reached.

  If input is not null, input.toString() executes without issue, and the final assertion assert input != null; passes.

  If Assertions Are Disabled:

  The enabled variable remains false, but the assertions are ignored, so this has no effect.

  If input is null, calling input.toString() will throw a NullPointerException.

  If input is not null, input.toString() executes without issue.

  Conclusion:

  A NullPointerException is thrown if input is null, regardless of whether assertions are enabled or disabled.

  Therefore, the correct answer is:

  C. Only if assertions are disabled and the input argument is null

• Question 7:

  How would you create a ConcurrentHashMap configured to allow a maximum of 10 concurrent writer threads and an initial capacity of 42? Which of the following options meets this requirement?

  A. var concurrentHashMap = new ConcurrentHashMap(42);
  B. None of the suggestions.
  C. var concurrentHashMap = new ConcurrentHashMap();
  D. var concurrentHashMap = new ConcurrentHashMap(42, 10);
  E. var concurrentHashMap = new ConcurrentHashMap(42, 0.88f, 10);
  E. var concurrentHashMap = new ConcurrentHashMap(42, 0.88f, 10);

  ---

  Explanation

  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.

• Question 8:

  Given:

  var list = List.of(1,2,3,4,5);

  System.out.println(list.stream().dropWhile(i -> i < 3)

  .takeWhile(i -> i < 5)

  .toList());

  What is printed?

  A. [3, 4]
  B. [1, 2, 3, 4]
  C. [4, 5]
  D. []
  A. [3, 4]

  ---

  Explanation

  dropWhile(i < 3) skips 1 and 2, leaving [3, 4, 5]; takeWhile(i < 5) then takes 3 and 4 until predicate fails. Final list [3, 4].

• Question 9:

  Given:

  java

  public class Test {

  class A {

  }

  static class B { } public static void main(String[] args) { // Insert here } } Which three of the following are valid statements when inserted into the given program?

  A. A a = new A();
  B. B b = new Test.B();
  C. A a = new Test.A();
  D. B b = new Test().new B();
  E. B b = new B();
  F. A a = new Test().new A();
  B. B b = new Test.B();
  E. B b = new B();
  F. A a = new Test().new A();

  ---

  Explanation

  In the provided code, we have two inner classes within the Test class:

  Class A:

  An inner (non-static) class.

  Instances of A are associated with an instance of the enclosing Test class.

  Class B:

  A static nested class.

  Instances of B are not associated with any instance of the enclosing Test class and can be instantiated without an instance of Test.

  Evaluation of Statements:

  A. A a = new A();

  Invalid.Since A is a non-static inner class, it requires an instance of the enclosing class Test to be instantiated. Attempting to instantiate A without an instance of Test will result in a compilation error.

  B. B b = new Test.B();

  Valid.B is a static nested class and can be instantiated without an instance of Test. This syntax is correct.

  C. A a = new Test.A();

  Invalid.Even though A is referenced through Test, it is a non-static inner class and requires an instance of Test for instantiation. This will result in a compilation error.

  D. B b = new Test().new B();

  Invalid.While this syntax is used for instantiating non-static inner classes, B is a static nested class and does not require an instance of Test. This will result in a compilation error.

  E. B b = new B();

  Valid.Since B is a static nested class, it can be instantiated directly without referencing the enclosing class.

  F. A a = new Test().new A();

  Valid.This is the correct syntax for instantiating a non-static inner class. An instance of Test is created, and then an instance of A is created associated with that Test instance.

  Therefore, the valid statements are B, E, and

  F.

• Question 10:

  Given:

  java

  ExecutorService service = Executors.newFixedThreadPool(2);

  Runnable task = () -> System.out.println("Task is complete");

  service.submit(task);

  service.shutdown();

  service.submit(task);

  What happens when executing the given code fragment?

  A. It prints "Task is complete" once and throws an exception.
  B. It prints "Task is complete" twice and throws an exception.
  C. It exits normally without printing anything to the console.
  D. It prints "Task is complete" twice, then exits normally.
  E. It prints "Task is complete" once, then exits normally.
  A. It prints "Task is complete" once and throws an exception.

  ---

  Explanation

  In this code, an ExecutorService is created with a fixed thread pool of size 2 using Executors. newFixedThreadPool(2). A Runnable task is defined to print "Task is complete" to the console.

  The sequence of operations is as follows:

  service.submit(task);

  This submits the task to the executor service for execution. Since the thread pool has a size of 2 and no other tasks are running, this task will be executed promptly, printing "Task is complete" to the console.

  service.shutdown();

  This initiates an orderly shutdown of the executor service. In this state, the service stops accepting new tasks