1Z0-829 Practice Test 37 — 15 Questions

Question 1

A financial services company has a microservice that processes trade confirmations. The service receives a stream of Trade objects (with fields: id (long), symbol (String), quantity (int), price (double)) and needs to compute the total value (quantity * price) for each symbol, but only for trades with quantity > 0 and price > 0. The result should be a Map mapping symbol to total value. The current implementation uses a for loop with manual aggregation, but it is error-prone and difficult to parallelize. The team decides to refactor using the Stream API. The DataSource provides a Stream trades(). The code must be efficient and handle large datasets. Which approach best meets these requirements?

Accepted Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).collect(Collectors.groupingBy(Trade::symbol, Collectors.summingDouble(t -> t.quantity() * t.price()))). Option A is correct because it uses `Collectors.groupingBy` with a downstream `Collectors.summingDouble` collector, which is the idiomatic and efficient way to group trades by symbol and sum their computed values (quantity * price) after filtering out invalid trades. This approach is concise, leverages the Stream API's built-in parallelization support, and avoids manual accumulation or mutable state issues.

Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).collect(Collectors.toMap(Trade::symbol, t -> t.quantity() * t.price(), Double::sum))

Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).collect(Collectors.toMap(Trade::symbol, t -> t.quantity() * t.price(), (v1, v2) -> v1 + v2))

Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).reduce(new HashMap<>(), (map, t) -> { map.merge(t.symbol(), t.quantity() * t.price(), Double::sum); return map; }, (m1, m2) -> { m1.putAll(m2); return m1; })

Question 2

A data analytics platform processes user activity logs. Each log entry is a LogRecord with fields: userId (int), action (String), timestamp (long). The requirement is to find the top 3 most active users (by count of actions) in the last hour. The logs are stored in a List<LogRecord> logs. The current solution sorts all records by userId and counts manually, but it's slow. The team decides to use streams with parallel processing. Which code correctly identifies the top 3 users?

Accepted Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.<Long, Long>comparingByValue().reversed()).limit(3).collect(Collectors.toList()). Option A is correct because it first filters logs to only those within the last hour, then groups by userId and counts actions, sorts the resulting map entries by count in descending order, limits to the top 3, and collects the result. This uses parallelStream() for performance and correctly applies the required logic.

Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByKey()).limit(3).collect(Collectors.toList())

Answer

logs.parallelStream().collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue().reversed()).limit(3).collect(Collectors.toList())

Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::action, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue().reversed()).limit(3).collect(Collectors.toList())

Question 3

You are developing a Java application that processes sensitive user data. The application runs on a server with strict security policies. You need to read configuration properties from a file located at /etc/app/config.properties. The application uses a SecurityManager. During testing, you get a security exception: java.security.AccessControlException: access denied (java.io.FilePermission /etc/app/config.properties read). You have already added a file permission grant in the policy file for the application codebase. However, the exception persists. What is the most likely cause?

Accepted Answer

A library or caller on the execution stack does not have the required FilePermission.. Option B is correct because even if the application's own codebase has the required FilePermission, any library or caller on the execution stack that does not have the permission will cause an AccessControlException. The SecurityManager performs stack inspection: every class on the call stack must have the required permission. If a library or framework method invoked by your code lacks the grant, the check fails.

Answer

The application codebase URL in the policy file is incorrect.

Answer

The file path is relative and needs to be resolved against user.dir.

Answer

The policy file is not being loaded because the JVM was not started with -Djava.security.policy.

Question 4

You are developing a microservice that processes order payments. The service uses a custom exception hierarchy: PaymentException (checked), InsufficientFundsException (unchecked, extends RuntimeException), and NetworkException (checked, extends PaymentException). The processPayment method is declared as: public void processPayment(Order order) throws PaymentException. Inside, a call to an external payment gateway may throw InsufficientFundsException or NetworkException. The requirement is to log all payment failures to an audit system, but the service must continue processing other orders. The audit logging method is: public void logFailure(String message) throws Exception. Which approach best handles exceptions while meeting the requirements?

Accepted Answer

Catch InsufficientFundsException and NetworkException in separate catch blocks. Inside each, try to call logFailure; if logFailure throws an exception, catch it and log a generic message to a fallback logger. Then return normally from processPayment without throwing.. Option C is correct because it ensures that both checked (NetworkException) and unchecked (InsufficientFundsException) exceptions are caught locally, allowing the service to log the failure via logFailure (which itself throws Exception) without propagating the exception up the call stack. By catching any exception from logFailure and falling back to a generic logger, the method guarantees that processPayment returns normally, meeting the requirement to continue processing other orders. This approach respects the checked exception contract of processPayment (throws PaymentException) while handling all failure scenarios internally.

Answer

Wrap the call to the payment gateway in a try-catch-finally block. In the catch block, log the error using logFailure. In the finally block, return from the method.

Answer

Add a throws clause to processPayment for InsufficientFundsException and NetworkException, and let the caller handle them.

Answer

Catch InsufficientFundsException and NetworkException separately, log the error using logFailure, and then throw a new RuntimeException to indicate failure.

Question 5

A company's Java 17 application processes large log files and stores word counts. Initially, they used a TreeMap to maintain sorted word counts. After adding 10 million entries, insertion performance became unacceptably slow. The team switched to a HashMap for fast insertions, but now they need to produce sorted reports. They are considering two approaches: (1) Keep the HashMap and, when a sorted report is needed, extract all entries into an ArrayList> and sort it using Collections.sort with a comparator, or (2) Use a ConcurrentSkipListMap instead. The application is single-threaded, and reports are requested infrequently. What is the best course of action?

Accepted Answer

Use HashMap and sort with Collections.sort when needed. Option C is correct because the application is single-threaded and reports are infrequent, so the overhead of sorting a HashMap's entries only when needed is acceptable and avoids the continuous insertion cost of a TreeMap. HashMap provides O(1) insertions, and sorting an ArrayList of 10 million entries with Collections.sort (which uses TimSort, O(n log n)) is efficient for occasional use, making this the best balance of performance and simplicity.

Answer

Use ConcurrentSkipListMap

Answer

Use LinkedHashMap and convert to sorted list when needed

Answer

Revert to TreeMap because it always keeps data sorted

Question 6

An architect is designing a microservice that reads large CSV files (up to 500 MB) from a shared filesystem and processes each row. The processing is CPU-bound and must not block the main thread. The service is deployed in a container with limited memory (512 MB heap). Which approach is most suitable?

Accepted Answer

Use a BufferedReader on a separate thread, reading lines into a bounded queue, and a thread pool to process rows from the queue.. Option B is correct because it uses a bounded blocking queue to decouple I/O (reading lines from the CSV) from CPU-bound processing, preventing the main thread from being blocked while also avoiding memory exhaustion. The bounded queue acts as a back-pressure mechanism, ensuring that the limited 512 MB heap is not overwhelmed by the 500 MB file. Processing rows via a thread pool allows parallel CPU-bound work without blocking the reading thread.

Answer

Use Files.readAllLines() to read the entire file into memory, then process in parallel using streams.

Answer

Use a FileChannel with a memory-mapped byte buffer of the entire file.

Answer

Use a java.nio.file.FileSystem with a WatchService to detect changes to the file.

Question 7

A large-scale data processing platform uses Java to read and write files across multiple nodes. Recently, operations have slowed down significantly. The system uses FileInputStream and FileOutputStream wrapped in BufferedInputStream and BufferedOutputStream with default buffer sizes (8 KB). The operations team suspects that the default buffer size is causing excessive system calls. The files are typically 100 MB to 1 GB in size. Which change would most improve I/O performance while minimizing memory overhead?

Accepted Answer

Increase the buffer size to 64 KB.. Increasing the buffer size to 64 KB reduces the number of system calls (read/write) by allowing more data to be transferred per call. With default 8 KB buffers and 100 MB–1 GB files, the overhead of frequent kernel transitions is significant. A 64 KB buffer strikes a good balance between performance gain and memory overhead, as it is large enough to reduce syscalls substantially without consuming excessive heap space.

Answer

Switch to using FileChannel with direct ByteBuffers for all file operations.

Answer

Use memory-mapped files (MappedByteBuffer) for the entire file.

Answer

Replace FileInputStream with FileReader and FileOutputStream with FileWriter.

Question 8

A developer is building a file synchronization tool that runs on multiple threads. Multiple threads may read and write to the same file concurrently. The developer wants to ensure that a thread does not read a file while another thread is writing to it, and that concurrent reads are allowed. Which locking mechanism should be used?

Accepted Answer

Use java.nio.channels.FileLock with shared lock for reading and exclusive lock for writing.. Option D is correct because java.nio.channels.FileLock provides a platform-independent mechanism for locking files, supporting shared locks for concurrent reads and exclusive locks for writes. This ensures that a thread cannot read a file while another thread is writing to it, while allowing multiple threads to read simultaneously, which matches the requirement exactly.

Answer

Use a ReentrantReadWriteLock in Java with the file as a resource.

Answer

Use synchronized blocks on the File object.

Answer

Use a Semaphore with permits equal to the number of threads.

Question 9

You are a DevOps engineer at a software house. Your team is preparing a Java 17 application for deployment. The application is modular and consists of 12 modules. They have been using the 'jlink' tool to create a custom runtime image for Linux. The image works fine on the development machines. However, when deployed to a minimal Docker container based on Alpine Linux, the application fails with: 'Error: Could not find or load main class com.example.Main'. The main class is declared in the module 'com.example.app' and the module-path is correctly set within the image. The image's bin directory contains the launcher scripts generated by jlink. The Docker container has only the bare minimum libraries. You have verified that the 'modules' file exists in the lib directory and contains 'com.example.app'. What is the most likely cause?

Accepted Answer

The launcher script in the image has a bash shebang and Alpine uses ash, causing the script to fail to execute properly.. The jlink tool generates launcher scripts with a bash shebang (#!/bin/bash) by default. Alpine Linux uses ash (a BusyBox shell) instead of bash, and if bash is not installed in the minimal container, the script fails to execute properly, resulting in the 'Could not find or load main class' error even though the module path and modules file are correct.

Answer

The main class is not exported by the module, so the launcher cannot find it.

Answer

The Alpine container is missing the glibc compatibility layer, causing the JVM to fail loading native libraries.

Answer

The module path in the launcher script does not include the application module.

Question 10

A financial trading system uses a Java application to process market data. The core algorithm uses nested loops to compare price arrays. The developer uses a labeled continue statement to skip certain combinations. After a code review, the team suspects the algorithm has a bug that causes incorrect results. The developer writes a unit test and discovers that the labeled continue sometimes skips more iterations than intended. The code is: outer: for (int i = 0; i < prices1.length; i++) { for (int j = 0; j < prices2.length; j++) { if (prices1[i] < prices2[j]) continue outer; // process combination } } The developer intended that if any price in prices1 is less than a price in prices2, the entire row (i) should be skipped. However, the algorithm skips rows even when the condition is not met for all j. What is the most likely cause?

Accepted Answer

The label outer is placed on the inner loop, not the outer loop.. Option B is correct because the label `outer` is placed on the inner loop, not the outer loop. In Java, a labeled continue statement jumps to the next iteration of the loop identified by the label. If the label is on the inner loop, `continue outer` will skip the current iteration of the inner loop and continue with the next iteration of the outer loop, which is exactly what the developer intended. However, the code as written has the label on the inner loop, so `continue outer` actually skips the entire inner loop for the current `i` and moves to the next `i`, even if the condition `prices1[i] < prices2[j]` is only true for some `j`. This causes more iterations to be skipped than intended.

Answer

A break statement is missing after processing a combination.

Answer

The condition for continuing is not correctly evaluated.

Answer

The continue outer statement should be a break outer.

Question 11

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.. Creating a snapshot (new ArrayList<>(transactions)) ensures the stream operates on a consistent, immutable view, avoiding ConcurrentModificationException. Using parallelStream then leverages multiple cores. The groupingBy collector works correctly in parallel because it has a combiner. This combination balances 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 12

A financial application processes millions of transactions daily. The original code uses a for loop to aggregate transactions into a Map<Long, TransactionSummary> where the key is account ID. To improve performance, a developer refactors it using parallel streams: transactions.parallelStream() .collect(Collectors.toMap( Transaction::getAccountId, Function.identity(), (t1, t2) -> t1.merge(t2), // merging logic HashMap::new )); After deployment, they observe that the resulting map is smaller than expected and some transaction summaries are missing. Profiling shows the merge function is called infrequently, suggesting that the map is losing entries. What is the most likely cause and the correct fix?

Accepted Answer

Replace HashMap::new with ConcurrentHashMap::new in the collector.. Option B is correct because HashMap is not thread-safe, and the default toMap collector uses a non-concurrent map which can be corrupted in parallel stream. Using ConcurrentHashMap as the map supplier ensures thread-safe concurrent accumulation. Option A is wrong because the merge function is associative and compatible with parallel reduction. Option C is wrong because using parallelstream and then sequential() would lose parallelism, though it would work. Option D is wrong because forEach with put might cause race conditions even with ConcurrentHashMap if not using merge.

Answer

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

Answer

The merge function is not associative; change it to use a combiner that is associative.

Answer

Use forEach with a ConcurrentHashMap and putIfAbsent to manually merge.

Question 13

A team is developing a real-time data processing pipeline that reads sensor data from a message queue. The pipeline uses a flatMap operation that calls an external geocoding service for each sensor reading. The external service has a rate limit of 10 requests per second and is slow (150ms average response time). The current code: sensorStream.parallelStream() .flatMap(reading -> getGeocode(reading).stream()) .forEach(system.out::println); The application is overloaded because parallel stream fires many concurrent requests, exceeding the rate limit and causing failures. They need to process all sensor data but must respect the rate limit. Which approach should they use?

Accepted Answer

Use a sequential stream with a custom rate limiter (e.g., a semaphore) that blocks when the limit is reached.. Option D is correct because using a sequential stream with a controlled batch size and throttling via a rate limiter (like a semaphore or Guava's RateLimiter) is the only way to reliably respect the external service's rate limit while not losing data. Options A and B only reduce parallelism but do not enforce a specific rate. Option C is wrong because it discards data.

Answer

Reduce the parallelism level by using a custom thread pool with a fixed number of threads.

Answer

Use filter to drop some sensor readings to reduce the load.

Answer

Use a sequential stream and hope the processing completes within the time window.

Question 14

A developer is converting legacy for loops to streams. The legacy code: List list = new ArrayList<>(); for (String s : strings) { if (s.length() > 5) { list.add(s.length()); } } They write: List list = strings.stream() .filter(s -> s.length() > 5) .map(s -> s.length()) .collect(Collectors.toList()); But it doesn't compile. The error is: 'cannot find symbol: method collect(Collector>)'. What is the likely issue?

Accepted Answer

The map operation returns an IntStream, which does not have a collect method. Use map(s -> s.length()).boxed().collect(...) or mapToInt(...).boxed().. Option B is correct because the stream's type is String, but the pipeline returns an int (or Integer) after map; however, the error suggests the compiler cannot infer the collector type. The problem is that filter returns a Stream<String>, then map returns IntStream because s.length() returns int, and collect is not available on IntStream; they need to box it or use mapToInt then boxed. Option A is false because the lambda is valid. Option C is false because unordered would not affect compilation. Option D is false because the issue is not parallel.

Answer

The lambda in filter is incorrectly written; it should be s.length > 5.

Answer

The stream should be made unordered to allow the collector to function.

Answer

Use parallelStream() to enable the collect method.

Question 15

A development team is working on a Java 17 application that must be packaged as a custom runtime image for deployment on a Linux server without a JDK installed. The application uses `java.base`, `java.logging`, and `java.sql` modules, and also requires the `jdk.crypto.cryptoki` module for hardware security module (HSM) integration. The team wants to minimize the image size while ensuring all necessary modules are included. They run `jlink --add-modules java.base,java.logging,java.sql,jdk.crypto.cryptoki --output myapp-runtime`. The resulting image runs the application but fails at startup with a `ClassNotFoundException` for `javax.crypto.spec.SecretKeySpec`. Which action should the team take to resolve the issue?

Accepted Answer

Add `--bind-services` to the jlink command to include service provider modules.. The `jdk.crypto.cryptoki` module is a service provider module that provides cryptographic services via the Java Cryptography Architecture (JCA). When using `jlink`, service provider modules are not automatically included unless `--bind-services` is specified, because `jlink` only includes modules directly referenced in the module graph. The `javax.crypto.spec.SecretKeySpec` class is part of `java.base`, but the actual provider implementation that makes it available at runtime is in `jdk.crypto.cryptoki`; without `--bind-services`, the service linkage is missing, causing the `ClassNotFoundException`.

Answer

Manually add the `java.security.jgss` module to the `--add-modules` list.

Answer

Use the `--list-modules` option with jlink to verify which modules are included, then add any missing ones.

Answer

Add `ALL-MODULE-PATH` to the `--add-modules` list to include all available modules.