使用 Java Streams，我可以根据与具有相同变量的辅助对象列表共享的变量过滤对象列表吗？

Question

I am wondering if there is a way to simply the following code into a stream of some kind to work with, instead of having the for loop?

I am basically looking to filter out a certain group of Swimmers, while trying to also make sure that these swimmers are not already in the "AttendingList."

List<Swimmer> swimmingList = //List generated from db;
List<SwimmerAttending> attendingList = //List generated from db;

for(SwimmerAttending s : attendinglist)
   {
     swimmingList = swimmingList.stream()
                                  .filter(i-> i.getSwimerNumber() > 1000 && !s.getSwimmerNumber().equals(i.getSwimmerNumber()))
                                  .collect(Collectors.toList());   
   }

So I am curious if there is a simpler way to do this with just using Streams? Thanks you.

Answer 1

Your code can be simplified and, more importantly, can be made to run in linear time, O(n), as opposed to quadratic time, O(n^2), currently, as you've a loop inside a loop (the stream iteration remains a loop, albeit a hidden one).

To get linear time, you should convert your attending list to a set which can then be checked in constant time. As such:

swimmingList = //List generated from db;
attendingList = //List generated from db;

Set<Integer> attendingSet = 
   attendingList.stream()
                .map(s -> s.getSwimmerNumber())
                .collect(Collectors.toCollection(HashSet::new));

swimmingList = swimmingList.stream()
                           .filter(i -> i.getSwimmerNumber() > 1000 
                                    && !attendingSet.contains(i.getSwimmerNumber()))
                           .collect(Collectors.toList());

The conversion to a set is linear (one loop) and the filter is also linear which makes a total linear algorithm.

If your swimming list has 1000 entries and your attending list has 1000 entries, your original code would iterate on each of the attending list entries, and for each attendee, iterate over the 1000 swimming list entry, making a total of 1,000,000 iterations. The new code will iterate over the attending list once (1000 iterations) and then iterate over the swimming list once (1000 iterations) with the membership check being done on a set which is constant time on a HashSet, making the total number of operations only 2000.

Answer 2

You can map the attendinglist to their swimmer numbers first:

List<Integer> attendingSwimmerNumbers = 
    attendingList.stream()
        .map(SwimmerAttending::getSwimmerNumber)
        .collect(Collectors.toList());

Then we can check if each swimmer's number is in the above list using contains :

 swimmingList = swimmingList.stream()
                              .filter(i-> i.getSwimmerNumber() > 1000 && attendingSwimmerNumbers.contains(i.getSwimerNumber()))
                              .collect(Collectors.toList());  

This is all assuming that swimmingList and attendingList store different types of objects. If they store the same type, then it might make sense to override equals of SwimmerAttending to check equality of the swimmer number. Then you can use contains directly on the attendingList :

 swimmingList = swimmingList.stream()
                              .filter(i-> i.getSwimmerNumber() > 1000 && attendingList.contains(i))
                              .collect(Collectors.toList());