Stream流常用方法

小鱼儿 2023-10-08 17:27 49阅读 0赞

## 一、简介 ##

### 1.什么是Stream ###

Stream是数据渠道，用于操作数据源所生成的元素序列，它可以实现对集合的复杂操作，例如过滤、排序和映射等。

(1).集合是一种静态的数据结构，存储在内存中，而Stream是通过CPU来实现计算的(并不会存储数据)

(2).Stream不会改变源对象，而是返回一个新的持有结果的Stream(不可变)

### 2.为什么要使用Stream ###

在实际开发中，项目中的很多数据都来源于关系型数据库(例如MySQL、Oracle等)，使用SQL的条件语句就可以实现对数据的筛选、过滤等操作。但也有很多数据来源于非关系型数据库(例如Redis、MongoDB等)，想要处理这些数据，往往需要在Java层面去操作。

而Stream API就提供了对集合中数据的操作，类似于SQL执行的数据库查询。简单来说，Stream API提供了一种高效且易于使用的数据处理方式。

### 3.Stream操作的执行流程 ###

(1).创建Stream对象:通过一个数据源(例如集合、数组)创建一个流

(2).中间操作:一个中间的链式操作，对数据源的数据进行处理(例如过滤、排序等)，直到执行终止操作才执行(Stream操作是延迟执行的)

(3).终止操作:一旦执行终止操作，就执行中间的链式操作，并产生结果

## 二、具体使用方法 ##

### 1.实体类User ###

@Data
    @EqualsAndHashCode(callSuper = false)
    @Accessors(chain = true)
    public class User implements Serializable {
            public User(String name, String age, int height) {
                this.name = name;
                this.age = age;
                this.height = height;
            }
            private String name;
            private String age;
            private int height;
    }

### 2.创建3个user ###

@RestController
    @RequestMapping("/user")
    public class UserController {
        // 创建三个user
        User user1 = new User("小张", "18", 180);
        User user2 = new User("小杨", "18", 175);
        User user3 = new User("小陈", "19", 170);
    }

### 3.将user放到list中 ###

#### (1).普通方法： ####

public void test(){
            List<User> userList = new ArrayList<>();
            userList.add(user1);
            userList.add(user2);
            userList.add(user3);
        }

#### **(2).Stream流：创建动态list，可以添加元素** ####

// stream流，创建的是动态数组，可以添加元素
    List<User> userList = Stream.of(user1, user2, user3).collect(Collectors.toList());

### 4.**取对象的某一列：** ###

我取出list中所有user的name属性放到一个新的list中：

#### **(1).**普通方法： ####

// 遍历
    List<String> userNameList = new ArrayList<>();
    for (User user : userList) {
        userNameList.add(user.getName());
    }

#### **(2).**Stream流：map ####

// Stream流
    List<String> userNameList = userList.stream().map(User::getName).collect(Collectors.toList());

### 5.**过滤，或者说是根据一个判断条件筛选出目标对象** ###

我要筛选出userList中name不为空的user

#### **(1).**普通方法： ####

List<User> newUserList = new ArrayList<>();
    // if判断
    for (User user : userList) {
        if(user.getName() != null) {
            newUserList.add(user); 
        }
    }

#### **(2).**Stream流：filter ####

// 获取userName不为空的user的List
    List<User> userList = userList.stream().filter(user-> user.getName() != null).collect(Collectors.toList());

### 6.**分组** ###

把userList中的user根据年龄分组

#### **(1).**普通方法： ####

Map<String, List<User>> map = new HashMap<>();
    // if判断
    for (User user : userList) {
        if (map.get(user.getAge()) == null) {
            map.put(user.getAge(), new ArrayList());
        }
        map.get(user.getAge()).add(user);
    }

#### **(2).**Stream流：groupingBy ####

Map<String, List<User>> map =userList.stream().collect( Collectors.groupingBy(User::getAge, Collectors.toList()));

### 7.**求和** ###

double max = userList.stream().mapToDouble(User::getHeight).sum();

### 8.**Map、List互转** ###

list转map

#### **(1).**普通方法： ####

Map<String, User> userMap = new Map<>();
        for (User user : userList) {
            userMap.put(user.getName(), user);
        }

#### **(2).**stream流： ####

用Collectors的toMap方法转换List，一般会遇到两个问题。

##### （1）转换map，key重复问题 #####

代码中使用(key1,key2)->key2表达式可以解决此类问题，如果出现重复的key就使用key2覆盖前面的key1,也可以定义成(key1,key2)->key1，保留key1,根据自己的业务场景来调整。

##### （2）空指针异常，即转为map的value是null #####

这个可以用filter过滤；

### 9.map转list ###

#### (1).普通方法： ####

List<User> userList = new List<>();
        for (String userName : userMap.keySet()) {
            userList.add(userMap.get(userName));
        }

#### (2).**stream流：** ####

List<User> userList = userMap.entrySet().stream().map(e ->e.getValue()).collect(Collectors.toList());

### 10.**做判断** ###

#### **(1).anyMatch()：** ####

allMatch：判断条件里的元素，所有的都是，返回true；

比如上面的userlList，我想判断是否全部height > 175的：

userList.stream().allMatch(user -> user.getHeight() > 175);

#### **(2).allMatch()：** ####

allMatch：判断条件里的元素，所有的都是，返回true；

比如上面的userlList，我想判断是否全部height > 175的：

userList.stream().allMatch(user -> user.getHeight() > 175);

#### (3).**noneMatch()：** ####

与allMatch相反，判断条件里的元素，所有的都不是，返回true

userList.stream().noneMatch(user -> user.getHeight() > 175);

#### (4).**求取目标和：** ####

userList.stream().filter(user -> user.getHeight() > 175).count();

### 11.**合并List** ###

#### (1).**合并多个一维List：** ####

List<Integer> list1 = Arrays.asList(1, 2, 3);
       List<Integer> list2 = Arrays.asList(4, 5, 6);
       List<Integer> list3 = Arrays.asList(7, 8, 9);
       List<Integer> mergedList = Stream.of(list1, list2, list3).flatMap(Collection::stream).collect(Collectors.toList());
       System.out.println(mergedList);
    //打印结果： [1, 2, 3, 4, 5, 6, 7, 8, 9]

#### (2).**合并嵌套List：** ####

List<String> list1 = Arrays.asList("张三", "李四", "王麻子");
       List<String> list2 = Arrays.asList("111", "222", "333");
       // 合并前
       List<List<String>> lists = Arrays.asList(list1, list2);
       System.out.println(lists);//打印结果：[[张三,李四,王麻子],[111,222,333]]
       
       // 合并后
       List<String> mergedList = lists.stream().flatMap(Collection::stream).collect(Collectors.toList());
       System.out.println(mergedList);//打印结果：[张三,李四,王麻子,111,222,333]

### 12.**分页** ###

Map<String,Object> map = Maps.newHashMap();
        List list = new ArrayList();
        //list -> 当前页所有数据
        map.put("list",list.stream().skip((long) (pageNo - 1) * pageSize).limit(pageSize).collect(Collectors.toList()));
        //count -> 记录总条数
        map.put("count",list.size());

## 三、总结 ##

Stream流相较于传统的foreach的方式处理stream，到底有啥优势、劣势：

#### (1).优势： ####

1.代码更简洁，偏声明式的编码风格，更容易体现出代码的逻辑意图；

2.逻辑间解耦，一个Stream中间处理逻辑，无需关注上游与下游的内容，只需要按约定实现自身逻辑即可；

3.并行流场景效率会比迭代器逐个循环更高；

4.函数式接口，延迟执行的特性，中间管道操作不管有多少步骤都不会立即执行，只有遇到终止操作的时候才会开始执行，可以避免一些中间不必要的操作消耗。

#### (2).劣势： ####

1.代码调测debug不便；

2.程序员从历史写法切换到Stream流时，需要一定的适应时间；

3.可能没学过或者初学者看不懂Stream流。

以上是个人学习记录，如有错误，请指正！