1：今天学习的stream的一些函数
toArray()
这个方法是将流中的数据转换为一个数组
image.png
输出结果如：[1,2,3,4,5,6,7,8,9]
toArray(IntFunction<A[]> generator)这个方法是指定创建一个对象数组
image.png
输出结果为[{"name":"张三"},{"name":"李四"}]
这个函数的主要功能将一个流直接转换为一个对象数组
：limit()函数，
入参是一个long的基本类型。如果这个值的大小要超过本身流包含对象的长度，则以流对象长度为主。
image.png
输出结果如：[{"name":"张三"},{"name":"李四"}]
allMatch()函数
判断一个流中元素是否全部满足表达式的判定
入参是一个lamada表达式。这个lamada表达式式一个判断函数。流会将每一个对象进行表达式运算。最终返回一个布尔结果。
这个运算会在遇到第一个不满足的运算或者全部运算完成时候返回。
如下代码所示，判断流中元素是否全部是偶数，当遇到第一个不满足条件的对象时候，直接返回false结果。如果全部是偶数，则会以此将所有对象比较完成，然后返回最终结果。
boolean b = Stream.of(2,4,6,8,9,10,12).allMatch(p -> {
System.out.println(p);
return p % 2 == 0;});
System.out.println(JSONObject.toJSONString(b));
输出结果如下
2 4 6 8 9 false
anyMatch()
判断一个流中是否有满足表达式的判定。如果遇到第一个满足的或者全部运算完成时返回
如下所示，判断流中元素是否有偶数，如果有，则直接返回true。后面的元素不会再进行比较。如果没有则会依次将每个对象比较完成后再返回最终结果。
boolean b = Stream.of(2,4,6,8,9).anyMatch(p -> {
System.out.println(p);
return p % 2 == 0;});
System.out.println(JSONObject.toJSONString(b));
输出结果如下
2 true
count()
返回流中对象的个数
如下代码所示，统计对象的个数，这里有5个对象，这个结果不是去重的。有多少个对象，返回数字几。
long count = Stream.of(2, 4, 6, 8, 9).count();
System.out.println(JSONObject.toJSONString(count));
输出结果如下：
5
distinct()
对流中元素进行去重，返回一个流
如下代码所示，对流中元素进行去重，然后去重后的结果转换为数组后打印结果，全部为不重复的对象。
Object[] objects = Stream.of(2, 4, 6, 8, 9, 4, 6).distinct().toArray();
System.out.println(JSONObject.toJSONString(objects));
输出结果如下：
[2,4,6,8,9]
filter()
对流中的元素通过给定的表达式进行筛选，这里的结果不是筛选掉，而是筛选出
如下代码所示，将流中元素筛选出奇数，最终结果打印是9，1，3
Object[] objects = Stream.of(2, 4, 6, 8, 9, 1,3).filter(p -> p%2!=0).toArray();
System.out.println(JSONObject.toJSONString(objects));
输出结果如下
[9,1,3]
findAny()
从字面含义上来看，是找出任意一个，但是经过多次实验，返回永远是流中的第一个元素。
Optional<Integer> any = Stream.of(1,2, 4, 6, 8, 9, 1, 3).sorted(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return -(o1-o2);
}
}).findAny();
如上代码：进行10000次执行，每次返回的是9.因为这里进行了逆序排序。如果不排序，则每次返回的是第一个元素，通过手工改第一个元素后，始终返回的是第一个元素
findFirst()
返回流中第一个元素，如下所示
Optional<Integer> first = Stream.of(2, 4, 6, 8, 9, 1, 3).findFirst();
System.out.println(first.get());
如上代码，始终返回2
forEach() 和 forEachOrdered()
遍历流对象，通普通的for循环一样。从简单输出看，二者行为是一样的，
Stream.of(2, 4, 6, 8, 9, 1, 3).forEach(System.out::print);
Stream.of(2, 4, 6, 8, 9, 1, 3).forEachOrdered(System.out::print);
如上输出都是流中元素的顺序。
那么二者的区别再哪里呢？看如下代码
ArrayList<Integer> integers = Lists.newArrayList(1, 3, 4, 22, 43, 65, 11, 23, 45, 35);
integers.parallelStream().forEach(System.out::print);
这里如果多次打印，就会发现，每次打印的顺序是不一样的
再看如下代码：
ArrayList<Integer> integers = Lists.newArrayList(1, 3, 4, 22, 43, 65, 11, 23, 45, 35);
integers.parallelStream().forEachOrdered(System.out::print);
这里经过多次打印，就是严格按照流中元素的顺序进行打印的。
如果需要并行处理100万数据，那么我们可以测试下，顺序流和非顺序流的耗时。先生成100万个数，然后用并行流进行顺序消费
再我512G固态，i7 8700k 3.7GHZcpu 16G内存情况下
public static void main(String[] args) {
List<Integer> collect = Stream.iterate(0, n -> n + 1).limit(1000000).collect(Collectors.toList());
for (int i = 0; i <10 ; i++) {
long l = System.currentTimeMillis();
collect.parallelStream().forEachOrdered(n-> System.out.print(""));
long l1 = System.currentTimeMillis();
System.out.println(l1-l);
}
}
分别耗时为下列ms。
78 47 46 47 31 48 85 61 47 62
如果将其中的forEachOrdered替换成forEach
94 78 63 62 78 81 66 85 63 78
性能反而不如顺序消费来的快。 从这个结果来看，二者差距并不大。选用哪个方法，完全依赖于是否需要顺序消费。
今天就学到这里。明天继续
