Java Stream flatmap（七）

Stream Head的构建（一）
Stream 的中间操作（二）
Stream的终止操作（三）
flatmap是一个容易和map混淆的操作，前面我们已经分析过map这样的中间操作，这次来看一下flatmap的原理

List<String> first= Arrays.asList("one", "two", "three", "four");List<String> second= Arrays.asList("A", "B", "C", "D");Stream.of(first,second).flatMap(Collection::stream).forEach(System.out::print);

以可变长参数构建源头在第一篇已经分析过，不再赘述。主要看flatMap中间操作

ReferencePipeline.java public final <R> Stream<R> flatMap(Function<? super P_OUT, ? extends Stream<? extends R>> mapper) {        return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,                                     StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT | StreamOpFlag.NOT_SIZED) {            @Override            Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {                return new Sink.ChainedReference<P_OUT, R>(sink) {                    @Override                    public void begin(long size) {                        downstream.begin(-1);                    }                    @Override                    public void accept(P_OUT u) {                        Java 7引入try-with-resources 公告，只需实现AutoCloseable就能被当成resource                        优雅处理I/O这样的流在出现异常后能正确关闭流                        try (Stream<? extends R> result = mapper.apply(u)) {                            if (result != null)                                result.sequential().forEach(downstream);                        }                    }                };            }        };    }AbstractPipeline.java修改源头参数public final S sequential() {        sourceStage.parallel = false;        return (S) this;    }

流程前三篇已经讲过，这里主要看accept方法，首先把上游发来的元素转化成流，可以继续增加中间操作，这里没有

LambdaFunction<List, Stream<?>> mapper= list -> list.stream();方法引用Function<List, Stream<?>> mapper= Collection::stream;

注意：我们的集合是由Arrays生成的，返回内部定制的ArrayList，这种集合不支持添加和删除，在转化成流时，使用的是ArraySpliterator迭代器

public static <T> Spliterator<T> spliterator(Object[] array,int additionalCharacteristics) {        return new ArraySpliterator<>(Objects.requireNonNull(array),additionalCharacteristics);    }

而后把流中的元素遍历发给下游

再看下面这个例子，flatMap使用的是外部数据源，并添加了中间转换操作

List<String> first= Arrays.asList("one", "two", "three", "four");List<String> second= Arrays.asList("A", "B", "C", "D");      //不使用lambda表达式     first.stream()          .flatMap(new Function<String, Stream<String>>() {                  //f是first发出的元素                    public Stream<String> apply(String f) {                        return second.stream().map(new Function<String, String>() {                           //s是second发出的元素                            public String apply(String s) {                                return String.format("%s,%s ", f, s);                            }                        });                    }                })         .forEach(System.out::println);        //使用lambda表达式        first.stream()                .flatMap(f -> second.stream().map(s -> String.format("%s,%s ", f, s)))                .forEach(System.out::println);

重点就一句,在内部重新构造新流发送给下游，如何构造由flatmap转化参数实现

 result.sequential().forEach(downstream);