1Z0-829 Practice Test 15 — 15 Questions

Question 1

A stream pipeline filters strings, sorts them, and returns the first match: .filter(s -> s.length() > 3).sorted().findFirst(). This is inefficient because sorted() processes all elements. Which alternative achieves the same result with better performance?

Accepted Answer

.filter(s -> s.length() > 3).min(Comparator.naturalOrder()). Using min() is a short-circuiting terminal operation that finds the minimum without sorting the entire stream, thus improving performance.

Answer

.filter(s -> s.length() > 3).sorted().limit(1).findFirst()

Answer

.filter(s -> s.length() > 3).parallel().sorted().findFirst()

Answer

.filter(s -> s.length() > 3).sorted().collect(Collectors.toList()).get(0)

Question 2

Refer to the exhibit. What is the result?

Accepted Answer

IllegalStateException. After the first terminal operation (forEach), the stream is consumed. Any further operation on the same stream throws IllegalStateException.

Answer

abc

Answer

NullPointerException

Answer

abcabc

Question 3

A Java team is processing a large dataset with parallel streams. They notice inconsistent results due to non-atomic operations on shared mutable state. Which approach should they use to ensure thread-safety while maximizing performance?

Accepted Answer

Use the collect method with a concurrent Collector such as toConcurrentMap().. Option C is correct because using a concurrent Collector (like toConcurrentMap or groupingByConcurrent) ensures both thread-safety and efficiency in parallel processing. Option A is wrong because synchronized blocks inside lambdas can cause contention and undermine parallelism. Option B is wrong because ConcurrentHashMap alone does not guarantee atomicity of compound operations. Option D is wrong because forEach with AtomicInteger still requires careful coordination and may not be optimal.

Answer

Use forEach with AtomicInteger and update atomically.

Answer

Use synchronized blocks inside the lambda expression.

Answer

Use ConcurrentHashMap for accumulation, but collect using toList().

Question 4

A developer writes the following code to print a list of strings in order: list.stream().map(s -> s.toUpperCase()).forEach(System.out::print). They want to parallelize the processing but must preserve the output order. Which change is correct and most appropriate?

Accepted Answer

list.parallelStream().map(s -> s.toUpperCase()).forEachOrdered(System.out::print);. Option C is correct because parallelStream() returns a parallel stream, and forEachOrdered guarantees encounter order while still allowing parallel processing (though ordering may reduce some parallelism). Option A is wrong because forEach does not preserve order in parallel streams. Option B is wrong because sequential() would lose parallelism. Option D is wrong because synchronized is unnecessary and reduces performance.

Answer

list.parallelStream().map(s -> s.toUpperCase()).forEach(System.out::print);

Answer

list.stream().parallel().map(s -> { synchronized(System.out) { return s.toUpperCase(); } }).forEach(System.out::print);

Answer

list.stream().parallel().map(s -> s.toUpperCase()).sequential().forEach(System.out::print);

Question 5

Arrange the steps to use a lambda expression to sort a list of strings by length.

Question 6

Which TWO are valid ways to create an immutable List in Java?

Accepted Answer

Collections.unmodifiableList(new ArrayList<>()). Option B is correct because `Collections.unmodifiableList()` returns a view of the specified list that cannot be structurally modified; any attempt to add, remove, or set elements will throw an `UnsupportedOperationException`. Option E is correct because `List.of()` (introduced in Java 9) directly creates an immutable list that disallows `null` elements and throws `UnsupportedOperationException` on mutation attempts.

Answer

Stream.of("a").collect(Collectors.toList())

Answer

Arrays.asList("a", "b")

Answer

new ArrayList<>()

Question 7

Which TWO statements are true about the java.time.Duration class? (Choose two.)

Accepted Answer

Duration represents a time-based amount of time, such as hours, minutes, seconds.. Option A is correct because the java.time.Duration class models a time-based amount of time in terms of seconds and nanoseconds, which can represent hours, minutes, seconds, and smaller units. It is designed for time-based quantities, not date-based ones like days, months, or years.

Answer

Duration.ofDays(1) returns a Duration that is daylight-saving-safe.

Answer

Duration.between(LocalDate.now(), LocalDate.now().plusDays(1)) returns a Duration of 1 day.

Answer

Duration can represent a period of months.

Question 8

Which TWO statements about the Java Platform Module System (JPMS) are true? (Choose two.)

Accepted Answer

JPMS provides reliable configuration through explicit module dependencies.. Option B is correct because JPMS enforces reliable configuration by requiring modules to explicitly declare their dependencies using the 'requires' directive in the module descriptor. This eliminates the classpath's silent dependency resolution, where missing or conflicting JARs often cause runtime errors like ClassNotFoundException.

Answer

All classes on the classpath are automatically placed in the boot layer.

Answer

A module declaration is placed in a file named module-info.class.

Answer

JPMS allows the use of the classpath to add modules to the module graph.

Question 9

Given the stack trace, which statement is true about the exception handling?

Accepted Answer

The SQLException is a checked exception, and the code must handle it or declare it.. Option C is correct because SQLException is a checked exception (a subclass of Exception but not RuntimeException), so the Java compiler enforces that it must be either caught in a try-catch block or declared in the throws clause of the enclosing method. The stack trace indicates that an SQLException occurred, and the code must handle this checked exception to compile successfully.

Answer

Both exceptions are checked, and the code must handle both.

Answer

The RuntimeException is caused by a checked exception, so it must be declared in the throws clause.

Answer

The RuntimeException is an unchecked exception, so it cannot be caught.

Question 10

A developer is writing a method that takes a LocalDate and a ZoneId and returns the current time in that time zone as an OffsetDateTime. Which approach correctly implements this?

Accepted Answer

ZonedDateTime.now(zone).toOffsetDateTime(). Option B is correct because `ZonedDateTime.now(zone).toOffsetDateTime()` directly obtains the current date-time in the specified time zone and then converts it to an `OffsetDateTime` by extracting the zone offset. This approach correctly uses the provided `ZoneId` and returns the current time as an `OffsetDateTime` without any loss of precision or incorrect time manipulation.

Answer

OffsetDateTime.of(LocalDateTime.now(), ZoneOffset.from(ZonedDateTime.now(zone)))

Answer

LocalDate.now(zone).atStartOfDay(zone).toOffsetDateTime()

Answer

LocalDateTime.now().atZone(zone).toOffsetDateTime()

Question 11

Which TWO statements are true about the Stream API and lambda expressions in Java 17?

Accepted Answer

The Stream API does not modify the original data source.. Option A is correct because the Stream API is designed to work on a view of the data, not the data itself. Operations like filter, map, and collect produce new streams or results without altering the original collection, array, or I/O source. This non-interference guarantee is a core principle of the Stream API, ensuring safe parallel execution and functional programming style.

Answer

A stream can be consumed by multiple terminal operations sequentially.

Answer

Intermediate operations on a stream are executed eagerly.

Answer

Lambda expressions introduce a new level of scope, similar to an anonymous inner class.

Question 12

The code fails to compile. What is the reason?

Accepted Answer

The flatMap method requires a function that returns a Stream, but String::chars returns an IntStream.. Option D is correct because the `chars()` method on `String` returns an `IntStream`, not a `Stream`. The `flatMap` method on a `Stream` expects a function that returns a `Stream`, but `String::chars` returns an `IntStream`, which is a primitive stream and not a subtype of `Stream`. This type mismatch causes a compilation error.

Answer

The collect method is not applicable for a Stream<Character>.

Answer

The method reference String::chars is not a valid method reference.

Answer

The chars() method returns a Stream, but flatMap requires a function that returns a Stream.

Question 13

A method receives a Boolean reference and must set it to false if null. Which code accomplishes this correctly?

Accepted Answer

flag = Boolean.FALSE.equals(flag) ? Boolean.FALSE : flag;. Option B is correct because it uses Boolean.FALSE.equals(flag) which safely handles a null flag reference without throwing a NullPointerException. If flag is null, equals returns false, so the ternary assigns Boolean.FALSE; if flag is already Boolean.FALSE, it stays unchanged; otherwise, it keeps the original value. This matches the requirement to set the Boolean reference to false only when it is null.

Answer

if (flag = null) flag = Boolean.FALSE;

Answer

if (flag == null) flag = false;

Answer

if (flag.equals(Boolean.FALSE)) flag = null;

Question 14

Given the exhibit, what is the output? (Assume America/New_York observes daylight saving time, with spring forward on March 12, 2023 at 2:00 AM to 3:00 AM.)

Accepted Answer

A DateTimeException is thrown.. Option C is correct because attempting to create a ZonedDateTime for 2023-03-12 at 02:30 in the America/New_York timezone results in a DateTimeException. This is due to the daylight saving time 'spring forward' transition at 2:00 AM, when clocks jump directly to 3:00 AM, making the time 02:30 non-existent in that timezone. The java.time API strictly validates local date-time values against the timezone's offset transitions and throws an exception for invalid local times.

Answer

null is printed.

Answer

2023-03-12T03:30:00-04:00[America/New_York]

Answer

2023-03-12T02:30:00-05:00[America/New_York]