A Real-World Example of a Stream Collector
See how Stream Collectors work in the wild.
Join the DZone community and get the full member experience.Join For Free
Collectors methods fit most use-cases. They allow returning either a
Collection or a scalar. For the former, you use one of the
toXXX() method, for the latter, one of the
Let's imagine an e-commerce platform that implements a shopping cart. The cart is modeled as the following:
This diagram might translate into the following (abridged) code:
- Only depend on
- Organize products into a map. The key is the
Product; the value is the quantity.
- Remember to return a read-only copy of the collection to maintain encapsulation.
Once we have defined how we store data in memory, we need to design how to display the cart on-screen. We know that the checkout screen needs to show two different bits of information:
- The list of rows with the price for each row, i.e., the price per product times the quantity.
- The overall price of the cart.
Here's the corresponding code:
CartRowis a value object. We can model it as a Java 16
- Collect the list of rows.
- Compute the price for each row.
- Compute the total price.
One of the main limitations of Java streams is that you can only consume them once. The reason is that streamed objects are not necessarily immutable (though they can be). Hence, executing the same stream twice might not be idempotent.
Therefore, to get both the rows and the price, we need to create two streams from the cart. From one stream, we will get the rows and from the other the price.
This is not the way.
We want to collect both rows and the price from a single stream. We need a custom
Collector that returns both in one pass as a single object.
- Total cart price.
- List of cart rows that can display the product's label, the product's price, and the row price.
Here's a summary of the
Collector interface. For more details, please check this previous post.
||Supply the base object to start from|
||Describe how to accumulate the current streamed item to the container|
||If the stream is parallel, describe how to merge them|
||If the mutable container type is not the returned type, describe how to transform the former into the latter|
||Provide meta-data to optimize the stream|
Given this, we can implement the
- The mutable container is an instance of
- For each map entry containing the product and the quantity, accumulate both into the
PriceAndRowscan be combined by summing their total price and aggregating their respective rows.
- The mutable container can be returned as-is.
Collector is a bit involved, but using the custom collector is as easy as:
You can solve most use cases with one of the out-of-the-box collectors provided in the
Collectors class. However, some require to implement a custom
Collector, e.g., when you need to collect more than a single collection or a single scalar.
While it may seem complicated if you never developed one before, it's not. You only need a bit of practice. I hope this post might help you with it.
You can find the source code of this post on GitHub in Maven format.
To go further:
Originally published at A Java Geek on May 2nd, 2021
Published at DZone with permission of Nicolas Fränkel, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.