1Z0-829 Practice Test 35 — 15 Questions

Question 1

Refer to the exhibit. What is the output?

Accepted Answer

true
true

Answer

Compilation fails

Answer

true
false

Answer

false
true

Question 2

A financial application processes transactions as List objects. The application runs on a server with limited memory (2 GB heap). The development team observes that after processing a large number of transactions (over 10 million), heap usage spikes to near 1.8 GB and garbage collection pauses become frequent (over 5 seconds). The Transaction class is defined as public record Transaction(LocalDateTime timestamp, double amount, String category) {}. The current processing code reads all transactions from a database result set into an ArrayList using a loop with list.add(). Then the list is sorted by timestamp using Collections.sort(list, Comparator.comparing(Transaction::timestamp)). The sorted list is then iterated multiple times to generate various reports. The code runs in a single-threaded context. Which change would most effectively reduce peak memory usage while preserving the sorted report output?

Accepted Answer

Collect transactions into an array (Transaction[]) and sort using Arrays.sort().. Option C is correct because using an array (Transaction[]) avoids the overhead of ArrayList's internal array expansion (which may overallocate up to 50% additional capacity) and uses contiguous memory with no wrapper objects, reducing memory footprint. Option A increases memory due to Map and List overhead. Option B loses duplicate transactions. Option D adds overhead from parallel streams and concurrent collections.

Answer

Use a TreeMap> to group by timestamp, then flatten on iteration.

Answer

Use a SortedSet<Transaction> (java.util.TreeSet) with a comparator to store transactions in sorted order.

Answer

Use a parallel stream with .sorted() and collect to a ConcurrentLinkedDeque.

Question 3

A financial application processes a large log file containing millions of timestamp entries in two different formats: "2024-01-15T10:30:00Z" (ISO 8601) and "01/15/2024 10:30:00 AM" (US locale). The current implementation uses a single DateTimeFormatter with a pattern that throws an exception for the other format. The team wants to parse both formats efficiently without using try-catch for each line. Performance is critical, and the code must be thread-safe. Which approach should be used?

Accepted Answer

Use DateTimeFormatterBuilder.appendOptional to combine both formatters into one thread-safe formatter.. Option D is correct because DateTimeFormatterBuilder.appendOptional allows defining multiple formatters in a chain, and the resulting formatter tries each in order. This is efficient and thread-safe. Option A is weak because catching DateTimeParseException per entry is slow. Option B is wrong because DateTimeFormatter.ofPattern cannot handle multiple formats. Option C is wrong because SimpleDateFormat is not thread-safe and outdated.

Answer

Use a single DateTimeFormatter and catch DateTimeParseException for the failing format, then retry with a second formatter.

Answer

Use DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'" or "MM/dd/yyyy hh:mm:ss a") with a union pattern.

Answer

Use a SimpleDateFormat with a try-catch block for each format inside a synchronized method.

Question 4

A financial application processes a daily batch of 10 million transactions. Each transaction is an object with fields: id, amount, and status (an enum: PENDING, APPROVED, REJECTED). The requirement is to find the first APPROVED transaction with amount greater than 1000. The current implementation uses a while loop with a nested if-else structure that checks each transaction sequentially. The loop also logs each transaction status, which involves a moderately expensive file write operation. Performance analysis shows the method is a bottleneck, often taking over 12 seconds. The development team is considering refactoring. Which course of action will most effectively reduce execution time while maintaining the requirement?

Accepted Answer

Replace the while loop with a traditional for loop that uses a break when the first match is found, and defer the logging to a separate batch process after the loop.. Option C is correct because early break stops iteration as soon as the first matching transaction is found, skipping remaining transactions. Additionally, moving the logging operation outside the loop, perhaps to a batch logger, reduces I/O overhead significantly. Option A is wrong because parallel streams add overhead for thread management and ordering requirements; the first match in parallel requires careful handling and may not return the first in source order. Option B is wrong because using a for-each loop with break is essentially similar to the while loop and does not address the logging issue. Option D is wrong because recursion adds stack overhead and is not suitable for large datasets, and it does not address the logging either.

Answer

Refactor the while loop into a recursive method that processes one transaction per call and stops when the condition is met.

Answer

Replace the while loop with a parallel stream and use findFirst() to get the first matching transaction.

Answer

Replace the while loop with a for-each loop that breaks when the condition is met, but keep the logging inside the loop.

Question 5

A company uses a large dataset of customer orders. They want to compute statistics: total orders, average amount, and maximum amount per city. They write: Map<String, IntSummaryStatistics> stats = orders.stream() .collect(Collectors.groupingBy(Order::getCity, Collectors.summarizingInt(Order::getAmount))); The code works but is slower than expected when run on a large dataset. They suspect the grouping operation is not taking advantage of parallelism. They want to improve performance by making the collector concurrent. Which change is correct?

Accepted Answer

Use Collectors.groupingByConcurrent(Order::getCity, Collectors.summarizingInt(Order::getAmount)).. Option D is correct because groupingByConcurrent returns a ConcurrentMap (e.g., ConcurrentHashMap) and is designed for parallel stream processing, allowing concurrent insertion. Option A is wrong because parallelStream() alone does not make the collector concurrent; the collector must also support it. Option B is wrong because forEach is not recommended for this aggregation. Option C is wrong because changing the map supplier to ConcurrentHashMap without using groupingByConcurrent may still cause thread-safety issues.

Answer

Use parallelStream() instead of stream().

Answer

Keep the code but supply a ConcurrentHashMap as the map supplier to groupingBy.

Answer

Replace collect with forEach and manually update a ConcurrentHashMap.

Question 6

A developer is processing a stream of strings and needs to create a map where the key is the string length and the value is a list of strings of that length. They write the following code: Map> map = strings.stream() .collect(Collectors.groupingBy(String::length)); The code works correctly in a sequential stream, but when they switch to parallelStream, they notice that sometimes the map contains fewer keys than expected. They suspect that the issue is related to the default map implementation used by groupingBy. What is the most likely cause and the correct fix?

Accepted Answer

Replace groupingBy with groupingByConcurrent.. Option C is correct because the default groupingBy uses a map that is not thread-safe for parallel streams. Using a concurrent collector like groupingByConcurrent ensures thread-safe accumulation. Option A is wrong because the classifier is fine. Option B is wrong because the stream is already parallel; there's no need to switch back to sequential. Option D is wrong because the issue is not with the classifier.

Answer

Provide a custom thread-safe map factory to groupingBy, e.g., ConcurrentHashMap::new.

Answer

Remove parallelStream() and use stream() to avoid concurrency issues.

Answer

The classifier function (String::length) is not threadsafe.

Question 7

A developer is writing a method that takes a Collection and returns a List containing the same elements in sorted order. The method should not modify the original collection. The developer tries the following code: public List sortCollection(Collection col) { return col.stream().sorted().collect(Collectors.toList()); } The code compiles and runs, but the team lead says it is not optimal. What improvement should be made?

Accepted Answer

Return an unmodifiable list using collect(Collectors.toUnmodifiableList()). Option D is correct because the current code creates a mutable list via `Collectors.toList()`, but the method contract does not require mutability. Using `Collectors.toUnmodifiableList()` returns an unmodifiable list, which is more memory-efficient and thread-safe, and it aligns with the principle of returning immutable collections when modification is not needed. This improvement does not affect sorting correctness but optimizes the result for immutability.

Answer

Use parallelStream() for better performance

Answer

Use a TreeSet and then convert to List

Answer

Convert the collection to an ArrayList first, then call Collections.sort() on it

Question 8

You are developing a high-frequency trading application that processes a stream of market data ticks. Each tick is an immutable object containing timestamp, price, and volume. The ticks arrive in real time and must be stored in a collection for later analysis. The collection is accessed by multiple threads: one producer thread adds ticks, and multiple consumer threads periodically iterate to compute moving averages. The system must minimize latency for the producer and ensure that consumers see a consistent snapshot of data without interfering with ongoing writes. You initially used a synchronized ArrayList, but profiler results show high contention and poor throughput. You consider the following approaches. Which one best addresses the requirements?

Accepted Answer

Use a ConcurrentLinkedDeque for writes and have consumers obtain a consistent snapshot by calling toArray() on the deque. The toArray() operation is O(n) but provides a point-in-time view without blocking the producer.. Option B is correct because ConcurrentLinkedDeque allows lock-free, non-blocking writes (ideal for low-latency producers) and calling toArray() provides a consistent, immutable snapshot of the deque at that instant without blocking concurrent modifications. This satisfies the requirement for multiple consumers to see a consistent view while the producer continues writing with minimal latency.

Answer

Replace ArrayList with CopyOnWriteArrayList, which provides thread-safety without explicit synchronization and allows concurrent iteration while modifications occur.

Answer

Use a ConcurrentLinkedDeque and have consumers acquire a read lock when iterating, while the producer uses a write lock. This provides fine-grained locking and reduces contention.

Answer

Maintain two synchronized ArrayLists. The producer writes to one list while consumers read from the other. Periodically, swap references using an AtomicReference. This allows lock-free reads after the swap.

Question 9

An application needs to maintain a set of unique customer IDs (type String) and frequently check if an ID is already present. The set is expected to contain up to 100,000 IDs. The current implementation uses a TreeSet, but performance tests show that the contains() operation is slower than desired. The developer considers switching to a HashSet. However, the business requires that when iterating the set, IDs must appear in sorted order. The developer proposes to convert the HashSet to a sorted list each time iteration is needed. Iteration occurs rarely (once per hour). What is the best approach?

Accepted Answer

Use HashSet and sort when iteration is needed. Option D is correct because the primary performance bottleneck is the contains() operation, which is O(log n) for TreeSet but O(1) average for HashSet. Since iteration with sorted order is required only once per hour, the cost of sorting the HashSet into a list (O(n log n)) is negligible compared to the frequent contains() checks. This trade-off optimizes for the dominant use case while still meeting the sorted iteration requirement.

Answer

Use ConcurrentSkipListSet

Answer

Use LinkedHashSet

Answer

Keep the TreeSet because it maintains sorted order

Question 10

A Java 17 application uses a HashMap> to group error messages by error code. The map may contain up to 5000 error codes, and each list may contain up to 1000 messages. The application frequently retrieves the list for a given error code and iterates over it. The lists are rarely modified after initial population. The current performance is acceptable, but the team wants to reduce memory footprint. The developer suggests replacing the inner List with an array (String[]), but then iteration would require conversion. Another developer suggests using a TreeMap instead of HashMap to save memory because TreeMap uses less memory per entry? Actually TreeMap has more overhead. Actually HashMap typically has lower overhead than TreeMap. The correct approach: Since lists are rarely modified, consider using List.of to create immutable lists that can be shared? Or use ArrayList with initial capacity to reduce resizing. But the stem says 'reduce memory footprint'. Option C: Use ArrayList with initial capacity to reduce internal array resizing overhead. Option A: Use TreeMap - wrong because TreeMap uses more memory per entry due to tree nodes. Option B: Use array of arrays - not type-safe. Option D: Use LinkedList - higher memory overhead per element. So best is to use ArrayList with proper sizing to minimize wasted space.

Accepted Answer

Use ArrayList<String> with initial capacity set to expected list size. Option D is correct because using an ArrayList with an initial capacity set to the expected list size eliminates the overhead of repeated internal array resizing (which wastes memory by leaving unused capacity). Since the lists are rarely modified after initial population, this approach minimizes wasted space without sacrificing iteration performance, unlike the other options.

Answer

Replace ArrayList with LinkedList

Answer

Replace HashMap with TreeMap

Answer

Replace List<String> with String[]

Question 11

A developer is implementing a cache that stores recent user sessions. The cache should maintain the most recently accessed session at the end, and when the cache reaches its maximum size (1000), it should remove the least recently accessed session (i.e., the oldest). The developer chooses a LinkedList to store sessions, adding new sessions at the end and removing from the front. However, performance is poor because searching for an existing session to update its position requires O(n) linear scan. Which collection should replace the LinkedList to improve performance while maintaining the removal order?

Accepted Answer

LinkedHashSet. LinkedHashSet (C) maintains insertion order (which can be used to represent access order if reinserted on access) and provides O(1) average-time complexity for add, remove, and contains operations. By removing and re-adding a session upon access, it moves to the end, and the oldest (first inserted) can be removed from the front when the size exceeds 1000, solving the O(n) scan problem of LinkedList.

Answer

TreeSet

Answer

HashSet

Answer

ArrayList

Question 12

You are developing a batch processing application that reads records from a CSV file and parses each row into an integer ID. The reading method readNextRecord() returns a String and can throw IOException and NumberFormatException. The method processID(int id) processes the ID. The entire process runs in a for loop over 10,000 records. The requirement is that if any record fails (either due to file read error or parsing), the loop must continue to the next record, but the exception must be logged for later review. Which approach best achieves this requirement?

Accepted Answer

Inside the loop, wrap the readNextRecord() and processID() calls in a try-catch block that catches IOException and NumberFormatException separately, logs the exception, and continues.. Option D is correct because it places a try-catch block inside the loop that catches IOException and NumberFormatException separately, logs each exception, and then continues to the next iteration. This ensures that a failure in reading or parsing any single record does not terminate the loop, and each exception is logged individually for later review, meeting the requirement precisely.

Answer

Surround the entire loop with a try-catch block that catches IOException and NumberFormatException using multi-catch, logs once, and allows the loop to continue.

Answer

Inside the loop, wrap the calls in a try-catch that catches Exception, logs, and continues.

Answer

Declare the method to throw IOException and NumberFormatException and let the caller handle them.

Question 13

A company has a service layer with a method performOperation() that originally declared throws BaseException (a checked exception). Several client methods call performOperation() and catch BaseException, wrapping it in a RuntimeException for propagation. After a system upgrade, the implementation of performOperation() now explicitly throws two new checked exceptions: SubException1 and SubException2, both of which extend BaseException. The client methods must continue to compile without modifying their catch signatures, and they must still handle the new exceptions appropriately. What is the best way to modify the client methods?

Accepted Answer

No change needed because the catch for BaseException catches all subclasses.. Option D is correct because in Java, a catch block for a superclass exception type (BaseException) will catch all subclasses (SubException1 and SubException2) due to polymorphism in exception handling. Since the client methods already catch BaseException and wrap it in a RuntimeException, no changes are needed to the catch signatures; the new exceptions are automatically handled. This satisfies the requirement that client methods continue to compile without modifying their catch signatures while still handling the new exceptions appropriately.

Answer

Use a multi-catch block to catch SubException1 and SubException2 and rethrow as RuntimeException.

Answer

Modify the client method signature to declare throws SubException1, SubException2.

Answer

Add separate catch blocks for SubException1 and SubException2 before the existing BaseException catch.

Question 14

Your team manages a high-throughput financial transaction system running on Java 17. Recently, the application experiences intermittent slowdowns and increased CPU usage during peak hours. Monitoring reveals that exception handling code is invoked frequently due to validation errors in incoming data. The system uses a central exception handler that logs every exception and throws a custom ApplicationException. In many places, the code catches generic Exception and rethrows the custom exception after logging. Additionally, method signatures include throws Exception. The team wants to improve performance and maintainability without changing the external behavior significantly. Which course of action best addresses the performance and maintainability issues?

Accepted Answer

Define specific custom checked exception classes for each validation error and catch them precisely, avoiding generic Exception catches.. Option C is correct because catching generic `Exception` forces the JVM to build a full stack trace for every validation error, which is expensive in a high-throughput system. By defining specific custom checked exception classes and catching them precisely, the team reduces unnecessary stack trace generation and makes the code more maintainable by clearly documenting which errors are expected. This approach aligns with Java best practices for exception handling, improving both performance and code clarity without altering external behavior.

Answer

Change all catch blocks to catch Throwable and ignore irrecoverable errors to reduce logging.

Answer

Add a try-catch block around every method call that might throw an exception to handle locally.

Answer

Wrap all exceptions in a single custom unchecked exception to simplify exception handling.

Question 15

A financial services company runs a Java 17 application on a server with 8 GB RAM. The application reads daily transaction files in CSV format (each file is about 500 MB). It processes each line, validates it against a SQL database, and writes results to an output file. Recently, after processing about 60% of a file, the application crashes with an OutOfMemoryError: Java heap space. The heap size is set to 2 GB. The code uses Files.readAllLines() to load the entire file into a List<String>, then iterates. The team is evaluating solutions to avoid memory issues. Which approach is the best course of action?

Accepted Answer

Replace Files.readAllLines() with Files.lines() and process the stream line by line.. Option D is correct because Files.readAllLines() loads the entire 500 MB CSV file into memory as a List, which causes the OutOfMemoryError when combined with other heap usage. Replacing it with Files.lines() returns a Stream that reads lines lazily, processing each line one at a time without holding the entire file in memory. This directly solves the heap space issue without requiring additional hardware or manual file splitting.

Answer

Increase the JVM heap size to 4 GB.

Answer

Enable class data sharing to reduce memory footprint.

Answer

Split the file into 100 MB chunks and process each chunk sequentially.

1Z0-829 Practice Test 35 — 15 Questions

Exhibit

1Z0-829 Practice Test 35 — 15 Questions

Exhibit