Question 445 of 509

Working with Streams and Lambda Expressions →mediumMultiple ChoiceObjective-mapped

Quick Answer

The answer is to replace `HashMap::new` with `ConcurrentHashMap::new` in the collector. This is correct because `Collectors.toMap` with a `HashMap` supplier is not thread-safe; when used with a parallel stream, multiple threads concurrently write to the same map, causing race conditions that silently drop entries and produce a smaller map than expected. The merge function is actually associative and correct, so the real issue is the non-concurrent map supplier, which violates the thread safety required for parallel reduction. On the Oracle Certified Professional Java SE 17 Developer 1Z0-829 exam, this question tests your understanding of parallel streams collector thread safety and the critical distinction between concurrent and non-concurrent collectors. A common trap is assuming the merge function is the culprit, but the exam expects you to recognize that the map supplier must be thread-safe for parallel accumulation. Memory tip: “Parallel streams need concurrent collections—if your map is missing entries, check the supplier, not the merger.”

1Z0-829 Working with Streams and Lambda Expressions Practice Question

This 1Z0-829 practice question tests your understanding of working with streams and lambda expressions. Read the scenario carefully and evaluate each option against the stated constraints before committing to an answer. After answering, compare your reasoning against the explanation and wrong-answer breakdown below. Once you have made your selection, read the full explanation to reinforce the concept and understand why each distractor is designed to mislead on exam day.

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?

Clue words in this question

Noticing these words before you look at the options changes how you read each choice.

Clue: "most likely"
Why it matters: Probability qualifier — the question wants the most probable cause or outcome, not a guaranteed one. Eliminate low-probability options.

Question 1mediummultiple choice

Full question →

A
Remove parallelStream() and use sequential stream to avoid concurrency issues.
Why wrong: While this would work, it sacrifices the parallelism benefit. The goal is to maintain performance while fixing correctness.
B
The merge function is not associative; change it to use a combiner that is associative.
Why wrong: The merge function appears associative as it combines two summaries. The issue is not associativity.
C
Use forEach with a ConcurrentHashMap and putIfAbsent to manually merge.
Why wrong: This approach is error-prone and may still cause race conditions. The collect method with proper collector is preferred.
D
Replace HashMap::new with ConcurrentHashMap::new in the collector.
In parallel streams, the default toMap collector uses HashMap which is not thread-safe. ConcurrentHashMap allows safe concurrent insertion and merging.

Full breakdown with real-world context →

Answer choices

Why each option matters

Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.

Correct answer & explanation

✓

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.

Key principle: NAT direction and interface roles matter as much as the IP address mapping. Inside/outside designation controls which traffic is translated.

Answer analysis

Option-by-option breakdown

For each option: why learners choose it and why it is or isn't the right answer here.

✗
Remove parallelStream() and use sequential stream to avoid concurrency issues.
Why it's wrong here
While this would work, it sacrifices the parallelism benefit. The goal is to maintain performance while fixing correctness.
✗
The merge function is not associative; change it to use a combiner that is associative.
Why it's wrong here
The merge function appears associative as it combines two summaries. The issue is not associativity.
✗
Use forEach with a ConcurrentHashMap and putIfAbsent to manually merge.
Why it's wrong here
This approach is error-prone and may still cause race conditions. The collect method with proper collector is preferred.
✓
Replace HashMap::new with ConcurrentHashMap::new in the collector.
Why this is correct
In parallel streams, the default toMap collector uses HashMap which is not thread-safe. ConcurrentHashMap allows safe concurrent insertion and merging.
Clue confirmation
The clue word "most likely" in the question point toward this answer.
Related concept
Static NAT maps one inside address to one outside address.

Common exam traps

Common exam trap: NAT rules depend on direction and matching traffic

NAT is not only about the public address. The inside/outside interface roles and the ACL or rule that matches traffic are just as important.

Detailed technical explanation

How to think about this question

NAT questions usually test address translation, overload/PAT behaviour, static mappings and whether the right traffic is being translated. Read the interface direction and address terms carefully.

KKey Concepts to Remember

Static NAT maps one inside address to one outside address.
PAT allows many inside hosts to share one public address using ports.
Inside local and inside global describe the private and translated addresses.
NAT ACLs identify traffic for translation, not always security filtering.

TExam Day Tips

Identify inside and outside interfaces first.
Check whether the scenario needs static NAT, dynamic NAT or PAT.
Do not confuse NAT matching ACLs with normal packet-filtering intent.

Key takeaway

NAT direction and interface roles matter as much as the IP address mapping. Inside/outside designation controls which traffic is translated.

Real-world example

How this comes up in practice

A small business has 20 workstations on the 192.168.1.0/24 network and one public IP from its ISP. The router uses PAT (NAT overload) so all 20 devices share one public address using different source ports. NAT questions test whether you understand the four address terms and which direction each translation applies.

What to study next

Got this wrong? Here's your next step.

Review the four NAT address types (inside local, inside global, outside local, outside global), PAT port overload, and static vs dynamic NAT use cases. Then practise related 1Z0-829 NAT questions on configuration and troubleshooting.

Related 1Z0-829 practice-question pages

Use these pages to review the topic behind this question. This is how one missed question becomes focused revision.

Handling Date, Time, Text, Numeric and Boolean Values practice questions

Practise 1Z0-829 questions linked to Handling Date, Time, Text, Numeric and Boolean Values.

Controlling Program Flow practice questions

Practise 1Z0-829 questions linked to Controlling Program Flow.

Utilizing Java Object-Oriented Approach practice questions

Practise 1Z0-829 questions linked to Utilizing Java Object-Oriented Approach.

Handling Exceptions practice questions

Practise 1Z0-829 questions linked to Handling Exceptions.

Working with Arrays and Collections practice questions

Practise 1Z0-829 questions linked to Working with Arrays and Collections.

Working with Streams and Lambda Expressions practice questions

Practise 1Z0-829 questions linked to Working with Streams and Lambda Expressions.

Java Platform Overview and Packaging practice questions

Practise 1Z0-829 questions linked to Java Platform Overview and Packaging.

Java I/O API and Securing Applications practice questions

Practise 1Z0-829 questions linked to Java I/O API and Securing Applications.

1Z0-829 fundamentals practice questions

Practise 1Z0-829 questions linked to 1Z0-829 fundamentals.

1Z0-829 scenario practice questions

Practise 1Z0-829 questions linked to 1Z0-829 scenario.

1Z0-829 troubleshooting practice questions

Practise 1Z0-829 questions linked to 1Z0-829 troubleshooting.

Practice this exam

Start a free 1Z0-829 practice session

Short sessions build daily habit. Longer sessions build exam-day stamina. Try a timed session to simulate real conditions.

10 questions 20 questions 30 questions 50 questions Timed 30

1Z0-829 practice-test guide →Study guide →Browse all practice tests

FAQ

Questions learners often ask

What does this 1Z0-829 question test?

Working with Streams and Lambda Expressions — This question tests Working with Streams and Lambda Expressions — Static NAT maps one inside address to one outside address..

What is the correct answer to this question?

The correct answer is: 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.

What should I do if I get this 1Z0-829 question wrong?

Are there clue words in this question I should notice?

Yes — watch for: "most likely". Probability qualifier — the question wants the most probable cause or outcome, not a guaranteed one. Eliminate low-probability options.

What is the key concept behind this question?

Static NAT maps one inside address to one outside address.

About these practice questions

Courseiva creates original exam-style practice questions with explanations and wrong-answer analysis. It does not publish real exam questions, exam dumps, or protected exam content. Learn why practice questions differ from exam dumps →

How Courseiva writes practice questions · Editorial policy

Same concept, more angles

1 more ways this is tested on 1Z0-829

These questions test the same concept from different angles. Work through them to make sure you can recognise it however the exam phrases it.

Variation 1. A company runs a financial application that processes a stream of millions of transaction records daily. Each record is a 'Transaction' object with fields: id, amount, currency, timestamp. The system currently uses a parallel stream to group transactions by currency and compute the sum of amounts per currency, using the following code: Map<String, Double> result = transactions.parallelStream() .collect(Collectors.groupingBy(Transaction::getCurrency, Collectors.summingDouble(Transaction::getAmount))); Recently, performance has degraded significantly. Analysis shows that the stream source is a LinkedList, and the operation involves a large number of distinct currencies (over 1000). The JVM is running on a machine with 4 cores. Which is the best course of action to improve performance?

hard

A.Change the stream source to an ArrayList and use sequential stream.
B.Use a custom thread pool with ForkJoinPool to control parallelism.
C.Increase the parallelism level to 8.
✓ D.Replace groupingBy with a custom concurrent collector using ConcurrentHashMap.

Why D: Option C is correct: using groupingByConcurrent is designed for parallel streams and uses ConcurrentHashMap, reducing merge overhead. Option A (sequential stream) would lose parallelism and likely be slower. Option B (increasing parallelism) would add overhead without addressing the source or collector issue. Option D (custom thread pool) does not fix the core problems of poor splitting and non-concurrent collector.

Last reviewed: Jun 24, 2026

Question Discussion

Share a tip, memory trick, or ask about the reasoning behind this question. Do not post real exam questions, leaked content, braindumps, or copyrighted exam material. Comments are moderated and may be removed without notice.

Loading comments…

This 1Z0-829 practice question is part of Courseiva's free Oracle certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the 1Z0-829 exam.