Java 8 在java 8流的收集阶段，是否可以过滤/忽略对象？

这个问题与我不久前发表的文章有关

我找到了一种方法，可以按照我想要的方式对数据进行分组。但由于我需要对对象进行分组/映射，所以在收集过程中，当我需要应用一些过滤时，我已经关闭了流。我有以下代码：

final Map<TeamDetails, List<Player>> teamDetailsPlayerListMap  = 
        dbRows.stream().map(row -> mapDbRowToTeamPlayerPair(row))
                .collect(Collectors.groupingBy(TeamPlayerPair::getKey, 
                      Collectors.mapping(TeamPlayerPair::getValue, Collectors.toList())));

final List<Team> teams = teamDetailsPlayerListMap.entrySet().stream()
        .map(teamPlayerList -> mapTeamPlayerListToTeam(teamPlayerList))
        .collect(Collectors.toList());

其中

MyCollectors.toFilteredLinkedList（）是：

public class MyCollectors {

    public static <T, A extends Collection<T>> Collector<T, ?, A> toFilteredCollection(Supplier<A> collectionFactory, Function<T, Boolean> filter) {
        return Collector.of(
                collectionFactory,
                (acc, entry) -> {
                    if (filter.apply(entry)) {
                        acc.add(entry);
                    }
                },
                (left, right) -> { left.addAll(right); return left; }
        );
    }

    public static <T> Collector<T, ?, List<T>> toFilteredLinkedList(Function<T, Boolean> filter) {
        return toFilteredCollection(LinkedList<T>::new, filter);
    }
}

公共类MyCollector{
公共静态收集器ToFiltedCollection（供应商收集工厂、函数过滤器）{
返回收集器(
收藏工厂，
（acc，条目）->{
如果（筛选应用（条目））{
acc.add（条目）；
}
},
（左，右）->{left.addAll（右）；返回左；}
);
}
公共静态收集器toFilteredLinkedList（函数筛选器）{
返回到FilteredCollection（LinkedList:：new，filter）；
}
}
似乎您需要一个
过滤
收集器，它类似于
映射
，但执行过滤。它已经出现在Java-9中，但在Java-8中不存在。您可以将其放入项目中的某个实用程序类中：

public static <T, A, R> Collector<T, A, R> filtering(
        Predicate<? super T> filter, Collector<T, A, R> downstream) {
    BiConsumer<A, T> accumulator = downstream.accumulator();
    Set<Characteristics> characteristics = downstream.characteristics();
    return Collector.of(downstream.supplier(), (acc, t) -> {
        if(filter.test(t)) accumulator.accept(acc, t);
    }, downstream.combiner(), downstream.finisher(), 
        characteristics.toArray(new Collector.Characteristics[0]));
}

公共静态收集器筛选(
谓语
public static <T, A, R> Collector<T, A, R> filtering(
        Predicate<? super T> filter, Collector<T, A, R> downstream) {
    BiConsumer<A, T> accumulator = downstream.accumulator();
    Set<Characteristics> characteristics = downstream.characteristics();
    return Collector.of(downstream.supplier(), (acc, t) -> {
        if(filter.test(t)) accumulator.accept(acc, t);
    }, downstream.combiner(), downstream.finisher(), 
        characteristics.toArray(new Collector.Characteristics[0]));
}

final Map<TeamDetails, List<Player>> teamDetailsPlayerListMap  = 
    dbRows.stream()
          .map(row -> mapDbRowToTeamPlayerPair(row))
          .collect(Collectors.groupingBy(TeamPlayerPair::getKey, 
                Collectors.mapping(TeamPlayerPair::getValue, 
                    filtering(player -> player != null && player.getName() != null 
                                 && !player.getName().isEmpty(), Collectors.toList()))));