Java Stream API：寻找filterAndMap的优雅方式

Question

过滤和映射流的默认“最佳做法”是

Stream<T> source;
// ...
Predicate<T> predicate; // = ...
Function<T, U> mapper; // = ...
Stream<U> dst = source
         .filter(predicate)
         .map(mapper);

在许多软件项目中，您将达到必须在多个流上应用相同的过滤器和映射操作的程度。例如，类T的对象集合应该转换为U类对象的List，其中U是T的子类，我们只需要U的实例。所以可以写：

Collection<T> source;
// ...
List<U> dst = source.stream()
            .filter(U.class::isInstance)
            .map(U.class::cast)
            .collect(Collectors.toList());

为了概括这一点，我写了一个名为onlyInstancesOf的帮助方法：

static <T, U> Function<T, Stream<U>> onlyInstancesOf(Class<U> clazz) {
    return t -> clazz.isInstance(t)
            ? Stream.of(clazz.cast(t))
            : Stream.empty();
}

此方法随后将与flatMap一起使用：

List<U> dst = source.stream()
            .flatMap(onlyInstancesOf(U.class))
            .collect(Collectors.toList());

我经常使用的另一个函数是optionalPresent来处理包含Optionals的流：

static <T> Function<Optional<T>, Stream<T>> optionalPresent() {
    return t -> t.map(Stream::of).orElse(Stream.empty());
}

和用法：

Collection<Optional<T>> source;
// ...
List<T> dst = source.stream()
        .flatMap(optionalPresent())
        .collect(Collectors.toList());

这些解决方案在第一个视图中看起来很优雅，但它们有一个很大的缺点：它们比首先过滤然后映射的“经典”解决方案慢10倍。

如果不违反DRY原则，您会建议如何处理这些常用的滤镜和地图习语？

Answer 1

您可以使用收集器（因为您总是收集任何方式）来过滤某个类的实例：

static <T, U extends T> Collector<T, ?, List<U>> onlyInstancesOfCollector(Class<U> clazz) {
    return Collector.of(
            ArrayList::new,
            (acc, e) -> {
                if(clazz.isInstance(e)) {
                    acc.add(clazz.cast(e));
                }
            },
            (a, b) -> {
                a.addAll(b);
                return a;
            });
}

...

List<U> dst = source.stream()
    .collect(onlyInstancesOfCollector(U.class));

哪个具有更好的性能特征：

Benchmark           Mode  Cnt  Score   Error  Units
Tests.collector     avgt   10  0.171 ± 0.003   s/op
Tests.filterAndMap  avgt   10  0.203 ± 0.005   s/op
Tests.flatmap       avgt   10  0.375 ± 0.012   s/op

完整的jmh基准：

@BenchmarkMode({ Mode.AverageTime })
@Warmup(iterations = 25)   
@Measurement(iterations = 10)    
@State(Scope.Benchmark)
public class Tests {

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
            .include(Tests.class.getSimpleName())
            .build();
        new Runner(opt).run();
    }

    List<A> input;

    @Setup
    public void setup() {
        Random r = new Random();
        input = new ArrayList<>();
        for(int i = 0; i < 10_000_000; i++) {
            input.add(r.nextInt(2) == 0 ? new A() : new B());
        }
    } 

    @Fork(1)
    @Benchmark
    public List<B> filterAndMap() {
        return input.stream()
            .filter(B.class::isInstance)
            .map(B.class::cast)
            .collect(Collectors.toList());
    }

    @Fork(1)
    @Benchmark
    public List<B> flatmap() {
        return input.stream()
            .flatMap(onlyInstancesOf(B.class))
            .collect(Collectors.toList());
    }

    @Fork(1)
    @Benchmark
    public List<B> collector() {
        return input.stream()
            .collect(onlyInstancesOfCollector(B.class));
    }

    static <T, U> Function<T, Stream<U>> onlyInstancesOf(Class<U> clazz) {
        return t -> clazz.isInstance(t)
                ? Stream.of(clazz.cast(t))
                : Stream.empty();
    }

    static <T, U extends T> Collector<T, ?, List<U>> onlyInstancesOfCollector(Class<U> clazz) {
        return Collector.of(
                ArrayList::new,
                (acc, e) -> {
                    if(clazz.isInstance(e)) {
                        acc.add(clazz.cast(e));
                    }
                },
                (a, b) -> {
                    a.addAll(b);
                    return a;
                });
    }

}

class A {}
class B extends A {}