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）、判断一个流中元素是否全部满足表达式的判定

　　　2）、入参是一个lamada表达式。这个lamada表达式式一个判断函数。流会将每一个对象进行表达式运算。最终返回一个布尔结果。

　　　3）、这个运算会在遇到第一个不满足的运算或者全部运算完成时候返回。

// 判断流中元素是否全部是偶数，当遇到第一个不满足条件的对象时候，直接返回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则是一个必须将表达式统一包装到一个流的表达式。

　　1）、map函数式对流中的每一个元素进行遍历然后进行运算，返回一个新的流对象。这里需要注意，foreach也是遍历运算，区别在于foreach在于纯消费，没有返回值。而map是运算后将结果返回给新的流。

    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