JDK1.8新特性(二)

Stream API

什么是Stream API
Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。
使用Stream API对集合数据进行操作，就类似于使用sql执行的数据库查询。也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式。
为什么要使用Stream API
实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。
Stream 和 Collection集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。
什么是 Stream
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
“集合讲的是数据，Stream讲的是计算！”
Stream 的操作三个步骤
1- 创建 Stream
一个数据源（如：集合、数组），获取一个流
2- 中间操作
一个中间操作链，对数据源的数据进行处理
3- 终止操作(终端操作) 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
步骤一：创建Stream
stream的创建方式有四种
第一种：通过集合

 public void test(){
        List<String> list=new ArrayList<>();
        Stream<String> stream = list.stream();
    }

第二种：通过数组

  public void test(){
        int[] arr={1,2,3,4,5,6};
        IntStream stream = Arrays.stream(arr);
    }

第三种：通过Stream的of

public void test(){
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
    }

第四种：创建无限流

  public void test(){
        //迭代
        Stream<Integer> limit = Stream.iterate(0, t -> t + 2).limit(10);
        //生成
        Stream<Double> limit1 = Stream.generate(Math::random).limit(10);
    }

步骤二：中间操作
操作一：filter过滤，接收 Lambda ， 从流中排除某些元素

public void test(){
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        integerStream.filter(e->e!=5).forEach(System.out::println);
    }

操作二：distinct去重，筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

   public void test(){
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        integerStream.distinct().forEach(System.out::println);
    }

操作三：limit截取，截断流，使其元素不超过给定数量

  public void test() {
    Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
    integerStream.limit(3).forEach(System.out::println);
}

操作四：skip，跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        integerStream.skip(3).forEach(System.out::println);
    }

操作五：map映射，接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

  public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        integerStream.map(e->e+2).forEach(System.out::println);
    }

操作六：sorted，产生一个新流，其中按自然顺序排序

 public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        integerStream.sorted().forEach(System.out::println);
    }

另外sorted(Comparator com) 产生一个新流，其中按比较器顺序排序

步骤三：终止操作
操作一：allMatch(Predicate p) 检查是否匹配所有元素

  public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        boolean b = integerStream.allMatch(e -> e > 3);
    }

操作二：anyMatch(Predicate p) 检查是否至少匹配一个元素

 public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        boolean b = integerStream.anyMatch(e -> e > 3);
    }

操作三：noneMatch(Predicate p) 检查是否没有匹配所有元素

 public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        boolean b = integerStream.noneMatch(e -> e > 3);
    }

操作四：findFirst() 返回第一个元素

public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        Optional<Integer> first = integerStream.findFirst();
    }

操作五：findAny() 返回当前流中的任意元素

 public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        Optional<Integer> any = integerStream.findAny();
    }

操作六：count() 返回流中元素总数

public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        long count = integerStream.count();
    }

操作七：max(Comparator c) 返回流中最大值

 public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        Optional<Integer> max = integerStream.max(Math::max);
    }

操作八：min(Comparator c) 返回流中最小值

public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        Optional<Integer> max = integerStream.min(Math::min);
    }

操作九：forEach(Consumer c)内部迭代

  public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        integerStream.forEach(System.out::println);
    }

操作十：reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一
个值。返回 T

 public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        Integer reduce = integerStream.reduce(10, Integer::sum);
    }

reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一
个值。返回 Optional

操作十一：collect(Collector c)将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

 public void test() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 5, 5, 6, 7);
        List<Integer> collect = integerStream.collect(Collectors.toList());
    }