1Z0-829 Timed Hard Questions — 25 Difficult Questions

Question 1

A developer is designing a service that processes multiple files concurrently. To avoid resource leaks, which practice is essential?

Accepted Answer

Use try-with-resources for each AutoCloseable resource. Try-with-resources guarantees that each AutoCloseable resource is closed automatically at the end of the statement, even if an exception occurs. This is essential when processing multiple files concurrently, as it prevents resource leaks without requiring explicit close() calls in finally blocks.

Answer

Ensure each thread has its own copy of the file handle

Answer

Call close() on each stream in a separate try-catch block

Answer

Use FileLock to prevent concurrent access

Question 2

Which TWO statements about lambda expressions are true? (Choose two.)
A. A lambda expression can be assigned to a functional interface variable.
B. A lambda expression can access final or effectively final local variables.
C. A lambda expression can throw any checked exception.
D. A lambda expression can be used to create an instance of an abstract class.
E. A lambda expression can be used to implement multiple abstract methods.

Accepted Answer

A lambda expression can be assigned to a functional interface variable.. False: A lambda expression can only throw checked exceptions that are declared in the functional interface's abstract method, not any checked exception. Options B and C are true: a lambda can be assigned to a functional interface variable, and it can access final or effectively final local variables. Option D is false: a lambda can only implement one abstract method (functional interface). Option E is false: lambdas cannot instantiate abstract classes; they only implement functional interfaces.

Answer

A lambda expression can throw any checked exception.

Answer

A lambda expression can be used to implement multiple abstract methods.

Answer

A lambda expression can be used to create an instance of an abstract class.

Question 3

Which THREE of the following are true about the Optional class? (Choose three.)

Accepted Answer

Optional.empty().orElseThrow(IllegalStateException::new) throws IllegalStateException. `Optional.empty().orElseThrow(IllegalStateException::new)` explicitly throws a new `IllegalStateException` when the Optional is empty. The `orElseThrow` method is designed to throw the provided exception supplier's exception if no value is present.

Answer

Optional.of(null) returns an empty Optional

Answer

Optional.get() on empty Optional returns null

Question 4

Given the following switch statement:

```java
int x = 2;
switch (x) {
    default:
        System.out.print("default ");
    case 1:
        System.out.print("1 ");
    case 2:
        System.out.print("2 ");
    case 3:
        System.out.print("3 ");
        break;
    case 4:
        System.out.print("4 ");
}
```

What is the output?

Accepted Answer

2 3. The switch statement starts execution at the matching case (case 2) and then falls through to subsequent cases until a break statement is encountered. Since case 2 has no break, it prints "2 ", then falls through to case 3, prints "3 ", and the break terminates the switch. The default case is not executed because a matching case was found before it.

Answer

2

Answer

2 3 4

Answer

default 1 2 3

Question 5

Which of the following will compile without error and produce an unmodifiable list containing three elements?

Accepted Answer

List.of("A","B","C"). `List.of("A","B","C")` returns an unmodifiable list exactly as required. In Java 9+, `List.of` returns an immutable list; any attempt to modify it throws `UnsupportedOperationException`. Option A, `Arrays.asList`, returns a fixed-size list backed by an array that allows modification via `set()`, so it is not unmodifiable. Option B, `new ArrayList<>(List.of(...))`, creates a mutable ArrayList. Option D, `Collections.unmodifiableList`, returns an unmodifiable view, but the underlying ArrayList is still mutable; modifications to the original list affect the view, so it does not guarantee immutability. Therefore, only C meets the criteria.

Answer

Arrays.asList("A","B","C")

Answer

new ArrayList<>(List.of("A","B","C"))

Answer

Collections.unmodifiableList(new ArrayList<>(List.of("A","B","C")))

Answer

None of the above

Question 6

Given: Map map = new HashMap<>(); map.put("x", 10); map.put("y", 20); map.computeIfAbsent("x", k -> 30); map.computeIfPresent("z", (k,v) -> 40); System.out.println(map); What is the output?

Accepted Answer

{x=10, y=20}. `computeIfAbsent` only inserts a mapping if the key is absent, and since "x" already exists with value 10, the lambda is not executed and the value remains 10. `computeIfPresent` only modifies a mapping if the key is present, and since "z" is not in the map, the lambda is not executed and no entry is added. Thus the map remains {x=10, y=20}.

Answer

Compilation fails

Answer

{x=30, y=20}

Answer

{x=30, y=20, z=40}

Answer

{x=10, y=20, z=40}

Question 7

Which THREE statements are true about loops in Java?

Accepted Answer

The break statement can be used to exit a loop prematurely.. The break statement in Java is used to immediately terminate the execution of a loop (for, while, or do-while) and transfer control to the statement following the loop. This allows premature exit based on a condition, which is a fundamental control flow mechanism in Java.

Answer

A while loop always executes at least once.

Answer

A do-while loop may execute zero times if the condition is false.

Question 8

A team is developing a large enterprise application using Java 17. The application consists of multiple modules: core (provides logging and configuration), services (business logic), and web (REST endpoints). The modules are packaged as separate JAR files and deployed on a server. During runtime, the web module throws a java.lang.ClassNotFoundException for a class that is part of the core module. The core module's module-info.java exports the package containing the missing class. The web module's module-info.java requires core. However, the services module also needs the same class but uses a different version of it, causing conflicts. The team decides to use the class path for the conflicting package and the module path for the rest. They add the conflicting JAR to the class path and keep the other JARs on the module path. After this change, the web module still cannot find the class, but the services module works fine. What is the most likely cause of the issue?

Accepted Answer

The web module is a named module and cannot access classes from a split package that is also in the unnamed module.. When a named module (the web module) is on the module path, it cannot access classes from the unnamed module (the class path) if those classes belong to a package that is also exported by another named module on the module path. This creates a split package, which is forbidden by the Java module system. The core module exports the package, so the web module cannot load the class from the class path JAR, resulting in ClassNotFoundException.

Answer

The services module is using an automatic module, which automatically reads the unnamed module, while the web module is a named module that does not.

Answer

The class path is not scanned for JAR files unless the module path is empty.

Answer

The core module's module-info.java does not export the package to the web module; it only exports it to all modules.

Question 9

Given the following code:

```java
outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1) {
            continue outer;
        }
        System.out.print(i + " " + j + " ");
    }
}
```

What is the output?

Accepted Answer

0-0 0-1 0-2 2-0 2-1 2-2. The code uses a labeled continue statement 'continue outer' that, when i equals 1, skips the entire inner loop for that iteration. Thus, no output is produced when i=1. The output consists of the pairs from i=0 (j=0,1,2) and i=2 (j=0,1,2), resulting in '0 0 0 1 0 2 2 0 2 1 2 2', which is correctly represented in option D.

Answer

0-0 0-1 0-2 1-0 2-0 2-1 2-2

Answer

0-0 0-1 0-2 1-0 1-1 1-2 2-0 2-1 2-2

Answer

0-0 0-1 0-2 2-0 2-1

Question 10

Which TWO statements are true about the sealed class feature in Java 17?

Accepted Answer

A sealed class restricts which other classes or interfaces may extend or implement it.. The primary purpose of the sealed class feature is to explicitly control which other classes or interfaces are permitted to extend or implement it. This is achieved by using the `permits` clause to list the allowed subclasses, thereby restricting the inheritance hierarchy.

Answer

A sealed interface cannot use the permits clause.

Answer

The permits clause must list all direct subclasses of a sealed class.

Answer

A sealed class must be declared as abstract.

Question 11

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

Which THREE practices are recommended for effective exception handling? (Choose three.)

Accepted Answer

Throw exceptions early, catch them late, but handle them at the appropriate level.. Effective exception handling in Java recommends throwing exceptions as soon as an error is detected (fail-fast), catching them at a level where the error can be meaningfully handled (not too early), and handling them at the appropriate layer of abstraction. This prevents swallowing exceptions or losing context, and aligns with the principle of separation of concerns.

Answer

Define custom exceptions without providing any additional context.

Answer

Catch exceptions at the highest level of the application and log them generically.

Question 13

Given: ZonedDateTime zdt = ZonedDateTime.of(2024, 3, 10, 2, 30, 0, 0, ZoneId.of("America/New_York")); In the US, on March 10, 2024, clocks spring forward at 2:00 AM to 3:00 AM. What is the output of System.out.println(zdt);?

Accepted Answer

2024-03-10T03:30-04:00[America/New_York]. When a ZonedDateTime is created for a time that falls within a DST gap (2:00 AM to 3:00 AM on March 10, 2024, in America/New_York), the Java API automatically adjusts the time forward to the next valid offset. The local time 2:30 AM does not exist because clocks spring forward to 3:00 AM, so the ZonedDateTime is normalized to 3:30 AM with the DST offset -04:00. This behavior is defined by the ZonedDateTime.of method, which resolves invalid local times by shifting to the offset after the gap.

Answer

Throws DateTimeException

Answer

2024-03-10T02:30-05:00[America/New_York]

Answer

2024-03-10T02:30-04:00[America/New_York]

Question 14

Given a requirement to efficiently copy a large file (over 2 GB) from one path to another, which approach is most appropriate for Java NIO.2?

Accepted Answer

Using FileChannel.transferTo() with position and count. `FileChannel.transferTo()` leverages zero-copy I/O, which allows data to be transferred directly between file system caches without unnecessary copying through user-space buffers. This is particularly efficient for large files (over 2 GB) as it minimizes context switches and memory overhead, and the method supports a `position` and `count` parameter to handle large file offsets correctly.

Answer

Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING)

Answer

Using Files.readAllBytes() then Files.write()

Answer

Using FileInputStream and FileOutputStream with a buffer of 8192 bytes

Question 15

A serialized object has an explicitly declared serialVersionUID of 123L. After a code change, a new field is added to the class but the serialVersionUID is left unchanged. What happens when deserializing an old stream?

Accepted Answer

Deserialization succeeds and the new field is set to its default value.. When a serialized object has an unchanged serialVersionUID, the Java deserialization mechanism treats the class as compatible. The new field is not present in the old stream, so it is simply initialized to its default value (e.g., null for objects, 0 for primitives) without throwing an exception. This behavior is defined by the Java Object Serialization Specification, which allows forward compatibility as long as the serialVersionUID matches.

Answer

Deserialization succeeds only if the new field is marked transient.

Answer

Deserialization throws StreamCorruptedException due to missing field.

Answer

Deserialization throws InvalidClassException because the class definition has changed.

Question 16

Refer to the exhibit. What is the result?

Accepted Answer

Prints 10. The code accesses the private field `x` of the `Outer` class from within the `Inner` class, which is a member inner class. In Java, a non-static inner class has access to all members (including private fields) of its enclosing outer class. The `Inner` class's `printX()` method directly accesses `Outer.this.x`, which is initialized to 10 in the `Outer` constructor, so it prints 10.

Answer

Runtime exception because Inner class is not static.

Answer

Compilation error because x is private.

Answer

Prints 0 because x is not initialized in Inner.

Question 17

Which change fixes the exception?

Accepted Answer

Change line 4 to: for (int i = 0; i < arr.length; i++). It changes the loop to start at index 0 and continue while i < arr.length, which correctly iterates over all valid indices (0 to arr.length-1). The original code likely used i <= arr.length, causing an ArrayIndexOutOfBoundsException when accessing arr[i] at i = arr.length. By using i < arr.length, the loop stops before reaching the out-of-bounds index.

Answer

Change line 4 to: for (int i = 1; i <= arr.length; i++)

Answer

Change line 4 to: for (int i = 0; i <= arr.length-1; i++)

Answer

Change line 5 to: System.out.println(arr[i-1]);

Question 18

A company runs a Java 17 microservice that processes real-time financial transactions. The application receives a large number of transactions per second, each with a timestamp, amount, and type. The current implementation uses a sequential stream to filter and aggregate transactions into a Map. The team observes high latency and CPU spikes during peak loads. They suspect the stream pipeline is inefficient. The pipeline code is: Map stats = transactions.stream() .filter(t -> t.getTimestamp().isAfter(Instant.now().minusSeconds(60))) .collect(Collectors.groupingBy(Transaction::getType, Collectors.summarizingDouble(Transaction::getAmount))); The transactions list is an ArrayList that is frequently modified by other threads (adding new transactions). The system has multiple CPU cores available. Which of the following changes is the MOST effective way to improve performance while maintaining correctness?

Accepted Answer

Use .parallelStream() on a snapshot (new ArrayList<>(transactions)) and keep the same collector.. Taking a snapshot via new ArrayList<>(transactions) provides a consistent, immutable view for the stream, reducing contention and allowing parallelStream to leverage multiple cores. However, the copy operation itself is not thread-safe and can throw ConcurrentModificationException if the list is being modified simultaneously. Despite this risk, option B is the most effective among the choices because it attempts to isolate the stream from concurrent modifications and uses a parallel-friendly collector. To guarantee correctness, additional synchronization would be required, but none of the other options offer a better combination of performance and safety.

Answer

Use .stream().parallel() with a custom thread pool and ensure the stream source is not modified during operation.

Answer

Replace ArrayList with CopyOnWriteArrayList and use .parallelStream() with the same collector.

Answer

Replace the collector with Collectors.groupingByConcurrent() and use .parallelStream() directly on the original list.

Question 19

A financial application uses Java SE 17 with a custom date format. The requirement is to parse strings like "2023-12-31T23:59:59.999Z" into an Instant. The existing code uses SimpleDateFormat with pattern "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'" and then calls parse(). It works fine in single-threaded testing, but in production under load, intermittent parsing failures occur with DateTimeParseException or wrong values. The application is multi-threaded and reuses the same formatter instance. Which single change should be made to fix the issue while maintaining performance?

Accepted Answer

Replace SimpleDateFormat with DateTimeFormatter.ISO_INSTANT and use Instant.from(). `SimpleDateFormat` is not thread-safe, and reusing a single instance across multiple threads causes race conditions leading to parsing failures. Replacing it with `DateTimeFormatter.ISO_INSTANT` (which is immutable and thread-safe) and using `Instant.from()` directly parses the ISO 8601 string without any synchronization overhead, maintaining performance while fixing the concurrency bug.

Answer

Wrap the parse call in a synchronized block

Answer

Use a ThreadLocal<SimpleDateFormat> to give each thread its own instance

Answer

Create a new SimpleDateFormat instance for each parse call

Question 20

A developer needs to parse the string "2023-12-31T23:59:60Z" (a leap second) into a java.time.Instant. Which statement is true?

Accepted Answer

It returns an Instant representing 2023-12-31T23:59:59Z with an added nanosecond.. Java.time.Instant.parse() handles leap seconds by converting them to the last valid second of the minute (23:59:59) and then adding a nanosecond to account for the extra second. This behavior is specified by the ISO-8601 standard and the Java Time API, which does not support a true 60th second but represents it as an Instant with a fractional second adjustment.

Answer

It returns an Instant representing 2023-12-31T23:59:59Z, ignoring the leap second.

Answer

It throws a DateTimeParseException because 60 seconds is invalid.

Answer

It returns null because the string is invalid.