找出Java 8流过滤器是否已过滤某些内容的优雅方法

Question

I have a List of Item fetched from a database.

I do something like:

List<Item> list;
list.stream()
    .filter( i -> i.condition() )
    .mapToLong( Item::asLong )
    .sum()
    ;

Now I want to know, if the filter has filtered out something so I could delete this from my database where it is no longer needed.

I could do:

List<Item> list2 = list.stream()
    .filter( i -> i.condition() )
    .collect( Collectors.toList() )
    ;

int theSizeIWant = list2.size();

list2.stream().mapToLong( Item::asLong )
     .sum()
     ;

but I wonder if there is a more elegant solution which doesn't need to create the intermediate list.

Answer 1

A possible solution would be to partition the Stream with the predicate and sum the values. Partitioning is done with partitioningBy(predicate, downstream) . In this case, the predicate would be your filtering function and the downstream collector would be summingLong to sum the values.

public static void main(String[] args) {
    List<Item> list = new ArrayList<>();
    Map<Boolean, Long> map = 
        list.stream()
            .collect(Collectors.partitioningBy(
                Item::condition, 
                Collectors.summingLong(Item::asLong)
            ));
    long sumWithTrueCondition = map.get(true);
    long sumWithFalseCondition = map.get(false);
}

The map will contain the sum where the predicate is true (resp. false ) with the true key (resp. false ).

This way, if something has been filtered, sumWithTrueCondition will be strictly greater than 0. Furthermore, you can get the total sum by adding sumWithTrueCondition and sumWithFalseCondition .

Answer 2

Yes, you can do something like this.

Map<Boolean, List<Item>> partitions =
    list.stream.collect(Collectors.partitioningBy(i -> i.condition()));

Where partitions.get(true) will get you the good ones and partitions.get(false) will get you the ones to be deleted.

Answer 3

Another solution is to count the bad elements in the lambda expression:

List<String> strings = Arrays.asList("1", "2", "3", "12", "4", "5");
List<String> badOnes = new ArrayList<>();

strings.stream()
       .filter(s -> {
         boolean returnValue = !s.contains("1");
         if (!returnValue) {
           badOnes.add(s);
         }
         return returnValue;
       })
       .forEach(s -> System.out.println(s));

System.out.println(badOnes);

Answer 4

This alleviates the intermediate list, it still need a second calculation though. If something doesn't pass the condition, it wont pass further down the stream, and won't get counted.

int count = 0;

count has to be an instance variable, and then you can do this:

List<Item> list;
list.stream()
    .filter( i -> i.condition() )
    .mapToLong( (item) -> { count++; return item.asLong(); } )
    .sum();

boolean isFiltered = list.size() > count;