Скачать или смотреть Simplifying Java Streams: Filter a List of Objects Efficiently

Discover how to improve the performance of your Java Streams by filtering objects with shared variables across two lists efficiently and in linear time.
---
This video is based on the question https://stackoverflow.com/q/64628085/ asked by the user 'MXBuster' ( https://stackoverflow.com/u/10205622/ ) and on the answer https://stackoverflow.com/a/64628272/ provided by the user 'Vikash Madhow' ( https://stackoverflow.com/u/576437/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: With Java Streams, can I filter a list of objects based on a variable that is shared with a secondary list of objects with that same variable?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Simplifying Java Streams: Filter a List of Objects Efficiently

When working with lists of objects in Java, particularly with Java 8 and its stream API, you might encounter situations where filtering a list based on shared variables from another list can seem daunting. Suppose you're trying to filter a list of Swimmers while ensuring that these swimmers are not already in an AttendingList. In such cases, understanding how to streamline your code using streams is crucial for both performance and readability.

The Initial Problem

The conventional approach to this problem often involves using nested loops, which can lead to inefficiencies. Here’s a simplified version of such an approach, as found in many applications:

[[See Video to Reveal this Text or Code Snippet]]

This code is not only difficult to read but also runs in quadratic time (O(n²)), making it inefficient for larger datasets.

The Efficient Solution

To efficiently filter the swimmingList, you can leverage the power of Java Streams and collections, transforming your code from O(n²) to O(n) complexity. The key lies in converting the attendingList into a set for rapid membership checking. Here's how you can do it:

Convert the attendingList to a Set: This allows for constant time (O(1)) checks for membership.

Filter the swimmingList with a Stream: Apply the filter conditions directly on the stream.

Here is the refactored code utilizing these techniques:

[[See Video to Reveal this Text or Code Snippet]]

Breakdown of the Solution

Creating a Set for Attending Swimmers:

We convert attendingList to a HashSet of swimmer numbers. This is done in linear time (O(n)), where n is the size of the attendingList.

Filtering the Swimming List:

Using streams, we filter swimmingList based on the swimmer number being greater than 1000 and not present in the attendingSet. Each check for membership in the set is done in constant time thanks to the set’s internal structure.

Performance Comparison

Original Code: For a swimming list and an attending list of size 1000, the original nested loops run a staggering 1,000,000 iterations (1000 * 1000).

Refactored Code: The new stream-based approach accomplishes the task in just 2000 iterations (1000 for creating the set and 1000 for filtering), dramatically enhancing performance.

Conclusion

Using Java Streams not only simplifies the code but significantly enhances the processing speed by utilizing proper data structures like sets for membership checks. By adopting this linear approach, you can ensure that your applications run efficiently, even with larger data sets.

If you're struggling with similar scenarios, remember that it's often possible to use collections strategically to reduce complexity and enhance performance. Happy coding!