JDK1.8 Stream
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果
一、创建流
1、 Collection接口有默认的stream方法，这个也就是大家平时用的list.stream()，只要是这个接口的实现类都可以通过这种方式去创建一个流
Lists.newArrayList().stream();
2、Stream的静态方法
// 1、通过 build 方法创建
Stream.Builder builder = Stream.builder(); builder.accept(1); builder.add(2); Stream build = builder.build();
// 2、通过Stream.of 方法创建
// of有2个重载的方法，一个是接受一个对象，一个是接受可变参数创建流 Stream s1 = Stream.of(1); Stream s2 = Stream.of(1,2,3,4,5);
// 3、通过Stream.generate 静态方法去创建一个流。这个特别需要注意，这个方法是创建无限流，如果不在调用这个函数后调用limit方法去限制流的长度，则会无限创建下去
// 这里传入的行为参数一定是有返回值的，也就是行为的结果是创建了一个对象。
Stream generate = Stream.generate(Math::random).limit(10); Stream g2 = Stream.generate(() -> Math.random()).limit(10);
// 4、通过Stream.iterate 迭代的去创建流，同上也是无限流，不同的地方在于这个函数有2个参数，第一个参数是基值，第二个参数是基于第一个参数的运算函数。如下生成自然数序列
// 这里iterate，会迭代的进行第二个参数的运算，
Stream limit = Stream.iterate(0, n -> n +1).limit(10);
// 5、 Stream.empty()创建一个空的流
// 6、Stream.concat(arg1,arg2) 将2个流合并为一个流
二、函数
1、toArray (IntFunction<A[]> generator) 这个方法是指定创建一个对象数组 （ 这个方法是将流中的数据转换为一个数组 ）
2、limit()函数：入参是一个long的基本类型。如果这个值的大小要超过本身流包含对象的长度，则以流对象长度为主。
3、allMatch()函数 ：
1）、判断一个流中元素是否全部满足表达式的判定
// 判断流中元素是否全部是偶数，当遇到第一个不满足条件的对象时候，直接返回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
4、 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
5、count() 返回流中对象的个数
6、distinct() 对流中元素进行去重，返回一个流7、filter() 对流中的元素通过给定的表达式进行筛选，这里的结果不是筛选掉，而是筛选出 （即：不删除）
8、findAny() 从字面含义上来看，是找出任意一个，但是经过多次实验，返回永远是流中的第一个元素。
9、findFirst() 返回流中第一个元素，如下所示
10、forEach() 和 forEachOrdered() 遍历流对象，通普通的for循环一样。从简单输出看，二者行为是一样的，foreach在于纯消费，没有返回值。
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 性能反而不如顺序消费来的快。 从这个结果来看，二者差距并不大。选用哪个方法，完全依赖于是否需要顺序消费。
11、map()和flatmap()函数： map和flatmap函数入参都是一个Function函数。从函数上看二者不同在于，map函数是普通的表达式运算，而flatmap则是一个必须将表达式统一包装到一个流的表达式。
List<String> strings = Lists.newArrayList("hello", "world","apple");
List<String> collect = strings.stream().map(s -> s += ":").collect(Collectors.toList());
System.out.println(strings);
System.out.println(collect);
输出入下：说明不影响原来的对象状态
[hello, world, apple]
[hello:, world:, apple:]
2）、flatmap是一个处理更高纬度的操作。map函数只能处理一层纬度，返回的也是一层纬度。而flatmap可以处理多层纬度，然后返回一维。
比如我们需要将一个二维list转换为1纬list。那么用flatmap通过一个很简单的函数就可以直接转换。
List<List<String>> listList = Lists.newArrayList(); listList.add(Lists.newArrayList("apple", "mi","huawei")); listList.add(Lists.newArrayList("dell", "lenvo","isony")); listList.add(Lists.newArrayList("tmall", "jd","qq")); List<Object> collect = listList.stream().flatMap(s -> s.stream()).collect(Collectors.toList()); System.out.println(JSONObject.toJSONString(collect)); 输出结果如下： ["apple","mi","huawei","dell","lenvo","isony","tmall","jd","qq"]
还是以上面的例子，那么如果我想继续拆成单个字母的数组呢？可以通过继续再进行一次flatmap运算即可。也就是flatmap的功能主要是将一个维度减少一层。
List<Object> collect = listList.stream(). flatMap(s -> s.stream()). flatMap(b -> Stream.of(b.split("|"))). distinct(). collect(Collectors.toList()); System.out.println(JSONObject.toJSONString(collect)); 输出结果如下： ["a","p","l","e","m","i","h","u","w","d","n","v","o","s","y","t","j","q"]
12、flatmapToDouble、int、long 是将对象直接映射成对于的类型：
比如一系列特定分割符的字符串，(实际应用场景中，我们有一种场景是给用户设置限额，限额分为不同等级。和对应系统约定好限额配置规则，则只需要一行代码就可以解释完成。)
List<String> strings = Lists.newArrayList("123/456","789/123","456/789");
double[] doubles = strings.stream().
flatMapToDouble(s -> Stream.of(s.split("/")).mapToDouble(e -> Double.valueOf(e))). toArray();
System.out.println(JSONObject.toJSONString(doubles));
输出结果如下：
[123.0,456.0,789.0,123.0,456.0,789.0]
13、max方法和min方法获取流中最大值最小值,这里可以传入自定义实现的Comparator实现类进行自定义排序。
List<Integer> Integers = Lists.newArrayList(1,4,99,5,55,23); Optional<Integer> max = Integers.stream().max((a,b) -> a.compareTo(b)); Optional<Integer> min = Integers.stream().min((a,b) -> a.compareTo(b)); System.out.println(JSONObject.toJSONString(max.get())); System.out.println(JSONObject.toJSONString(min.get()));
14、noneMatch 判断是否都不匹配。如果是，则返回true，如果不是则返回false
List<Integer> Integers = Lists.newArrayList(1,3,5,7); boolean b = Integers.stream().noneMatch(a -> a % 2 == 0); System.out.println(b);
b结果为 true
15、peek 对流中元素做处理，不返回。对应和map区别，map会将处理返回，peek处理后不返回。
List<Integer> collect = Stream.of(1, 3, 5, 6, 7).peek(a -> a = a + 1).collect(Collectors.toList());
System.out.println(JSONObject.toJSONString(collect));
输出结果如下：
[1,3,5,6,7]
16、skip函数，入参是一个long基本类型，效果是忽略流中指定个元素。如果超过流的长度，则会返回流
List<Integer> collect = Stream.of(1, 3, 5, 6, 7).skip(7).collect(Collectors.toList()); System.out.println(JSONObject.toJSONString(collect)); 输出结果如下：会把流中前7个元素全部忽略掉，所以输出一个空的数组 [] List<Integer> collect = Stream.of(1, 3, 5, 6, 7).skip(2).collect(Collectors.toList()); System.out.println(JSONObject.toJSONString(collect)); 输出结果如下: 会把前2个元素给忽略掉，然后返回后面的元素。 [5,6,7]
17、sorted，对流中元素进行排序。不指定排序方式，按照默认的方式排序。可以自定义排序方式
List<Integer> collect = Stream.of(99, 5, 47, 34, 2).sorted().collect(Collectors.toList());
System.out.println(JSONObject.toJSONString(collect));
输出结果如下:
[2,5,34,47,99]
18、reduce函数 1：reduce(BinaryOperator<P_OUT> accumulator) ：https://www.jianshu.com/p/35ab18451a52
浙公网安备 33010602011771号