Java8 Stream流的实战超神操作

置顶 已于 2023-11-25 14:42:26 修改
阅读量5.2k 收藏 42
点赞数 10
分类专栏： java8 文章标签： java8去重 java8 stream流 java8集合交集，并集，差集 stream流去重 stream流分组，转map
于 2021-09-02 16:40:48 首次发布
版权声明：本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/w2462140956/article/details/120064611
版权

 一、描述

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

stream()操作将集合转换成一个流，filter()执行我们自定义的筛选处理，这里是通过lambda表达式筛选出所有偶数，最后我们通过collect()对结果进行封装处理，并通过Collectors.toList()指定其封装成为一个List集合返回。 

下面所有的实例都源自于开发实战总结，集合元素为对象实例。主要通过对象的某些属性进行操作，举一反三即可。下面所有的举例对象均为熟悉的学生对象。

二、单个集合操作

1、排序操作

1）、通过对学生对象中的某个属性进行排序（升序，降序）操作。

2）、注意：使用stream流排序时不改变原集合！但是下面代码提供了一种改变排序后对象的集合操作方式。

public class DTest {

    @Data
    @AllArgsConstructor
    class User {
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest() {
        // 这是一个自定义集合
        ArrayList<User> users = Lists.newArrayList();
        users.add(new User("小明", "男", 12));
        users.add(new User("小明", "女", 10));
        users.add(new User("小红", "女", 14));
        users.add(new User("小红", "男", 10));
        // 根据年龄升序
        List<User> collect1 = users.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
        System.out.println(collect1);
        //[User(name=小明, sex=女, age=10), User(name=小红, sex=男, age=10), User(name=小明, sex=男, age=12), User(name=小红, sex=女, age=14)]
        
        // 根据年龄降序
        List<User> collect2 = users.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());
        System.out.println(collect2);
        //[User(name=小红, sex=女, age=14), User(name=小明, sex=男, age=12), User(name=小明, sex=女, age=10), User(name=小红, sex=男, age=10)]

        // 按年龄，姓名升序排序
        List<User> collect3 = users.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getName)).collect(Collectors.toList());
        System.out.println(collect3);
        //[User(name=小明, sex=女, age=10), User(name=小红, sex=男, age=10), User(name=小明, sex=男, age=12), User(name=小红, sex=女, age=14)]

        // 在List集合内部排序，改变原来的集合元素顺序
        // 按年龄倒序
        collect3.sort(Comparator.comparing(User::getAge).reversed());
        System.out.println(collect3);
        //[User(name=小红, sex=女, age=14), User(name=小明, sex=男, age=12), User(name=小明, sex=女, age=10), User(name=小红, sex=男, age=10)]

    }
}

2、分组操作

1)、提供对学生对象的某个属性（例如姓名）进行分组的操作，分组后为Map对象。

2）、对于分组后的结果，可以对结果集合进行表达式计算，例如计算平均分等。

public class DTest {

    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users = Lists.newArrayList();
        users.add(new User("小明", "男", 12));
        users.add(new User("小明", "女", 10));
        users.add(new User("小红", "女", 14));
        users.add(new User("小红", "女", 12));
        users.add(new User("小红", "男", 10));


        // 分组结果
        Map<String, List<User>> groupBy = users.stream().collect(Collectors.groupingBy(User::getName));
        System.out.println(groupBy);
        //{小明=[DTest.User(name=小明, sex=男, age=12), DTest.User(name=小明, sex=女, age=10)],小红=[DTest.User(name=小红, sex=女, age=14), DTest.User(name=小红, sex=女, age=12), DTest.User(name=小红, sex=男, age=10)]}

        
        // 以年龄分组，分组结果只保留姓名属性
        Map<Integer, List<String>> groupedByAge = users.stream()
                    .collect(Collectors.groupingBy(User::getAge,
                            Collectors.mapping(User::getName, Collectors.toList())));
        System.out.println(groupedByAge);
        // {10=[小明, 小红], 12=[小明, 小红], 14=[小红]}


        // 分组平均值结果
        Map<String, Double> avgGroup = users.stream().collect(Collectors.groupingBy(User::getName, Collectors.averagingInt(User::getAge)));
        System.out.println(avgGroup);
        // {小明=11.0, 小红=12.0}

        // 分组总数值结果
        Map<String, Integer> sumGroup = users.stream().collect(Collectors.groupingBy(User::getName, Collectors.summingInt(User::getAge)));
        System.out.println(sumGroup);
        // {小明=22, 小红=36}
        
    }
}

3、List集合转Map

1）、提供对学生对象某个属性进行提取，转换为Map对象，Map对象可能存在Key值重复导致报错，所以下方个例举例了，冲突时保留策略。

2）、提供对集合的转Map时，同时可以抽取部分属性自定义Map的 value 值。

public class DTest {

    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users = Lists.newArrayList();
        users.add(new User("小明", "男", 12));
        users.add(new User("小明", "女", 10));
        users.add(new User("小红", "女", 14));
        users.add(new User("小红", "女", 12));
        users.add(new User("小红", "男", 10));
      
        // List转Map, 遇到相同的key, k值则保留第一次遇到的值
        Map<String, User> toMapK1 = users.stream().collect(Collectors.toMap(User::getName, a -> a, (k1,k2) -> k1));
        System.out.println(toMapK1);
        // {小明=DTest.User(name=小明, sex=男, age=12), 小红=DTest.User(name=小红, sex=女, age=14)}

        // k值保留第二次遇见的数据
        Map<String, User> toMapK2 = users.stream().collect(Collectors.toMap(User::getName, a -> a, (k1,k2) -> k2));
        System.out.println(toMapK2);
        //{小明=DTest.User(name=小明, sex=女, age=10), 小红=DTest.User(name=小红, sex=男, age=10)}

        // 取对象中的两个属性组成Map
        Map<String, String> collect = users.stream().collect(Collectors.toMap(User::getName, a -> a.getSex(), (k1, k2) -> k2));
        System.out.println(collect);
        //{小明=女, 小红=男}


    }
}

4、去重演示

开发过程中经常需要需要去重的情况，其中主要比较棘手的是List集合中的元素，根据元素的某个属性或多个属性去重！以下代码演示！

1）、对象单个属性去重

举例了根据学生对象中的某个属性值去重，默认保留第一次遇到的。所以如果有保留的某些需求。可以先对集合进行排序。

public class DTest {

    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users = Lists.newArrayList();
        users.add(new User("小明", "男", 12));
        users.add(new User("小明", "女", 10));
        users.add(new User("小红", "女", 14));
        users.add(new User("小红", "女", 12));
        users.add(new User("小红", "男", 10));
        // 根据User.name属性值去重
        ArrayList<User> userList = users.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getName))), ArrayList::new));
        
        // 按顺序保留了第一次遇到name
        System.out.println(userList);
        //[DTest.User(name=小明, sex=男, age=12), DTest.User(name=小红, sex=女, age=14)]

    }
}

2）、对个多个属性组合去重

举例了根据学生对象中的多个属性值组合来去重，默认保留第一次遇到的。所以如果有保留的某些需求。可以先对集合进行排序。

public class DTest {

    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users = Lists.newArrayList();
        users.add(new User("小明", "男", 12));
        users.add(new User("小明", "女", 10));
        users.add(new User("小红", "女", 14));
        users.add(new User("小红", "女", 12));
        users.add(new User("小红", "男", 10));
        // 根据User.name和User.sex 两个属性值组合去重
        List<User> userList= users.stream().collect(
                Collectors.collectingAndThen(Collectors.toCollection(() ->
                        new TreeSet<>(Comparator.comparing(o -> o.getName() + ";" + o.getSex()))
                ), ArrayList::new));

        // 按顺序保留了第一次遇到name+sex，结果去掉了12岁的小红
        System.out.println(userList);
        //[DTest.User(name=小明, sex=女, age=10), DTest.User(name=小明, sex=男, age=12), DTest.User(name=小红, sex=女, age=14), DTest.User(name=小红, sex=男, age=10)]
    }
}

5、Map元素遍历

1）、通过map()方法遍历返回集合中对象某个属性的集合。

2）、通过map()方法遍历，对遍历对象进行操作，然后返回自定义的集合。

public class DTest {

    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users = Lists.newArrayList();
        users.add(new User("小明", "男", 12));
        users.add(new User("小明", "女", 10));

        // 获取年龄数组
        List<Integer> collect = users.stream().map(User::getAge).collect(Collectors.toList());
        // 按顺序获取年龄
        System.out.println(collect);
        // [12, 10]

        // 对元素的属性进行操作
        List<User> userList = users.stream().map(e -> {
            e.setName("小红");
            return e;
        }).collect(Collectors.toList());
        // 全部改名
        System.out.println(userList);
        // [DTest.User(name=小红, sex=男, age=12), DTest.User(name=小红, sex=女, age=10)]


    }
}

6、Filter 根据条件过滤元素

1）、学生对象单个属性自定义规则筛选，返回集合。

2）、学生对象属性自定义规则筛选，对筛选结果进行自定义截取，返回最终的集合。

3）、学生对象多个属性自定义规则筛选，返回集合。

public class DTest {

    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest() {
        // 这是一个自定义集合
        ArrayList<User> users = Lists.newArrayList();
        users.add(new User("小明", "男", 12));
        users.add(new User("小明", "男", 10));
        users.add(new User("小红", "女", 14));

        // 单属性筛选: 姓名为小明的人
        List<User> user1 = users.stream().filter(e -> e.getName().equals("小明")).collect(Collectors.toList());
        System.out.println(user1);
        // [DTest.User(name=小明, sex=男, age=12), DTest.User(name=小明, sex=男, age=10)]

        /**
         *  筛选结果扩展:
         *      limit(n): 返回另一个不超过给定大小的流,取前几个;超过集合大小则返回所有;
         *      skip(n) : 返回丢弃前n个元素的流,如果流中的元素少于n个，则返回空流;
         */
        List<User> user2 = users.stream().filter(e -> e.getName().equals("小明")).limit(1).collect(Collectors.toList());
        System.out.println(user2);
        // [DTest.User(name=小明, sex=男, age=12)]

        List<User> user3 = users.stream().filter(e -> e.getName().equals("小明")).skip(1).collect(Collectors.toList());
        System.out.println(user3);
        // [DTest.User(name=小明, sex=男, age=10)]


        /**
         * 多属性筛选: 姓名为小明，年龄=10的人
         */
        List<User> user4 = users.stream().filter(e -> {
            if (e.getName().equals("小明") && e.getAge() == 10) {
                return true;
            }
            return false;
        }).collect(Collectors.toList());
        System.out.println(user4);
        // [DTest.User(name=小明, sex=男, age=10)]
    }
}

7、reduce 聚合方法

Stream.reduce() 是 Stream 的一个聚合方法，它可以把一个Stream 的所有元素按照聚合函数聚合成一个结果。常用可以进行累加累减少！

 案例主要是举例进行了累加，累减，字符串拼接操作，具体的通用规则也可以自定义。

public class DTest {

    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users = Lists.newArrayList();
        users.add(new User("小明", "男", 12));
        users.add(new User("小明", "女", 10));
        users.add(new User("小红", "女", 14));

        // 从0开始累加：0为设置的初始值
        Integer collect1 = users.stream().map(User::getAge).reduce(0, (a, b) -> a + b);
        System.out.println(collect1);    // 36

        // 从设置的初始值12进行累减
        Integer collect2 = users.stream().map(User::getAge).reduce(12, (a, b) -> a - b);
        System.out.println(collect2);    // -24

        // 建名字进行字符串拼接
        String collect3 = users.stream().map(User::getName).reduce("姓名集：", (a, b) -> a + b);
        System.out.println(collect3);    // 姓名集：小明小明小红

    }
}

二、多个集合操作

集合之间的关系基本如下。一图秒解，下面的实例基本以元素对象的某个或多个属性进行讲解，基本来源于实战总结。

交集：A & B，即A与B ( x x　( 😊 😊 ) x　x　)
并集：A | B， 即A或B ( 😊 😊 ( 😊 😊 ) 😊 😊 )
差集：A - B， 即A减B ( 😊 😊 ( x　x )　x　x　）
补集：A ^ B，即A异B ( 😊 😊 ( x x )　😊 😊　）

1、并集

并集的核心解题思路是，首先是将两个集合合并，然后对合并结果去重，上面教程元素单属性去重，元素自定义多属性去重，可往上查看。

1）、基本类型元素去重并集

1. 使用Stream.concat()方法将 list1 和 list2 合并成一个Stream对象。
2. 使用Stream.distinct() 方法去重，保留不同的学生对象。
3. 使用Collectors.toList()方法将Stream对象转换成List<>对象，存储到resultList中。

注意：Stream.distinct()方法去重自定义对象，例如Student等，Student类需要实现equals()和hashCode()方法，否则不能正确去重。

@Test
public void dTest(){
    // 这是一个自定义集合list1
    ArrayList<Integer> list1 = Lists.newArrayList();
    list1.add(22);
    list1.add(23);
    // 这是一个自定义集合list2
    ArrayList<Integer> list2 = Lists.newArrayList();
    list1.add(23);
    list1.add(24);
    List<Integer> resultList = Stream.concat(list1.stream(), list2.stream())
            .distinct()
            .collect(Collectors.toList());
    System.out.println(ArrayUtil.toString(resultList));
    // 运行结果：[22, 23, 24]
}

2）、自定义对象属性去重并集

如下是举例了根据元素指定的单个属性去重，如果根据多个属性去重，则看回上面的教程查看。

class DTest {
    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users1 = Lists.newArrayList();
        users1.add(new User("小明", "男", 12));
        users1.add(new User("小华", "男", 10));
        users1.add(new User("小红", "女", 14));

        // 这是一个自定义集合
        ArrayList<User> users2 = Lists.newArrayList();
        users2.add(new User("小明", "男", 12));
        users2.add(new User("小华", "男", 16));
        users2.add(new User("小青", "女", 16));
        /**
         * 使用TreeSet去重，最后将结果转换为ArrayList集合并返回。
         * 其中，Comparator.comparing()方法用于指定按照Age进行排序。根据指定的排序字段去重
         */
        List<User> resultList = Stream.concat(users1.stream(), users2.stream())
                .collect(Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getAge))),
                        ArrayList::new));
        resultList.forEach(System.out::println);
        /*
        打印结果：
            DTest.User(name=小华, sex=男, age=10)
            DTest.User(name=小明, sex=男, age=12)
            DTest.User(name=小红, sex=女, age=14)
            DTest.User(name=小华, sex=男, age=16)
         */
    }

}

2、交集

 1）、元素对象所有属性匹配交集

class DTest {
    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users1 = Lists.newArrayList();
        users1.add(new User("小明", "男", 12));
        users1.add(new User("小华", "男", 10));
        users1.add(new User("小红", "女", 14));

        // 这是一个自定义集合
        ArrayList<User> users2 = Lists.newArrayList();
        users2.add(new User("小明", "男", 12));
        users2.add(new User("小华", "男", 16));
        users2.add(new User("小青", "女", 16));
        /**
         * 使用filter条件筛选（选取两者集合互相包含的元素），最后将结果转换为ArrayList集合并返回。
         */
        List<User> resultList = users1.stream()
                .filter(users2::contains)
                .collect(Collectors.toList());
        resultList.forEach(System.out::println);
        /*
          打印结果：
            DTest.User(name=小明, sex=男, age=12)
         */
    }
    
}

2）、元素对象指定属性交集

在filter过滤器中，使用自定义匹配规则，两个集合中被规则匹配中的元素则为交集。

class DTest {
    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users1 = Lists.newArrayList();
        users1.add(new User("小明", "男", 12));
        users1.add(new User("小华", "男", 10));
        users1.add(new User("小红", "女", 14));

        // 这是一个自定义集合
        ArrayList<User> users2 = Lists.newArrayList();
        users2.add(new User("小明", "男", 12));
        users2.add(new User("小华", "男", 16));
        users2.add(new User("小青", "女", 16));
        /**
         * 使用filter条件筛选（选取两者集合指定的匹配规则），最后将结果转换为ArrayList集合并返回。
         */
        List<User> resultList = users1.stream()
                .filter(s1 -> users2.stream()
                        .anyMatch(s2 -> s1.getName().equals(s2.getName()) && s1.getSex().equals(s2.getSex())))
                .collect(Collectors.toList());
        resultList.forEach(System.out::println);
        /*
          打印结果：
            DTest.User(name=小明, sex=男, age=12)
            DTest.User(name=小华, sex=男, age=10)
         */
    }

}

3、差集

 在filter过滤器中，使用自定义匹配规则，排除两个集合中被规则匹配中的元素则为差集。

class DTest {
    @Data
    @AllArgsConstructor
    class User{
        String name;
        String sex;
        int age;
    }

    @Test
    public void dTest(){
        // 这是一个自定义集合
        ArrayList<User> users1 = Lists.newArrayList();
        users1.add(new User("小明", "男", 12));
        users1.add(new User("小华", "男", 10));
        users1.add(new User("小红", "女", 14));

        // 这是一个自定义集合
        ArrayList<User> users2 = Lists.newArrayList();
        users2.add(new User("小明", "男", 12));
        users2.add(new User("小华", "男", 16));
        users2.add(new User("小青", "女", 16));
        /**
         * 使用filter条件筛选（排除两者集合指定的匹配规则选中的元素），最后将结果转换为ArrayList集合并返回。
         */
        List<User> resultList = users1.stream()
                .filter(s1 -> users2.stream()
                        .noneMatch(s2 -> s1.getName().equals(s2.getName()) && s1.getSex().equals(s2.getSex())))
                .collect(Collectors.toList());
        resultList.forEach(System.out::println);
        /*
          打印结果：
            DTest.User(name=小红, sex=女, age=14)
         */
    }

}

自古圣贤皆寂寞
关注
  • 10
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
stream流不同的几种去重方式
weixin_57533260的博客
12-14 9313
System.out.println("指定age属性去重（方法一）：");System.out.println("指定age属性去重（方法二）：");System.out.println("指定age属性去重（方法三）：");System.out.println("整个对象去重：");// 一个集合中放入4个学生对象。3、使用比较方法针对对象中的某个字段去重。4、使用比较方法根据对象中的多个字段去重。// 按整个个对象去重。// 指定某个字段去重。// 方法二（用循环)根据对象中的某个字段去重。
java stream去重的几种方式
热门推荐
zml_666的博客
05-17 1万+
java stream去重的几种方式
java 8 Stream（流)(1)
最新发布
2301_79099416的博客
04-28 738
1、背景java 8 新特性Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
Java 使用 Stream 去重
Agony921的博客
06-14 7940
在项目中可以会获取到一个集合，集合中有很多重复的数据，但是总感觉转成Set去重不太体面，那就可以试试使用 Stream 来实现根据对象的属性进行去重将集合转为Stream流后通过Collectors.toMap 进行去重。
java stream 对象去重
想吃大盘鸡
11-30 5788
复杂对象去重
java Stream去重操作
weixin_38860401的博客
06-28 2765
网上找的stream流去重方法，可以根据类的某个属性去重，这里记录一下。
Java中采用stream新特性进行去重
dmber的博客
04-24 2909
如何用stream进行去重？
Java8 Stream flatmap中间操作用法解析
08-18
Java8 Stream flatmap中间操作用法解析 Java8 中的 Stream API 是一个功能强大且灵活的数据处理工具，flatmap 是 Stream 中的一种中间操作，它可以对 Stream 中的单个元素进行拆分（切片），从而生成一个新的 ...
Java8之Stream流代替For循环操作
08-24
Java8之Stream流代替For循环操作 Java8中引入了Stream流代替For循环操作，具有很好的参考价值，希望对大家有所帮助。Stream流代替For循环进行输出可以使代码更简洁。 Stream流的优点 1. 代码简洁：使用Stream流...
Java8新特性Stream流实例详解
08-29
Java 8 中引入了 Stream 流，用于操作数据源（集合、数组等）所生成的元素序列。Stream 流是数据渠道，具有声明性、可复合、可并行三个特性，使得 Stream 操作更简洁、更灵活、高效。Stream 可分为并行流与串行流，...
浅谈java8 stream flatMap流的扁平化操作
08-24
浅谈 Java8 Stream flatMap 流的扁平化操作 Java8 中的 Stream 是一个新概念，它不是输入输出的 Stream 流，而是一种用函数式编程方式在集合类上进行复杂操作的工具。Stream 提供了两种操作：中间操作和终止操作。...
分享几种 Java8 中通过 Stream 对列表进行去重的方法
BASK2312的博客
11-23 1万+
以上便是我要分享的几种关于列表去重的方法，当然这里没有进行更为详尽的性能分析，希望以后会深入底层再重新分析一下。如有纰漏，还望不吝赐教。
java中用stream进行去重，排序，分组
拒绝熬夜啊的博客
01-20 1万+
java中用stream进行去重，排序，分组
Java8通过stream对列表去重
weixin_44012070的博客
07-17 4101
distinct()方法使用hashCode()和equals()方法来获取不同的元素。也就是说，可以通过重写定制的hashCode()和equals()方法来达到特殊需求的去重。3.1 方式一：Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet(Comparator.comparing(Student::getName))), ArrayList::new)1、Stream的distinct()方法。
java8 列表通过 stream流 根据对象属性去重的三种实现方法
我认不到你的博客
01-19 6358
java8 列表通过 stream流 根据对象属性去重的三种实现方法，并比较每个方法的去重速度
Java8 stream流操作: 去重,排序,筛选,分组,聚合计算
qq_41902662的博客
02-18 9918
java 8 stream流操作List,Map
Java8 stream处理List集合的相同部分(交集)、去重！
Java精选
08-17 6610
Java8的新特性——Stream常用于处理集合，它不会改变集合原有的结构，优点是Stream的代码会比用for循环处理简洁不少本文主要说的是：获取两个List集合的交集、差集、去重文章目录两个集合的交集差集去重list.stream()是构造方法一、两个集合的交集例如：找出两个班 名字相同的学生publicclassStudent{ privateStringstudentNo;...
Stream和Lambda表达式最佳实践
04-24
Stream和Lambda表达式是Java 8引入的两个重要特性，它们极大地简化了集合处理和函数式编程的复杂性。以下是关于Stream和Lambda表达式的最佳实践介绍： Lambda表达式 Lambda表达式允许我们以简洁的方式表示匿名函数。最佳实践包括： 保持简洁：Lambda表达式应尽可能简洁，避免冗长的代码块。 避免副作用：Lambda表达式通常不应修改外部状态或具有副作用，以保持其纯函数性质。 类型推断：尽量利用Java的类型推断功能，避免显式指定Lambda表达式的参数类型。 Stream API Stream API提供了一种高效且声明式的方式来处理集合数据。最佳实践包括： 链式操作：利用Stream的链式操作，可以流畅地组合多个转换和过滤操作。 并行处理：对于大型数据集，考虑使用并行流（parallel streams）来加速处理。但要注意，并非所有操作都适合并行化，需要根据具体情况进行选择。 中间操作与终止操作：明确区分Stream的中间操作和终止操作。中间操作会返回一个新的Stream，而终止操作会生成一个结果或副作用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值