JAVA8给我带了什么——流的概念和收集器

到现在为止，笔者不敢给流下定义，从概念来讲他应该也是一种数据元素才是。可是在我们前面的代码例子中我们可以看到他更多的好像在表示他是一组处理数据的行为组合。这让笔者很难去理解他的定义。所以笔者不表态。各位同志自行理解吧。
在没有流以前，处理集合里面的数据一般都会用到显示的迭代器。用一下前面学生的例子吧。目标是获得学分大于5的前俩位同学。

 1 package com.aomi;
 2 
 3 import java.util.arraylist;
 4 import java.util.iterator;
 5 import java.util.list;
 6 import static java.util.stream.collectors.tolist;
 7 
 8 public class main {
 9 
10     public static void main(string[] args) {
11         // todo auto-generated method stub
12 
13         list<student> stus = getsources();
14 
15         iterator<student> ite = stus.iterator();
16 
17         list<string> names = new arraylist<>();
18         int limit = 2;
19         while (ite.hasnext() && limit > 0) {
20 
21             student stu = ite.next();
22 
23             if (stu.getscore() > 5) {
24 
25                 names.add(stu.getname());
26                 limit--;
27             }
28         }
29 
30         for (string name : names) {
31             system.out.println(name);
32         }
33 
34     }
35 
36     public static list<student> getsources() {
37         list<student> students = new arraylist<>();
38 
39         student stu1 = new student();
40 
41         stu1.setname("lucy");
42         stu1.setsex(0);
43         stu1.setphone("13700227892");
44         stu1.setscore(9);
45 
46         student stu2 = new student();
47         stu2.setname("lin");
48         stu2.setsex(1);
49         stu2.setphone("15700227122");
50         stu2.setscore(9);
51 
52         student stu3 = new student();
53         stu3.setname("lili");
54         stu3.setsex(0);
55         stu3.setphone("18500227892");
56         stu3.setscore(8);
57 
58         student stu4 = new student();
59 
60         stu4.setname("dark");
61         stu4.setsex(1);
62         stu4.setphone("16700555892");
63         stu4.setscore(6);
64 
65         students.add(stu1);
66         students.add(stu2);
67         students.add(stu3);
68         students.add(stu4);
69 
70         return students;
71     }
72 
73 }

如果用流的话是这样子的。

public static void main(string[] args) {
        // todo auto-generated method stub

        list<student> stus = getsources();

        list<string> names = stus.stream()
                .filter(st -> st.getscore() > 5)
                .limit(2)
                .map(st -> st.getname())
                .collect(tolist());
        for (string name : names) {
            system.out.println(name);
        }

    }

 把这俩段代码相比较主要是为了说明一个概念：以前做法都是在外部迭代，最为体现就是笔者在外面定义了一个集合names 。而流却什么也没有，现在我们应该能清楚感受到流是在内部迭代。也就是说流已经帮你做好了迭代。我们只要传入相关的函数就可以得到想要的结果。至于内部迭代的好处，笔者没有办法亲身的感受，唯一的感觉就是代码变的简单明了了。但是官方说stream库为了我们在内部迭代里面做了很多优化和充公利用性能的操作。比如并行操作。所以笔者就听官方了。

事实上，在用流的过程中，我们用到很多方法函数。比如上面的limit方法，filter方法等。这个定义为流操作。但是不管是什么操作，你必须要有一个数据源吧。总结如下：

• 数据源：用于生成流的数据，比如集合。
• 流操作：类似于limit方法，filter方法。

流还有一种特点——部分流操作是没有执行的。一般都是在collect函数执行的时候，才开始执行个个函数。所以我们可以细分一下流操作：

• 数据源：用于生成流的数据，比如集合。
• 中间操作：类似于limit方法，filter方法。这些操作做变了一个操作链，有一点流水线的概念。
• 终端操作：执行上面的操作链。比如collect函数。

从上面的讲解我们就可以感觉流好像是先收集相关的目标操作，什么意思呢？就是先把要做的事情计划一下，最后一声令下执行。而下这个命令是collect函数。这一点跟.net的linq是很像的。同时记得他只能执行一次。也就是说这个流执行一次之后，就不可能在用了。
笔者列一下以前的用到的函数

foreach：终端
collect：终端
count：终端
limit：中间
filter：中间
map：中间
sorted：中间

到目前为止我们用到的流都是通过集合来建一个流。笔者对此从来没有讲过。现在笔者来讲些构建流的方式。
在stream库里面为我们提供了这样子一个方法——stream.of

package com.aomi;

import java.util.optional;
import java.util.stream.stream;

public class main {

	public static void main(string[] args) {
		// todo auto-generated method stub

		stream stream = stream.of("i", "am", "aomi");

		optional<string> firstword = stream.findfirst();
		
		if(firstword.ispresent())
		{
			system.out.println("第一个字："+firstword.get());
		}
	}

}

运行结果：

去看一下of方法的代码。如下

public static<t> stream<t> of(t... values) {
        return arrays.stream(values);
    }

说明我们可能指定一个类型来建一个流。上面可以修改为

stream<string> stream = stream.of("i", "am", "aomi");

findfirst函数用于表示返回第一个值。那就是可能数据源是一个空呢？所以他有可以会返回null。所以就是用一个叫optional类的表示可以为空。这样子我们就可以用optional类的方法进一步做安全性的操作。比如判断有没有值（ispresent()）
笔者想要建一个int类型的数组流玩玩。为了方便笔者便试给一下上面的代码。却发现报错了。

如果我把int改为integer呢？没有问题了。所以注意要用引用类型的。int类型对应为integer类型。

 1 package com.aomi;
 2 
 3 import java.util.optional;
 4 import java.util.stream.stream;
 5 
 6 public class main {
 7 
 8     public static void main(string[] args) {
 9         // todo auto-generated method stub
10 
11         stream<integer> stream = stream.of(1, 2, 9);
12 
13         optional<integer> firstword = stream.findfirst();
14         
15         if(firstword.ispresent())
16         {
17             system.out.println("第一个字："+firstword.get());
18         }
19     
20     }
21 
22 }

运行结果：

那想要用int类型呢?什么办呢？改改

 1 package com.aomi;
 2 
 3 import java.util.optionalint;
 4 import java.util.stream.intstream;
 5 
 6 public class main {
 7 
 8     public static void main(string[] args) {
 9         // todo auto-generated method stub
10 
11         intstream stream = intstream.of(1, 2, 9);
12 
13         optionalint firstword = stream.findfirst();
14         
15         if(firstword.ispresent())
16         {
17             system.out.println("第一个字："+firstword.getasint());
18         }
19     
20     }
21 
22 }

运行结果：

我们以上面的例子来一个猜测：是不是double类型，只要修改为doublestream就行呢？试试。

 1 package com.aomi;
 2 
 3 import java.util.optionaldouble;
 4 import java.util.stream.doublestream;
 5 
 6 public class main {
 7 
 8     public static void main(string[] args) {
 9         // todo auto-generated method stub
10 
11         doublestream stream = doublestream.of(1.3, 2.3, 9.5);
12 
13         optionaldouble firstword = stream.findfirst();
14         
15         if(firstword.ispresent())
16         {
17             system.out.println("第一个字："+firstword.getasdouble());
18         }
19     
20     }
21 
22 }

运行结果：

结果很明显，我们的猜测是对的。所以见意如果你操作的流是一个int或是double的话，请进可能的用xxxstream 来建流。这样子在流的过程中不用进行拆装和封装了。必竟这是要性能的。在看一下如果数据源是一个数组的情况我们如何生成流呢？

1  public static collector<charsequence, ?, string> joining(charsequence delimiter,
2                                                              charsequence prefix,
3                                                              charsequence suffix) {
4         return new collectorimpl<>(
5                 () -> new stringjoiner(delimiter, prefix, suffix),
6                 stringjoiner::add, stringjoiner::merge,
7                 stringjoiner::tostring, ch_noid);
8     }

在看一个叫tolist函数的代码。

1 public static <t>
2     collector<t, ?, list<t>> tolist() {
3         return new collectorimpl<>((supplier<list<t>>) arraylist::new, list::add,
4                                    (left, right) -> { left.addall(right); return left; },
5                                    ch_id);
6     }

我们发现他会共同的返回一个collector类型。从上面我们就可以知道他的任务就是用去处理最后数据。我们把他定为收集器。让我们看一下收集器的接口代码吧;

 1 public interface collector<t, a, r> {
 2 
 3     supplier<a> supplier();
 4 
 5     biconsumer<a, t> accumulator();
 6 
 7     binaryoperator<a> combiner();
 8 
 9     function<a, r> finisher();
10 
11     set<characteristics> characteristics();
12 }

光看前面四个方法是不是有一点熟悉的感觉。想要说明这个五个方法的作用。就必须明白一个概念——并行归约。前面笔者讲过流是一个内部迭代，也说stream库为我们做一个很多优化的事情。其中一个就是并行。他用到了java 7引入的功能——分支/合并框架。也就是说流会以递归的方式拆分成很多子流，然后子流可以并行执行。最后在俩俩的子流的结果合并成一个最终结果。而这俩俩合并的行为就叫归约 。如图下。引用于《java8实战》

 

 

我们必须根据图上的意思来走。子流的图里面会调用到collector类的三个方法。

• supplier方法：用创建数据存储的地方。
• accumulator方法：用于子流执行过程的迭代工作。即是遍历每一项都会执行。所以可以这里做一些工作。
• finisher方法：返回最后的结果，你可以在这里进一步处理结果。

每一个子流结束这之后，就是俩俩合并。这个时候就要看流的机制图了。

• combiner方法：会传入每一个子流的结果过来，我们就可以在这里在做一些工作。
• finisher方法：返回最后的结果。同上面子流的一样子。

好像没有characteristics什么事情。不是这样子的。这个方法是用来说明当前这个流具备哪些优化。这样子执行流的时候，就可以很清楚的知道要以什么样子的方式执行了。比如并行。
他是一个enum类。值如下

• unordered：这个表示执行过程中结果不受归约和遍历的影响
• concurrent：表示可以多个线和调用accumulator方法。并且可以执行并行。当然前无序数据的才并行。除非收集器标了unordered。
• identity_finish：表示这是一个恒等函数，就是做了结果也一样子。不用做了可以跳过了。

由了上面的讲说明，我们在来写一个自己的收集器吧——去除相同的单词
distinctwordcollector类：

 1 package com.aomi;
 2 
 3 import java.util.arraylist;
 4 import java.util.collections;
 5 import java.util.enumset;
 6 import java.util.list;
 7 import java.util.set;
 8 import java.util.function.biconsumer;
 9 import java.util.function.binaryoperator;
10 import java.util.function.function;
11 import java.util.function.supplier;
12 import java.util.stream.collector;
13 
14 public class distinctwordcollector implements collector<string, list<string>, list<string>> {
15 
16     @override
17     public supplier<list<string>> supplier() {
18         // todo auto-generated method stub
19         return () -> new arraylist<string>();
20     }
21 
22     /**
23      * 子流的处理项的过程
24      */
25     @override
26     public biconsumer<list<string>, string> accumulator() {
27         // todo auto-generated method stub
28         return (list<string> src, string val) -> {
29 
30             if (!src.contains(val)) {
31                 src.add(val);
32             }
33         };
34     }
35 
36     /**
37      * 俩俩并合的执行函数
38      */
39     @override
40     public binaryoperator<list<string>> combiner() {
41         // todo auto-generated method stub
42         return (list<string> src1, list<string> src2) -> {
43             for (string val : src2) {
44                 if (!src1.contains(val)) {
45                     src1.add(val);
46                 }
47             }
48             return src1;
49         };
50     }
51 
52     @override
53     public function<list<string>, list<string>> finisher() {
54         // todo auto-generated method stub
55         return function.identity();
56     }
57 
58     @override
59     public set<characteristics> characteristics() {
60         // todo auto-generated method stub
61         return collections.unmodifiableset(enumset.of(characteristics.identity_finish, characteristics.concurrent));
62     }
63 
64 }

main:

 1 public static void main(string[] args) {
 2         // todo auto-generated method stub
 3 
 4         list<string> words = arrays.aslist("aomi","lili","lucy","aomi","nono");
 5 
 6         list<string> vals = words.stream().collect(new distinctwordcollector());
 7         
 8         for (string val : vals) {
 9             system.out.println(val);
10         }
11     }
12

运行结果

结果确定就是我们想要的——去掉了重复的aomi