工作中常用的Stream集合处理

AI何哥

已于 2023-05-30 20:39:39 修改

阅读量733

点赞数 2

CC 4.0 BY-SA版权

分类专栏： Java后端开发文章标签： Stream集合处理 Lamdba表达式 Stream list转map 流申明式处理数据集合

于 2023-02-13 23:30:39 首次发布

本文链接：https://blog.csdn.net/CSDN2497242041/article/details/129018116

Java后端开发专栏收录该内容

58 篇文章

订阅专栏

文章介绍了Java8引入的Lambda表达式和StreamAPI如何极大地简化了代码，通过实例展示了如何使用Stream进行过滤、排序、映射、分组等操作，以及如何结合Lambda表达式使代码更加简洁高效。此外，还提到了常用函数式接口如Function、Consumer、Predicate和Supplier的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言：Java8的新特性主要是Lambda表达式和流，当流和Lambda表达式结合起来一起使用时，因为流申明式处理数据集合的特点，它允许把函数作为一个方法的参数，让我们的代码更优雅简洁。

Java8最大的特性就是引入Lambda表达式，即函数式编程，可以将行为进行传递。总结就是：使用不可变值与函数，函数对不可变值进行处理，映射成另一个值。

一、巧用Stream优化老代码

如果有一个需求，需要对数据库查询到的菜肴进行一个处理：

筛选出卡路里小于400的菜肴
对筛选出的菜肴进行一个排序
获取排序后菜肴的名字

菜肴：Dish.java

public class Dish {
    private String name;
    private boolean vegetarian;
    private int calories;
    private Type type;

    // getter and setter
}

Java8以前的实现方式

private List<String> beforeJava7(List<Dish> dishList) {
        List<Dish> lowCaloricDishes = new ArrayList<>();

        //1.筛选出卡路里小于400的菜肴
        for (Dish dish : dishList) {
            if (dish.getCalories() < 400) {
                lowCaloricDishes.add(dish);
            }
        }

        //2.对筛选出的菜肴进行排序
        Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
            @Override
            public int compare(Dish o1, Dish o2) {
                return Integer.compare(o1.getCalories(), o2.getCalories());
            }
        });

        //3.获取排序后菜肴的名字
        List<String> lowCaloricDishesName = new ArrayList<>();
        for (Dish d : lowCaloricDishes) {
            lowCaloricDishesName.add(d.getName());
        }

        return lowCaloricDishesName;
    }

Java8之后的实现方式

private List<String> afterJava8(List<Dish> dishList) {
        return dishList.stream()
                .filter(d -> d.getCalories() < 400)  //筛选出卡路里小于400的菜肴
                .sorted(comparing(Dish::getCalories))  //根据卡路里进行排序
                .map(Dish::getName)  //提取菜肴名称
                .collect(Collectors.toList()); //转换为List
}

不拖泥带水，一气呵成，原来需要写24代码实现的功能现在只需5行就可以完成了，这就是Stream+Lambda表达式之美！

二、工作中常用的Stream+Lambda表达式

1、提取 List 中元素的某一字段生成新的 List

需求：想要将List中实体的某个字段的值提取出来

List<Object> newList = objectList.stream().map(Object::getVar).collect(Collectors.toList());
将object换成你的实体类即可。

//例如：想要将List中Person对象的name提取出来
List<Person> personList = new ArrayList<>();
List<String> nameList = personList.stream().map(Person::getName).collect(Collectors.toList());

2、stream将list转化为map

工作中，我们经常遇到list转map的案例，Collectors.toMap就可以把一个List数组转成一个Map

//1.key和value都是对象中的某个属性值
Map<String, String> userMap1 = userList.stream().collect(Collectors.toMap(User::getId, User::getName));

//2.key是对象中的某个属性值，value是对象本身（使用返回本身的lambda表达式）
Map<String, User> userMap2 = userList.stream().collect(Collectors.toMap(User::getId, User -> User));

//3.key是对象中的某个属性值，value是对象本身（使用Function.identity()的简洁写法）
Map<String, User> userMap3 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));

//4.key是对象中的某个属性值，value是对象本身，当key冲突时选择第二个key值覆盖第一个key值
Map<String, User> userMap4 = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(), (oldValue, newValue) -> newValue));

如果不正确指定Collectors.toMap方法的第三个参数（key冲突处理函数），那么在key重复的情况下该方法会报出【Duplicate Key】的错误导致Stream流异常终止，使用时要格外注意这一点。

举例：

public class TestLambda {

    public static void main(String[] args) {

        List<UserInfo> userInfoList = new ArrayList<>();
        userInfoList.add(new UserInfo(1L, "伟大的何哥", 18));
        userInfoList.add(new UserInfo(2L, "何哥", 27));
        userInfoList.add(new UserInfo(2L, "何弟", 26));

        /**
         *  list 转 map
         *  使用Collectors.toMap的时候，如果有可以重复会报错，所以需要加(k1, k2) -> k1
         *  (k1, k2) -> k1 表示，如果有重复的key,则保留第一个，舍弃第二个
         */
        Map<Long, UserInfo> userInfoMap = userInfoList.stream().collect(Collectors.toMap(UserInfo::getUserId, userInfo -> userInfo, (k1, k2) -> k1));
        userInfoMap.values().forEach(a->System.out.println(a.getUserName()));
    }
}

//运行结果
伟大的何哥
何哥

类似的，还有Collectors.toList()、Collectors.toSet()，表示把对应的流转化为list或者Set。

3、filter()过滤

从数组集合中，过滤掉不符合条件的元素，留下符合条件的元素。

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "何哥", 18));
userInfoList.add(new UserInfo(2L, "何弟", 27));
userInfoList.add(new UserInfo(3L, "何妹", 26));
        
/**
 * filter 过滤，留下超过18岁的用户
 */
List<UserInfo> userInfoResultList = userInfoList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toList());
userInfoResultList.forEach(a -> System.out.println(a.getUserName()));
        
//运行结果
何弟
何妹

4、foreach遍历

foreach 遍历list，遍历map，真的很丝滑。

/**
 * forEach 遍历集合List列表
 */
List<String> userNameList = Arrays.asList("李白", "阿珂", "娜可露露");
userNameList.forEach(System.out::println);
 
HashMap<String, String> hashMap = new HashMap<>();
hashMap.put("中路", "安琪拉");
hashMap.put("上路", "孙策");
hashMap.put("打野", "澜");
/**
 *  forEach 遍历集合Map
 */
hashMap.forEach((k, v) -> System.out.println(k + ":\t" + v));

//运行结果
李白
阿珂
娜可露露
中路: 安琪拉
上路：孙策
打野：澜

5、groupingBy分组

提到分组，相信大家都会想起SQL的group by。我们经常需要一个List做分组操作。比如，按城市分组用户。在Java8之前，是这么实现的：

List<UserInfo> originUserInfoList = new ArrayList<>();
originUserInfoList.add(new UserInfo(1L, "刘备", 18,"北京"));
originUserInfoList.add(new UserInfo(3L, "关羽", 26,"上海"));
originUserInfoList.add(new UserInfo(2L, "张飞", 27,"深圳"));

Map<String, List<UserInfo>> result = new HashMap<>();
for (UserInfo userInfo : originUserInfoList) {
  String city = userInfo.getCity();
  List<UserInfo> userInfos = result.get(city);
  if (userInfos == null) {
      userInfos = new ArrayList<>();
      result.put(city, userInfos);
    }
  userInfos.add(userInfo);
}

而使用Java8的groupingBy分组器，清爽无比:

Map<String, List<UserInfo>> result = originUserInfoList.stream()
.collect(Collectors.groupingBy(UserInfo::getCity));

6、sorted+Comparator 排序

默认升序排序

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "张三", 18));
userInfoList.add(new UserInfo(3L, "李四", 26));
userInfoList.add(new UserInfo(2L, "王麻子", 27));

/**
 *  sorted + Comparator.comparing 排序列表，
 */
userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge)).collect(Collectors.toList());
userInfoList.forEach(a -> System.out.println(a.toString()));

System.out.println("开始降序排序");

/**
 * 如果想降序排序，则可以使用加reversed()
 */
userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge).reversed()).collect(Collectors.toList());
userInfoList.forEach(a -> System.out.println(a.toString()));

//运行结果
UserInfo{userId=1, userName='张三', age=18}
UserInfo{userId=3, userName='李四', age=26}
UserInfo{userId=2, userName='王麻子', age=27}
开始降序排序
UserInfo{userId=2, userName='王麻子', age=27}
UserInfo{userId=3, userName='李四', age=26}
UserInfo{userId=1, userName='张三', age=18}

7、distinct去重

distinct可以去除重复的元素:

List<String> list = Arrays.asList("A", "B", "F", "A", "C");
List<String> temp = list.stream().distinct().collect(Collectors.toList());
temp.forEach(System.out::println);

8、findFirst 返回第一个

findFirst 很多业务场景，我们只需要返回集合的第一个元素即可：

List<String> list = Arrays.asList("A", "B", "F", "A", "C");
list.stream().findFirst().ifPresent(System.out::println);

9、anyMatch是否至少匹配一个元素

anyMatch 检查流是否包含至少一个满足给定谓词的元素。

Stream<String> stream = Stream.of("A", "B", "C", "D");
boolean match = stream.anyMatch(s -> s.contains("C"));
System.out.println(match);
//输出
true

10、allMatch 匹配所有元素

allMatch 检查流是否所有都满足给定谓词的元素。

Stream<String> stream = Stream.of("A", "B", "C", "D");
boolean match = stream.allMatch(s -> s.contains("C"));
System.out.println(match);
//输出
false

11、map转换

map方法可以帮我们做元素转换，比如一个元素所有字母转化为大写，又或者把获取一个元素对象的某个属性，demo如下：

List<String> list = Arrays.asList("jay", "tianluo");
//转化为大写
List<String> upperCaselist = list.stream().map(String::toUpperCase).collect(Collectors.toList());
upperCaselist.forEach(System.out::println);

12、Reduce

Reduce可以合并流的元素，并生成一个值

int sum = Stream.of(1, 2, 3, 4).reduce(0, (a, b) -> a + b);
System.out.println(sum);

13、peek 打印个日志

peek()方法是一个中间Stream操作，有时候我们可以使用peek来打印日志。

List<String> result = Stream.of("何哥", "伟大的何哥", "何弟")
            .filter(a -> a.contains("何哥"))
            .peek(a -> System.out.println("测试:" + a)).collect(Collectors.toList());
System.out.println(result);
//运行结果
测试:何哥
测试:伟大的何哥
[何哥，伟大的何哥]

14、Max，Min最大最小

使用lambda流求最大，最小值，非常方便。

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "后羿", 18));
userInfoList.add(new UserInfo(3L, "鲁班", 26));
userInfoList.add(new UserInfo(2L, "虞姬", 27));

Optional<UserInfo> maxAgeUserInfoOpt = userInfoList.stream().max(Comparator.comparing(UserInfo::getAge));
maxAgeUserInfoOpt.ifPresent(userInfo -> System.out.println("max age user:" + userInfo));

Optional<UserInfo> minAgeUserInfoOpt = userInfoList.stream().min(Comparator.comparing(UserInfo::getAge));
minAgeUserInfoOpt.ifPresent(userInfo -> System.out.println("min age user:" + userInfo));

//运行结果
max age user:UserInfo{userId=2, userName='虞姬', age=27}
min age user:UserInfo{userId=1, userName='后羿', age=18}

15、count统计

一般count()表示获取流数据元素总数。

List<UserInfo> userInfoList = new ArrayList<>();
userInfoList.add(new UserInfo(1L, "吕布", 18));
userInfoList.add(new UserInfo(3L, "貂蝉", 26));
userInfoList.add(new UserInfo(2L, "董卓", 27));

long count = userInfoList.stream().filter(user -> user.getAge() > 18).count();
System.out.println("大于18岁的用户:" + count);
//输出
大于18岁的用户:2

16、字符串拼接

如果将所有学生的名字拼接起来，怎么做呢？通常只能创建一个StringBuilder，循环拼接。使用Stream，使用Collectors.joining()简单容易。

public class JoiningTest {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>(3);
        students.add(new Student("路飞", 22, 175));
        students.add(new Student("红发", 40, 180));
        students.add(new Student("白胡子", 50, 185));

         String names = students.stream()
             .map(Student::getName).collect(Collectors.joining(",","[","]"));
        System.out.println(names);
    }
}
//输出结果
//[路飞,红发,白胡子]

joining接收三个参数，第一个是分界符，第二个是前缀符，第三个是结束符。也可以不传入参数Collectors.joining()，这样就是直接拼接。

17、Stream流，修改List＜String＞和 List＜对象＞

a、修改List＜String＞

 /**
  * List<String> 无法for循环修改  用jdk8新特性  stream流
  */

 List<String> list = Arrays.asList("1" , "1" ,"1" ,"1" ,"1" ,"1");
 
 // 给 list 元素都添加 2 标识
 System.out.println(list.stream().map(x -> x+2).collect(Collectors.toList()));

输出：[12, 12, 12, 12, 12, 12]

b、修改List＜对象＞

List<DataX> dataXES = JSON.parseArray(payload, DataX.class);
            dataXES = dataXES.stream().peek(x -> x.setTss("11111"))).collect(Collectors.toList());

三、流的操作类型和常用函数式接口

流的操作类型主要分为两种：

1、中间操作

一个流可以后面跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的，仅仅调用到这类方法，并没有真正开始流的遍历，真正的遍历需等到终端操作时，常见的中间操作有filter、map等。

2、终端操作

一个流有且只能有一个终端操作，当这个操作执行后，流就被关闭了，无法再被操作，因此一个流只能被遍历一次，若想在遍历需要通过源数据在生成流。终端操作的执行，才会真正开始流的遍历。如下面即将介绍的count、collect等。

3、常用函数式接口

其实lambda离不开函数式接口，我们来看下JDK8常用的几个函数式接口：

Function<T, R>（转换型）: 接受一个输入参数，返回一个结果
Consumer<T> （消费型）: 接收一个输入参数，并且无返回操作
Predicate<T> （判断型）: 接收一个输入参数，并且返回布尔值结果
Supplier<T> （供给型）: 无参数，返回结果

Function<T, R> 是一个功能转换型的接口，可以把将一种类型的数据转化为另外一种类型的数据

    private void testFunction() {
        //获取每个字符串的长度，并且返回
        Function<String, Integer> function = String::length;
        Stream<String> stream = Stream.of("何哥", "伟大的何哥", "程序员何哥");
        Stream<Integer> resultStream = stream.map(function);
        resultStream.forEach(System.out::println);
    }

Consumer<T>是一个消费性接口，通过传入参数，并且无返回的操作

   private void testComsumer() {
        //获取每个字符串的长度，并且返回
        Consumer<String> comsumer = System.out::println;
        Stream<String> stream = Stream.of("何哥", "伟大的何哥", "程序员何哥");
        stream.forEach(comsumer);
    }

Predicate<T>是一个判断型接口,并且返回布尔值结果.

    private void testPredicate() {
        //获取每个字符串的长度，并且返回
        Predicate<Integer> predicate = a -> a > 18;
        UserInfo userInfo = new UserInfo(2L, "Java后端何哥", 27);
        System.out.println(predicate.test(userInfo.getAge()));
    }

Supplier<T>是一个供给型接口,无参数，有返回结果。

    private void testSupplier() {
        Supplier<Integer> supplier = () -> Integer.valueOf("666666");
        System.out.println(supplier.get());
    }

这几个函数在日常开发中，也是可以灵活应用的，比如我们DAO操作完数据库，是会有个result的整型结果返回。我们就可以用Supplier<T>来统一判断是否操作成功。如下：

    private void saveDb(Supplier<Integer> supplier) {
        if (supplier.get() > 0) {
            System.out.println("插入数据库成功");
        }else{
            System.out.println("插入数据库失败");
        }
    }
    
    @Test
    public void add() throws Exception {
        Course course=new Course();
        course.setCname("java");
        course.setUserId(100L);
        course.setCstatus("Normal");
        saveDb(() -> courseMapper.insert(course));
    }

参考链接：

巧用Stream优化老代码，太清爽了！