JavaJava8中的Stream

Posted 2022-06-21 sysu_lluozh

一、Stream的理解

Stream是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等

在Java8中Stream API作为数据渠道，用于操作数组或者集合等数据源。流本身是不存储数据的，只是移动数据，在移动过程中可能会对数据进行过滤，排序或者其它操作，但是，大多数情况下，流操作本身不会修改数据源，比如，对流排序不会修改数据源的顺序。它只是会创建一个新的流，其中包含排序后的结果

在java中称Stream为流，经常会用流去对集合进行一些流水线的操作。stream就像工厂一样，只需要把集合、命令还有一些参数灌输到流水线中去，就可以加工成得出想要的结果。这样的流水线能大大简洁代码，减少操作

二、Stream的流程

原集合 —> 流  —> 各种操作(过滤、分组、统计) —> 终端操作

Stream流的操作流程一般都是：

1. 将集合转为流
2. 经过各种操作，比如过滤、筛选、分组、计算
3. 终端操作，转化成想要的数据(数据的形式一般是集合，有时也会按照需求输出count计数)
   

三、Stream的特点

1. 可以“存储”有限个或无限个元素
   这里的存储打了引号，是因为元素有可能已经全部存储在内存中，也有可能是根据需要实时计算出来

2. 一个Stream可以轻易地转换为另一个Stream，而不是修改原Stream本身

3. 真正的计算通常发生在最后结果的获取，也就是惰性计算
   惰性计算的特点是：一个Stream转换为另一个Stream时，实际上只存储转换规则，并没有任何计算发生

四、Stream的方法

Stream定义的方法如下

五、Stream的操作符

Stream的操作符大体上分为两种：中间操作符和终止操作符

5.1 中间操作符

对于数据流来说，中间操作符在执行制定处理程序后，数据流依然可以传递给下一级的操作符

中间操作符包含8种(排除parallel和sequential，这两个操作并不涉及到对数据流的加工操作)：

1. map(mapToInt,mapToLong,mapToDouble)
   转换操作符，把比如A->B，这里默认提供了转int，long，double的操作符

2. flatmap(flatmapToInt,flatmapToLong,flatmapToDouble)
   拍平操作，比如把 int[]2,3,4 拍平变成 2，3，4，也就是从原来的一个数据变成了3个数据，这里默认提供了拍平成int、long、double的操作符

3. limit
   限流操作，比如数据流中有10个，只要出前3个就可以使用

4. distint
   去重操作，对重复元素去重，底层使用equals方法

5. filter
   过滤操作，把不想要的数据过滤

6. peek
   挑出操作，如果想对数据进行某些操作，如：读取、编辑修改等

7. skip
   跳过操作，跳过某些元素

8. sorted(unordered)
   排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器

5.2 终止操作符

数据经过中间加工操作，就轮到终止操作符上场
终止操作符用来对数据进行收集或者消费的，数据到了终止操作这里就不会向下流动，终止操作符只能使用一次

1. collect
   收集操作，将所有数据收集起来，官方的提供的Collectors提供了非常多收集器，Stream的核心在于Collectors

2. count
   统计操作，统计最终的数据个数

3. findFirst、findAny
   查找操作，查找第一个、查找任何一个，返回的类型为Optional

4. noneMatch、allMatch、anyMatch
   匹配操作，数据流中是否存在符合条件的元素返回值为bool值

5. min、max
   最值操作，需要自定义比较器，返回数据流中最大最小的值

6. reduce
   规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce

7. forEach、forEachOrdered
   遍历操作，这里就是对最终的数据进行消费

8. toArray
   数组操作，将数据流的元素转换成数组

六、API功能举例

首先，定义一个用户对象，包含姓名、年龄、性别和籍贯四个成员变量：

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Log4j
@Builder
public class User 
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private Integer sex;
    //所在省市
    private String address;

这里用lombok简化了实体类的代码

然后创建需要的 集合数据 ，也就是源数据：

//1.构建我们的list
List<User> list= Arrays.asList(
        new User("钢铁侠",40,0,"华盛顿"),
        new User("蜘蛛侠",20,0,"华盛顿"),
        new User("赵丽颖",30,1,"湖北武汉市"),
        new User("詹姆斯",35,0,"洛杉矶"),
        new User("李世民",60,0,"山西省太原市"),
        new User("蔡徐坤",20,1,"陕西西安市"),
        new User("葫芦娃的爷爷",70,0,"山西省太原市")
);

6.1 过滤

6.1.1 stream()/parallelStream() 创建流

创建流：

• stream() : 串行流
• parallelStream（）: 并行流

6.1.2 filter 过滤(T-> boolean)

比如要过滤年龄在40岁以上的用户，可以这样写：

List<User> filterList = list.stream().filter(user -> user.getAge() >= 40)
        .collect(toList());

filter里面，->箭头后面跟着的是一个 boolean值 ，可以写任何的过滤条件，就相当于sql中where后面的语句，换句话说， 能用sql实现的功能这里都可以实现

打印如下：

6.1.3 distinct 去重

和sql中的distinct关键字很相似。为了看到效果此处在原集合中加入一个重复的

List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿"),
                new User("钢铁侠",40,0,"华盛顿"),
                new User("蜘蛛侠",20,0,"华盛顿"),
                new User("赵丽颖",30,1,"湖北武汉市"),
                new User("詹姆斯",35,0,"洛杉矶"),
                new User("李世民",60,0,"山西省太原市"),
                new User("蔡徐坤",18,1,"陕西西安市"),
                new User("葫芦娃的爷爷",70,0,"山西省太原市")
);

//distinct 去重
List<User> distinctList = filterList.stream().distinct()
        .collect(toList());

打印结果：

6.1.4 sorted排序

如果流中的元素的类实现了Comparable接口，即有自己的排序规则，那么可以直接调用 sorted()方法对元素进行排序，如：

Comparator.comparingInt

反之, 需要调用sorted((T, T) -> int)实现Comparator接口

@Data
@NoArgsConstructor
@AllArgsConstructor
@Log4j
@Builder
public class User 
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private Integer sex;
    //所在省市
    private String address;

    public static void main(String[] args) 
        List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿"),
                new User("蜘蛛侠",20,0,"华盛顿"),
                new User("赵丽颖",30,1,"湖北武汉市"),
                new User("詹姆斯",35,0,"洛杉矶"),
                new User("李世民",60,0,"山西省太原市"),
                new User("蔡徐坤",18,1,"陕西西安市"),
                new User("葫芦娃的爷爷",70,0,"山西省太原市")
        );

        //sorted()
        List<User> sortedList = list.stream().sorted(Comparator.comparingInt(User::getAge))
                .collect(toList());
    

打印结果：

结果按照年龄从小到大进行排序

6.1.5 limit返回前n个元素

如果想知道这里面年龄最小的是谁，可作如下操作：

//limit 返回前n个元素
List<User> limitList = sortedList.stream().limit(1)
        .collect(toList());

6.1.6 skip跳过

与limit恰恰相反，skip的意思是跳过，也就是去除前n个元素

@Data
@NoArgsConstructor
@AllArgsConstructor
@Log4j
@Builder
public class User 
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private Integer sex;
    //所在省市
    private String address;

    public static void main(String[] args) 
        List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿"),
                new User("蜘蛛侠",20,0,"华盛顿"),
                new User("赵丽颖",30,1,"湖北武汉市"),
                new User("詹姆斯",35,0,"洛杉矶"),
                new User("李世民",60,0,"山西省太原市"),
                new User("蔡徐坤",18,1,"陕西西安市"),
                new User("葫芦娃的爷爷",70,0,"山西省太原市")
        );

        //skip 跳过前n个元素
        List<User> skipList = list.stream().skip(2).collect(toList());
    

打印结果：

前两个人都被去除，列表中剩下5个

6.2 映射

6.2.1 map(T->R)

map是将T类型的数据转为R类型的数据，比如想要设置一个新的list，存储用户所有的城市信息

@Data
@NoArgsConstructor
@AllArgsConstructor
@Log4j
@Builder
public class User 
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private Integer sex;
    //所在省市
    private String address;

    public static void main(String[] args) 
        List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿"),
                new User("蜘蛛侠",20,0,"华盛顿"),
                new User("赵丽颖",30,1,"湖北武汉市"),
                new User("詹姆斯",35,0,"洛杉矶"),
                new User("李世民",60,0,"山西省太原市"),
                new User("蔡徐坤",18,1,"陕西西安市"),
                new User("葫芦娃的爷爷",70,0,"山西省太原市")
        );

        //map(T->R)
        List<String> cityList = list.stream().map(User::getAddress).distinct().collect(toList());
    

打印结果：

6.2.2 flatMap(T -> Stream)

将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流

//flatMap(T -> Stream<R>)
        List<String> flatList = new ArrayList<>();
        flatList.add("唱,跳");
        flatList.add("rape,篮球,music");
        flatList = flatList.stream().map(s -> s.split(",")).flatMap(Arrays::stream).collect(toList());

打印结果：

这里原集合中的数据由逗号分割，使用split进行拆分后，得到的是Stream，字符串数组组成的流，要使用flatMap

Arrays::stream

将Stream转为Stream,然后把流相连接，组成了完整的唱、跳、rap、篮球和music

6.3 查找

6.3.1allMatch(T->boolean)

检测是否全部满足参数行为，假如这些用户是网吧上网的用户名单，那就需要检查是不是每个人都年满18周岁

boolean isAdult = list.stream().allMatch(user -> user.getAge() >= 18);

打印结果：

true

6.3.2 anyMatch(T->boolean)

检测是否有任意元素满足给定的条件，比如，想知道同学名单里是否有女生

//anyMatch(T -> boolean） 是否有任意一个元素满足给定的条件
boolean isGirl = list.stream().anyMatch(user -> user.getSex() == 1);

打印结果：

true

说明集合中有女生存在

6.3.3 noneMatch(T -> boolean)

流中是否有元素匹配给定的T -> boolean条件

比如检测有没有来自巴黎的用户

boolean isLSJ = list.stream().noneMatch(user -> user.getAddress().contains("巴黎"));

打印结果：

true

打印true说明没有巴黎的用户

6.3.4 findFirst( )找到第一个元素

Optional<User> fristUser  = list.stream().findFirst();

打印结果：

User(name=钢铁侠, age=40, sex=0, address=华盛顿)

6.3.5 findAny()找到任意一个元素

Optional<User> anyUser  = list.stream().findAny();

打印结果：

User(name=钢铁侠, age=40, sex=0, address=华盛顿)

这里发现findAny返回的也总是第一个元素，那么为什么还要进行区分呢？因为在并行流 parallelStream()中找到的确实是任意一个元素

Optional<User> anyParallelUser  = list.parallelStream().findAny();

打印结果 :

Optional[User(name=李世民, age=60, sex=0, address=山西省太原市)]

6.4 归纳计算

6.4.1 求用户的总人数

long count = list.stream().collect(Collectors.counting());

可以简写为：

long count = list.stream().count();

运行结果：

7

6.4.2 得到某一属性的最大最小值

// 求最大年龄
Optional<User> max = list.stream().collect(Collectors.maxBy(
Comparator.comparing(User::getAge)));
// 求最小年龄
Optional<User> min = list.stream().collect(Collectors.minBy(
Comparator.comparing(User::getAge)));

运行结果：

6.4.3 求年龄总和

// 求年龄总和
int totalAge = list.stream().collect(Collectors.summingInt(User::getAge));

运行结果：

273

经常会用BigDecimal来记录金钱，假设想得到BigDecimal的总和：

// 获得列表对象金额， 使用reduce聚合函数,实现累加器
BigDecimal sum = myList.stream().map(User::getMoney).reduce(BigDecimal.ZERO,BigDecimal::add);

6.4.4 求年龄平均值

//求年龄平均值
double avgAge = list.stream().collect(Collectors.averagingInt(User::getAge));

运行结果

39.0

6.4.5 一次性得到元素的个数、总和、最大值、最小值

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.JavaJava8中的Stream

 JavaJava8中的Stream
 JavaJava8新特性之接口默认方法与静态方法
 远程监控在钢铁废水处理系统中的应用
 秀恩爱分得快，你觉得在《葫芦娃》中有哪些比较凄美的爱情故事？
 钢铁少女 无限钻石安卓版下载 和 源代码部署成功