JAVA8你只需要知道这些（3）
前言
在上篇文章中，我们提到了java.util.stream包，今天我们就来详细的研究一下这个包。
整体框架
分析stream包，我们先从整体架构入手，然后再深入到细节。我们先来看看API文档：
1.png
从上图中可以看见stream包中的接口比较多，类和枚举比较少。我们先来看接口：
java8-stream.png
DoubleStream，IntStream,LongStream，Stream都继承于BaseStream接口。并且它们都有各自的Builder接口：DoubleStream.Builder，IntStream.Builder，LongStream.Builder，Stream.Builder。剩下就只有Collector接口，Collectors，StreamSupport类，Collector,Characteristics枚举。
Stream接口
Stream接口是一个泛型接口，而DoubleStream,IntStream,LongStream只不过是对double,int,long的包装而已，所以我们弄懂Stream，其他的接口也都大同小异。
1.forEach
void forEach(Consumer<? super T> action)
forEach接收一个Consumer接口，该接口我们之前讲Function包时已经提过了。它只接收不参数，没有返回值。然后在 Stream 的每一个元素上执行该表达式。
范例：
Stream<String> stream = Stream.of("I", "love", "you");
stream.forEach(System.out::println);
System.out.println方法我们都很熟悉了，它接收一个参数，并且在控制台打印出来。这正好符合Consumer接口，所以这里输出的结果是 ：
I
love
you
2.peek
Stream<T> peek(Consumer<? super T> action)
peek方法也是接收一个Consumer功能型接口，它与forEach的区别就是它会返回Stream接口，也就是说forEach是一个Terminal操作，而peek是一个Intermediate操作，forEach完了以后Stream就消费完了，不能继续再使用，而peek还可以继续使用。
范例:
Stream<String> stream = Stream.of("I", "love", "you");
stream.peek(System.out::println).forEach(System.out::println);
代码很简单，但是大家可以先思考一下，输出的结果是什么？
输出结果:
I
I
love
love
you
you
怎么样？跟你想的是一样的吗？有人可能会问，为什么输出结果不是以下这种呢？
I
love
you
I
love
you
明明peek方法在前面。这是因为我们前面提到过的懒加载，peek是一个Intermediate操作，它并不会马上执行，当forEach的时候才会把peek和forEach一起执行，来提高效率，所以等于是每个stream元素执行两次打印操作，再执行下一个元素。
3.filter
Stream<T> filter(Predicate<? super T> predicate)
filter方法接收一个断言型的接口，断言型接口接收一个参数，返回一个Boolean类型。filter方法根据某个条件对stream元素进行过滤，通过过滤的元素将生成一个新的stream。
范例:
Stream<Integer> stream = Stream.of(1, 2, 3,4,5,6);
stream.filter((n)->n>2).forEach(System.out::println);
以上代码通过filter方法把大于2的元素过滤出来，然后输出。
4.map
<R> Stream<R> map(Function<? super T,? extends R> mapper)
map方法接收一个功能型接口，功能型接口接收一个参数，返回一个值。map方法的用途是将旧数据转换后变为新数据，是一种1：1的映射，每个输入元素按照规则转换成另一个元素。该方法是Intermediate操作。
Stream<String> stream = Stream.of("a","b","c","d");
stream.map(String::toUpperCase).forEach(System.out::println);
以上代码通过map方法，把a,b,c,d全部转变成大写，然后输出。
5.flatMap
<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
flatMap从结构上来看跟map差不多，主要是可以用来将stream层级扁平化。
Stream<List<Integer>> inputStream = Stream.of(
Arrays.asList(1),
Arrays.asList(2, 3),
Arrays.asList(4, 5, 6)
);
inputStream.flatMap((n)->n.stream()).forEach(System.out::println);
我们可以看见，inputStream由3个list组成，在经过flatMap以后，list就没有了，以前list中的元素全部放在了一起。相关的方法还有：flatMapToInt，flatMapToLong，flatMapToDouble，只不过他们返回的分别是IntStream,LongStrea和DoubleStream。
6.findFirst:返回stream的第一个元素的Optional或为空。这是一个Terminal操作，也是一个短路操作。
7.count：返回此流元素的数量。
8.sorted：将此流中的元素根据自然顺序排序，sorted方法还有一个重载方法，可以传入一个Comparator，这样就可以根据Comparator来排序。
9.min/max:Stream接口中的这两个方法接收一个Comparator参数，通过Comparator返回此流最小或者最大的元素。IntStream,DoubleStream.LongStream则不需要传入Comparator。
10.limit:该方法接收一个long型参数，表示一共返回几个元素。
11.skip:接收一个long类型的参数，表示跳过几个元素。
12.distinct:消除重复元素后返回一个新Stream。
13.allMatch：Stream中的所有元素满足传入的断言型接口，就返回true。
14.anyMatch：Stream中的只要有一个元素满足传入的断言型接口，就返回true。
15.noneMatch：Stream中没有元素满足传入的断言型接口，就返回true。
16.generate:接收一个Supplier接口，返回一个Stream,通过实现supplier接口，可以自己来控制流的生成。
17.iterate:
static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)
iterate接收两个参数，第一个是泛型，seed可以理解为种子值或者起始值。UnaryOperator是一个接口：
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T,T>
该接口继承了Function接口，那么也必须实现Function接口中的apply方法。除此之外该接口还有一个静态方法---identity,该方法始终返回其输入参数。
iterate方法的作用是将种子值成为stream的第一个元素，f(seed)为第二个元素，f(f(seed))为第三个元素，说递归你应该比较容易明白。
范例：
Stream.iterate(3, n->n+3).limit(10).forEach(System.out::println);
输出：
3
6
9
12
15
以上范例中，3即为种子值，然后f(3)等于6，f（f（3））得9。需要注意的是，iterate方法和generate方法返回的都是无限stream,需要用limite来限制stream的长度。
18.reduce:
reduce提供了三种重载方法。
1. Optional<T> reduce(BinaryOperator<T> accumulator)
2. T reduce(T identity, BinaryOperator<T> accumulator)
3. <U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)
第一个方法返回一个Optional对象，接收一个BinaryOperator。我们先来看BinaryOperator是什么？
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T>
可以看到BinaryOperator是一个函数型接口，继承了BiFunction,并且传入参数和返回值都是相同类型。我们接着看BiFunction的定义：
@FunctionalInterface
public interface BiFunction<T, U, R>{
R apply(T t, U u);
}
BiFunction接口中有一个apply方法，有两个参数，一个返回值。到这里我们大概知道reduce方法传入的参数大概怎么用了，在来看返回值Optional的定义：
public final class Optional<T> extends Object
Optional是一个普通的对象，里面的方法大家可以自己去看API，这里就不详细说了。到这里你可能会说，写了这么多，你也没说reduce到底有什么作用啊？我们通过名字去猜测一下，reduce有减少，归纳之意。那我们是否可以理解为，把Stream提供的多个元素归纳成一个对象？
范例:
Integer sum=Stream.of(1,2,3,4).reduce(Integer::sum).get();
System.out.println(sum);
输出:
10
我们通过reduce方法，把1-4累加起来得到结果10.你肯定会问为什么传的参数是Integer::sum?我们在以前的文章里面提到了方法引用::，在这里就是引用了Integer类的sum方法：
static int sum(int a, int b)
这个方法是不是就跟BiFunction中定义的apply一样呢？接收两个参数和一个返回值。
我们接着看reduce的第二个重载方法，在这个重载方法中多了一个参数T，这就是起始值，然后返回值由Optional变成了T。
范例:
Integer sum=Stream.of(1,2,3,4).reduce(1,Integer::sum);
System.out.println(sum);
输出:
11
在此范例中，我们添加了起始值1，使得最后输出结果多加了1。如果你觉得还不明白，那么再来看一个例子。
范例:
String sum=Stream.of("a","b","c","d").reduce("1",String::concat);
System.out.println(sum);
输出:
1abcd
这会应该明白了。
关于reduce的第三个重载方法，主要是用于parallelStream的，reduce操作是并发进行的，为了避免竞争，每个reduce线程都会有独立的result，combiner参数的作用就是在于合并每个线程的result得到最终的结果。由于第三个方法不是特别常用，我就只说一下方法不给出范例了。
<U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)
这个方法起初一看，头都大了，这都是什么鬼？又是U，又是T，又是BiFunction，又是BinaryOperator。BinaryOperator不是继承与BiFunction的么？为什么不两个都使用BiFunction呢？
那我们就来解析一下这个方法，首先该方法的返回值是由第一个参数决定的。也就是说第一个参数是什么类型，该方法就返回什么类型。这点明确了很重要。
我们接着看第二个参数-BiFunction,为了理解深刻，我们再次拿出该接口的定义:
@FunctionalInterface
public interface BiFunction<T, U, R>{
R apply(T t, U u);
}
该接口接收两个参数，这两个参数的类型可以不一致。并且返回一个值，值的类型也可以不一致。
接着我们看reduce方法里面定义的
BiFunction<U,? super T,U> accumulator
我们来对应一下，该接口接收两个参数，其中第一个为U，第二个为T的子类，返回类型为U。这下就明白多了，也就是说接收两个不同类型的参数，但是返回值类型跟第一个参数一致，而第一个参数的类型也就是reduce方法的第一个参数类型U。
在看reduce第三个参数-BinaryOperator
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T>
该接口继承了BiFunction,但是最重要的是，继承的BiFunction的两个接收参数和返回值都是同一个类型T。所以简单来说BinaryOperator接收两个参数，返回一个值都是同一类型。
到这里我们应该明白了为什么reduce第二个参数是BiFunction，第三个参数是BinaryOperator了吧？
因为第二个参数的作用是accumulator，所以接收的两个参数类型可以不一样。而前面说了在parallelStream的情况下，combiner的作用是合并每个线程的结果，而每个线程返回的结果都应该是同一个类型，所以在这里用BinaryOperator而不是BiFunction。
不得不说这种设计真的是太精妙了。
19.collect:
collect方法跟reduce方法功能很类似，都是聚合方法。不同的是，reduce方法在操作每一个元素时总创建一个新值，而collect方法只是修改现存的值，而不是创建一个新值。
方法定义:
1.<R,A> R collect(Collector<? super T,A,R> collector)
2.<R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)
这两个方法都是泛型方法，我们先看第一个。第一个方法接收一个Collector接口作为参数。如果我们要自己实现它会很麻烦，好在java.util.stream包中给我们提供了一个叫Collectors的类。这个方法我就不在这里介绍了，大家可以自己去看API，通过Collectors这个类我们可以很容易得到一个Collector对象，这个类中提供了很多统计的操作和创建集合的操作。
范例：
Stream<String> stream = Stream.of("a", "b", "c", "d");
List<String> list =stream.collect(Collectors.toList());
for (String string : list) {
System.out.println(string);
}
输出:
a
b
c
d
在这里我们将一个stream流转换为了一个List对象。
collect方法的第二种形式跟我们前面说的reduce的很像。接收3个参数，第一个参数是Supplier接口，这个接口我们以前说过。
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
BiConsumer接口跟Consumer接口类似，不同的是Consumer接口只接收一个参数而BiConsumer接口接收两个参数。collect的第二个参数和第三个参数都是BiConsumer接口，但是参数类型却不一样。BiConsumer<R,? super T> 第一个参数跟collect返回值一样，也跟第一个参数一样。第二个参数类型跟stream的类型一样。BiConsumer<R,R>则两个参数类型是相同的。
范例：
System.out.println(Arrays.asList("1","2","3","4").parallelStream().collect(
StringBuilder::new,
new BiConsumer<StringBuilder,String>(){
@Override
public void accept(StringBuilder t, String u) {
System.out.println("accumulator operate current thread:"+Thread.currentThread().getId()+" t:"+t+" u:"+u);
t.append(u);
System.out.println("accumulator operate current thread:"+Thread.currentThread().getId()+" result t:"+t+" u:"+u);
}
}
, new BiConsumer<StringBuilder,StringBuilder>(){
@Override
public void accept(StringBuilder t, StringBuilder u) {
System.out.println("combiner operate current thread:"+Thread.currentThread().getId()+" t:"+t+" u:"+u);
t.append(u);
System.out.println("combiner operate current thread:"+Thread.currentThread().getId()+" result t:"+t+" u:"+u);
}
}));
输出：
accumulator operate current thread:1 t: u:3
accumulator operate current thread:11 t: u:4
accumulator operate current thread:10 t: u:2
accumulator operate current thread:12 t: u:1
accumulator operate current thread:12 result t:1 u:1
accumulator operate current thread:10 result t:2 u:2
accumulator operate current thread:11 result t:4 u:4
accumulator operate current thread:1 result t:3 u:3
combiner operate current thread:1 t:3 u:4
combiner operate current thread:10 t:1 u:2
combiner operate current thread:1 result t:34 u:4
combiner operate current thread:10 result t:12 u:2
combiner operate current thread:10 t:12 u:34
combiner operate current thread:10 result t:1234 u:34
1234
为了方便大家理解，我并没有使用lambda表达式。我们首先创建了一个并行的stream，每个stream元素的类型为String，接着我们调用了collect方法，collect方法第一个参数是创建一个StringBuilder对象，在第二个参数中，我们打印了当前的线程id,和t,u的值方便调试。执行的操作也只是把String加入到StringBuilder中，第三个参数则把两个StringBuilder合并。从输出结果中我们可以看见，在执行accumulator操作的时候t的值是空的，并且是4个线程同时进行了accumulator操作，每个线程都把String加入到了StringBuilder中，而在执行combiner操作的时候，就由4个线程变成了2个，然后进行合并操作。最终结果为1234。由于是多线程的，所以每次输出的顺序是不一样的。以上输出只能作为参考。
到目前为止，Stream接口中的大部分方法我们都讲过了。至于那些IntStream，LongStream都大同小异，大家可以自己去看看，我就不做详细介绍了。
如果你觉得本篇文章帮助到了你，希望大爷能够给瓶买水钱。
本文为原创文章，转载请注明出处！
