想要代码变短？还不快学学Stream流操作

学习目标：

掌握Stream

---

学习内容：

1、 简介 2、 什么是流 3、 获取流 4、 流操作

---

学习时间：

2021年1月7日

---

学习产出：

1、 技术笔记 1 遍 2、CSDN 技术博客 1 篇

简介

​ Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后编码效率与大大提高，并且可读性更强。

​ 要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全不同的概念。

简单案例：

public static void main(String[] args) {
    List<Apple> applestore = new ArrayList(); 
    applestore.add(new Apple(1,"red",500,"河南")); 
    applestore.add(new Apple(2,"red",400,"陕西")); 
    applestore.add(new Apple(3,"green",300,"上海")); 
    applestore.add(new Apple(4,"green",200,"湖北")); 
    applestore.add(new Apple(5,"green",100,"湖南")); 
}

我们的需求是在 applestore 集合中找出红色苹果手机.

使用 Stream 流快速实现操作

List<Apple> apples = applestore 
						.stream() 
    					.filter(a -> a.getColor().equals("red")) 
    					.collect(Collectors.toList());

这里使用的就是 Java8 中的 stream 流，使用的是声明性方式写的：说明想要完成什么（筛选，排序，取值），而不说明如何实现一个操作（for 循环）。

同时可以将这些操作链接起来，达到一种流水线式的效果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tYSQgELU-1643120369887)(E:\Users\asus\AppData\Roaming\Typora\typora-user-images\1643118453337.png)]

Java8 中的集合支持一个新的 Stream 方法，它会返回一个流。

什么是流呢

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

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

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

数据处理操作：流更偏向于数据处理和计算，比如 filter、map、find、sort 等。

简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合。

语法：

List<Integer> list = 
		widgets.stream() 
				.filter(b -> b.getColor() == RED) 
				.sorted((x,y) -> x.getWeight() - y.getWeight()) 
				.sum();

获取流

使用Collection接口下的stream()

List<String> list = new ArrayList<>();
list.stream();

使用 Arrays 中的 stream() 方法，将数组转成流

Integer[] arr = new Integer[10];
Arrays.stream(arr);

使用 Stream 中的静态方法：of()

Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

使用 BufferedReader.lines() 方法，将每行内容转成流

BufferedReader reader=new BufferedReader(new FileReader("stream.txt")); 
Stream<String> lineStream = reader.lines();

流操作

流操作可以分为两类：中间操作和终端操作。回看之前的代码

List<Apple> apples = applestore 
				.stream() //获得流 
				.filter(a -> a.getColor().equals("red")) //中间操作 
				.collect(Collectors.toList()); 终端操作

简化一下就是：

​ 数据源 => 中间操作 => 终端操作 => 结果

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

中间操作

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

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

distinct: 去除重复元素

limit(n): 获取 n 个元素

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

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

Stream.of(2,4,1,5,3,7,7,6)
                .distinct()//去重
                .sorted()//进行排序
                .filter((e)->{return e>3;})//过滤筛选
                .skip(0)//跳过n个元素
                .limit(2)//获取n个元素
                .forEach(a-> System.out.println(a));//终端操作输出

终端操作

forEach: 遍历流中的元素

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

Min:返回流中元素最小值

Max:返回流中元素最大值

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

Reduce:所有元素求和

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

findFirst：返回流中第一个元素

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

Object[] objects = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct().sorted()
                .toArray();//将流中的元素倒入一个数组
        System.out.println(objects);

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

        Long count = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct()
                .count();//求元素个数
        System.out.println(count);

        int sum = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct().sorted()
                .reduce((acc, n) -> acc + n)//求元素总和 返回的是Optional 需要get获取值
                .get();
        System.out.println(sum);

        boolean b1 = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct()
                .anyMatch((o2)->{return o2>3;});//如果元素里有一个满足条件的，就返回true
        System.out.println(b1);

        boolean b2 = Stream.of(2, 4, 1, 5, 3, 7, 7, 6)
                .distinct()
                .allMatch((o2)->{return o2>3;});//如果元素所有都满足条件，就返回true
        System.out.println(b1);

使用流操作进行集合之间的转换

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

        list.stream()
                .sorted(((o1, o2) -> {
                    return o1.getNum() - o2.getNum();
                }))
                .map(Apple::getName);//转为一个map


        List<Apple> list1 = list.stream()
                .sorted(((o1, o2) -> {
                    return o1.getNum() - o2.getNum();
                }))
                .collect(Collectors.toList());//转为list集合
        System.out.println(list1);

        Set<Apple> set = list.stream()
                .sorted(((o1, o2) -> {
                    return o1.getNum() - o2.getNum();
                }))
                .collect(Collectors.toSet());//转为set集合
        System.out.println(set);

        Map<Integer,String> map = list.stream()
                .sorted(((o1, o2) -> {
                    return o1.getNum() - o2.getNum();
                }))
                .collect(Collectors.toMap(Apple::getNum,Apple::getName));//转为map集合
        System.out.println(map);
    }