Stream流（简化开发）

Stream流

什么是 Stream？

Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把 它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后 编码效率与大大提高，并且可读性更强。 要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全不同的概念.

简单案例:

我们的需求是在 applestore 集合中找出红色苹果手机. 使用 Stream 流快速实现操作

这里使用的就是 Java8 中的 stream 流，使用的是声明性方式写的：说明想 要完成什么（筛选，排序，取值），而不说明如何实现一个操作（for 循环）。 同时可以将这些操作链接起来，达到一种流水线式的效果：

什么是流呢？

简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。

**元素列表:**和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。

**数据源 😗*获取数据的源，比如集合。

**数据处理操作 **:流更偏向于数据处理和计算，比如 filter、map、find、sort 等。 简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一 系列流操作，最后再构建成我们需要的数据集合

获取流

//获取流
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();     

        Integer[] arr = new Integer[10];
        Stream<Integer> stream1 = Arrays.stream(arr);

        Stream.of(2,4,1,5,3,7,6);
        //这就是一个流 然后进行中间操作 对流进行各种操作

操作流

流操作可以分为两类：中间操作和终端操作

简化一下就是：

诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终 端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。

中间操作

filter：过滤流中的某些元素,

sorted(): 自然排序，流中元素需实现 Comparable 接口

distinct: 去除重复元素

limit(n): 获取 n 个元素

skip(n): 跳过 n 元素，配合 limit(n)可实现分页

map(): 将其映射成一个新的元素

终端操作

forEach: 遍历流中的元素

toArray:将流中的元素倒入一个数组

Min:返回流中元素最小值

Max:返回流中元素最大值

count:返回流中元素的总个数

Reduce:所有元素求和

anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回

falseallMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false

findFirst：返回流中第一个元素

collect:将流中的元素倒入一个集合,Collection 或 Map

案例：

（1）过滤比3大的元素排序并去重 filter（） sorted（） distinct（） forEach（）

//操作
        Stream.of(2,4,1,5,3,7,6)
              .filter((e) -> { return e>3;})//过滤比3大的元素
              .sorted() //排序
              .distinct() //去重
              .forEach((a) -> {
                  System.out.println(a);
              }); //遍历

结果：

（2）找出最大的元素 max（）.get()

 Integer max = Stream.of(2,4,1,5,3,7,6)
              .distinct()
              .max((o1,o2) -> {return o1-o2;})
              .get();
        System.out.println(max);

结果：

（3）求各元素之和 reduce().get()

 Integer sum = Stream.of(2,4,1,5,3,7,6)
                .distinct()
                .reduce((o1,o2) -> {return o1+o2;})
                .get();
        System.out.println(sum);

结果：

**（4）判断所有元素是否满足条件 anyMatch() allMatch() **

  boolean res = Stream.of(2,4,1,5,3,7,6)
                .distinct()
                .anyMatch((e) -> {return e>3;});  //存在满足条件的返回true
                //.allMatch((e) -> {return e>3;});   所有满足条件的返回true
        System.out.println(res);

结果：

（5） 获取跳过的和限制条件过的元素 skip() limit()

Stream.of(1, 4, 6, 8, 7, 5, 7)
                .filter((e)->{return e>3;})
                .sorted()    //排序
                .distinct()    //去重
                .skip(2)    //跳过两个元素
                .limit(2)     //只获取两个元素
                .forEach((a)->{
                    System.out.println(a);
                });

结果：

map，collect使用

普通类：

public class streamDemo2 {

    public static void main(String[] args) {
        List<Apple> alist=new ArrayList<>();
        alist.add(new Apple(100,"苹果0","红色"));
        alist.add(new Apple(101,"苹果1","蓝色"));
        alist.add(new Apple(102,"苹果2","绿色"));
        alist.add(new Apple(103,"苹果3","黑色"));
        alist.add(new Apple(104,"苹果4","粉色"));
        alist.add(new Apple(105,"苹果5","墨绿色"));


        alist.stream().map(Apple::getNum).forEach((e)->{
            System.out.println(e);
        });      //将此列表中的每个元素的子元素映射成为新的元素


        List<Apple> alist2 = alist.stream()
                .sorted((o1, o2) -> {
                    return o2.getNum() - o1.getNum();
                })
                .collect(Collectors.toList());       //将list数据按照指定规则排序然后放到新集合中

        System.out.println(alist2);

        Set<Apple> set1 = alist.stream()
                .sorted((o1, o2) -> {
                    return o2.getNum() - o1.getNum();
                })
                .collect(Collectors.toSet());      //将list结合按照指定规则排序后放入set集合中

        System.out.println(set1);

        Map<Integer, String> map1 = alist.stream()
                .sorted((o1, o2) -> {
                    return o2.getNum() - o1.getNum();
                })
                .collect(Collectors.toMap(Apple::getNum, Apple::getName));  
        //将list集合按照指定规则排序然后以将每个元素的子元素按照一定方式的组合放入map键值对集合中
        System.out.println(map1);
    }
}

注：

注：
流在使用的时候一般都是与Lambda匿名函数一起组合使用的