Oracle 1Z0-830 Online Practice Questions and Exam Preparation

Oracle 1Z0-830 Online Questions & Answers

• Question 91:

  A module com.eiffeltower.shop with the related sources in the src directory.

  That module requires com.eiffeltower.membership, available in a JAR located in the lib directory.

  What is the command to compile the module com.eiffeltower.shop?

  A. bash CopyEdit javac -source src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop
  B. css CopyEdit javac --module-source-path src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop
  C. css CopyEdit javac --module-source-path src -p lib/com.eiffel.membership.jar -s out -m com.eiffeltower.shop
  D. css CopyEdit javac -path src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop
  B. css CopyEdit javac --module-source-path src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop

  ---

  Explanation

  Comprehensive and Detailed In-Depth Explanation:

  Understanding Java Module Compilation (javac)

  Java modules are compiled using the javac command with specific options to specify:

  Where the source files are located (--module-source-path)

  Where required dependencies (external modules) are located (-p / --module-path)

  Where the compiled output should be placed (-d)

  Breaking Down the Correct Compilation Command

  css

  CopyEdit

  javac --module-source-path src -p lib/com.eiffel.membership.jar -d out -m com.eiffeltower.shop

  --module-source-path src # Specifies the directory where module sources are located.

  -p lib/com.eiffel.membership.jar # Specifies the module path (JAR dependency in lib).

  -d out # Specifies the output directory for compiled .class files.

  -m com.eiffeltower.shop # Specifies the module to compile (com.eiffeltower.shop).

• Question 92:

  Given:

  java

  DoubleStream doubleStream = DoubleStream.of(3.3, 4, 5.25, 6.66); Predicate doublePredicate = d -> d < 5;

  System.out.println(doubleStream.anyMatch(doublePredicate));

  What is printed?

  A. Compilation fails
  B. true
  C. false
  D. An exception is thrown at runtime
  E. 3.3
  A. Compilation fails

  ---

  Explanation

  In this code, there is a type mismatch between the DoubleStream and the Predicate.

  DoubleStream: A sequence of primitive double values.

  Predicate: A functional interface that operates on objects of type Double (the wrapper class), not on primitive double values.

  The DoubleStream class provides a method anyMatch(DoublePredicate predicate), where DoublePredicate is a functional interface that operates on primitive double values. However, in the code, a Predicate is used instead of a

  DoublePredicate. This mismatch leads to a compilation error because anyMatch cannot accept a Predicate when working with a DoubleStream.

  To correct this, the predicate should be defined as a DoublePredicate to match the primitive double type:

  java

  DoubleStream doubleStream = DoubleStream.of(3.3, 4, 5.25, 6.66);

  DoublePredicate doublePredicate = d -> d < 5;

  System.out.println(doubleStream.anyMatch(doublePredicate));

  With this correction, the code will compile and print true because there are elements in the stream (e.g., 3.3 and 4.0) that are less than 5.

• Question 93:

  Given:

  java

  Period p = Period.between(

  LocalDate.of(2023, Month.MAY, 4),

  LocalDate.of(2024, Month.MAY, 4));

  System.out.println(p);

  Duration d = Duration.between(

  LocalDate.of(2023, Month.MAY, 4),

  LocalDate.of(2024, Month.MAY, 4));

  System.out.println(d);

  What is the output?

  A. P1Y PT8784H
  B. PT8784H P1Y
  C. UnsupportedTemporalTypeException
  D. P1Y UnsupportedTemporalTypeException
  D. P1Y UnsupportedTemporalTypeException

  ---

  Explanation

  In this code, two LocalDate instances are created representing May 4, 2023, and May 4, 2024. The Period. between() method is used to calculate the period between these two dates, and the Duration.between() method is used to calculate the duration between them.

  Period Calculation:

  The Period.between() method calculates the amount of time between two LocalDate objects in terms of years, months, and days. In this case, the period between May 4, 2023, and May 4, 2024, is exactly one year. Therefore, p is P1Y, which

  stands for a period of one year. Printing p will output P1Y.

  Duration Calculation:

  The Duration.between() method is intended to calculate the duration between two temporal objects that have time components, such as LocalDateTime or Instant. However, LocalDate represents a date without a time component. Attempting

  to use Duration.between() with LocalDate instances will result in an UnsupportedTemporalTypeException because Duration requires time-based units, which LocalDate does not support.

  Exception Details:

  The UnsupportedTemporalTypeException is thrown when an unsupported unit is used. In this case, Duration. between() internally attempts to access time-based fields (like seconds), which are not supported by LocalDate. This behavior is

  documented in the Java Bug System underJDK-8170275. Correct Usage:

  To calculate the duration between two dates, including time components, you should use LocalDateTime or Instant. For example:

  java

  LocalDateTime start = LocalDateTime.of(2023, Month.MAY, 4, 0, 0);

  LocalDateTime end = LocalDateTime.of(2024, Month.MAY, 4, 0, 0);

  Duration d = Duration.between(start, end);

  System.out.println(d); // Outputs: PT8784H

  This will correctly calculate the duration as PT8784H, representing 8,784 hours (which is 366 days, accounting for a leap year).

  Conclusion:

  The output of the given code will be:

  pgsql

  P1Y

  Exception in thread "main" java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit:

  Seconds

  Therefore, the correct answer is D:

  nginx

  P1Y

  UnsupportedTemporalTypeException

• Question 94:

  Given:

  var cabarets = new TreeMap<>();

  cabarets.put(1, "Moulin Rouge");

  cabarets.put(2, "Crazy Horse");

  cabarets.put(3, "Paradis Latin");

  cabarets.put(4, "Le Lido");

  System.out.println(cabarets.subMap(2, true, 5, false));

  What is printed?

  A. CopyEdit
  B. {2=Crazy Horse, 3=Paradis Latin, 4=Le Lido}
  C. {}
  D. An exception is thrown at runtime.
  E. Compilation fails.
  B. {2=Crazy Horse, 3=Paradis Latin, 4=Le Lido}

  ---

  Explanation

  Understanding TreeMap.subMap(fromKey, fromInclusive, toKey, toInclusive)

  TreeMap.subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) returns aportion of the map that falls within the specified key range.

  The first boolean parameter (fromInclusive) determines if the fromKey should be included.

  The second boolean parameter (toInclusive) determines if the toKey should be included.

  Given TreeMap Contents

  CopyEdit

  Applying subMap(2, true, 5, false)

  Includes key 2 ("Crazy Horse") #(fromInclusive = true)

  Includes key 3 ("Paradis Latin") #

  Includes key 4 ("Le Lido") #

  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

• Question 95:

  Given:

  java

  Optional o1 = Optional.empty();

  Optional o2 = Optional.of(1);

  Optional o3 = Stream.of(o1, o2)

  .filter(Optional::isPresent)

  .findAny()

  .flatMap(o -> o);

  System.out.println(o3.orElse(2));

  What is the given code fragment's output?

  A. 1
  B. 2
  D. Optional.empty
  F. An exception is thrown
  G. Optional[1]
  H. Compilation fails
  A. 1

  ---

  Explanation

  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.