开发者

java8列表中通过stream流根据对象属性去重的三种方式

开发者 https://www.devze.com 2024-08-22 10:26 出处：网络 作者： 我认不到你
目录一、简单去重二、根据对象某个属性去重三、测试哪个方法比较快总结一、简单去重
相关专题：java8对象java8对象属性去重
目录
  • 一、简单去重
  • 二、根据对象某个属性去重
  • 三、测试哪个方法比较快
  • 总结

一、简单去重

public class DistinctTest {
    /**
     * 没有重写 equals 方法
     */
    @Setter
    @Getter
    @ToString
    @AllArgsConstructor
    @NoArgsConstructor
    public static class User {
        private String name;
        private Integer age;
    }

    /**
     * lombok（@Data） 重写了 equals 方法 和 hashCode 方法
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class User2 {
        private String name;
        private Integer age;
    }

    @Test
    public void easyTest() {
        List<Integer> integers = Arrays.asList(1, 1, 2, 3, 4, 4, 5, 6, 77, 77);
        System.out.println("======== 数字去重 =========");
        System.out.print("原数字列表：");
        integers.forEach(x -> System.out.print(x + " "));
        System.out.println();
        System.out.print("去重后数字列表：");
        integers.stream().distinct().collect(Collectors.toList()).forEach(x -> System.out.print(x + " "));

        System.out.println();
        System.out.println();

        List<User> list = Lists.newArrayList();
        User three = new User("张三", 18);
        User three2 = new User("张三", 18);
        User three3 = new User("张三", 24);
        User four = new User("李四", 18);
        list.add(three);
        list.add(three);
        list.add(three2);
        list.add(three3);
        list.add(four);
        System.out.println("======== 没有重写equals方法的话，只能对相同对象（如：three）进行去重，不能做到元素相同就可以去重） =========");
        // 没有重写 equals 方法时，使用的是超类 Object 的 equals 方法
        // 等价于两个对象 == 的比较，只能筛选同一个对象
        System.out.println("初始对象列表：");
        list.forEach(System.out::println);
        System.out.println("简单去重后初始对象列表：");
        list.stream().distinct().collect(Collectors.toList()).forEach(System.out::println);

        System.out.println();
        System.out.println();

        List<User2> list2 = Lists.newArrayList();
        User2 five = new User2("王五", 18);
        User2 five2 = new User2("王五", 18);
        User2 five3 = new User2("王五", 24);
        User2 two = new User2("二蛋", 18);
        list2.add(five);
        list2.add(five);
        list2.add(five2);
        list2.add(five3);
        list2.add(two);
        System.out.println("======== 重写了equals方法的话，可以做到元素相同就可以去重） =========");
        // 所以如果只需要写好 equals 方法 和 hashCode 方法 也能做到指定属性的去重
        System.out.println("初始对象列表：");
        list2.forEach(System.out::println);
        System.out.println("简单去重后初始对象列表：");
        list2.stream().distinct().collect(Collectors.toList()).forEach(System.out::println);
    }
}

二、根据对象某个属性去重

0、User对象

    /**
     * 没有重写 equals 方法
     */
    @Setter
    @Getter
    @ToString
    @AllArgsConstructor
    @NoArgsConstructor
    public static class User {
        private String name;
        private Integer age;
    }

1、使用filter进行去重

    @Test
    public void objectTest() {
        List<User> list = Arrays.asList(
                new User(null, 18),
                new User("张三", null),
                null,
                new User("张三", 24),
                new User("张三5", 24),
                new User("李四", 18)
        );
        System.out.println("初始对象列表：");
        list.forEach(System.out::println);
        System.out.println();
        System.out.println("======== 使用 filter ，根据特定属性进行过滤（重不重写equals方法都不重要） =========");
        System.out.println("根据名字过滤后的对象列表：");
        // 第一个 filter 是用于过滤 第二个 filter 是用于去重
        List<User> collect = list.stream().filter(o -> o != null && o.getName() != null)
                .filter(distinctPredicate(User::getName)).collect(Collectors.toList());
        collect.forEach(System.out::println);
        System.out.println("根据年龄过滤后的对象列表：");
        List<User> collect1 = list.stream().filter(o -> o != null && o.getAge() != null)
                .filter(distinctPredicate(User::getAge)).collect(Collectors.toList());
        collect1.forEach(System.out::println);
    }

    /**
     * 列表对象去重
     */
    public <K, T> Predicate<K> distinctPredicate(Function<K, T> function) {
     http://www.devze.com   // 因为stream流是多线程操作所以需要使用线程安全的ConcurrentHashMap
        ConcurrentHashMap<T, Boolean> map = new ConcurrentHashMap<>();
        return t -> null == map.putIfAbsent(function.apply(t), true);
    }

测试

java8列表中通过stream流根据对象属性去重的三种方式

①、疑惑

  • 既然 filter 里面调用的是 distinctPredicate 方法，而该方法每次都 new 一个新的 map 对象，那么 map 就是新的，怎么能做到可以过滤呢

②、解惑

  • 先看一下http://www.devze.com filter 的部分实现逻辑，他使用了函数式接口 Predicate ，每次调用filter时，会使用 predicate 对象的 test 方法，这个对象的test 方法就是 null == map.putIfAbsent(function.apply(t), true)
  • 而 distinctPredicate 方法作用就是生成了一个线程安全的 Map 集合，和一个 predicate 对象，且该对象的 test 方法为 null == map.putIfAbsent(function.apply(t), true)
  • 之后 stream 流的 filter 方法每次都只会使用 predicate 对象的 test 方法，而该 test 方法中的 map 对象在该流中是唯一的，并不会重新初始化
    @Override
    public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
        Objects.requireNonNull(predicate);
        return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
                                     StreamOpFlag.NOT_SIZED) {
            @Override
            Sink<P_OUT> opWrapSink(int flags, Sink<P_OU编程客栈T> sink) {
                return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
                    @Override
                    public void begin(long size) {
                        downstream.begin(-1);
                    }

                    @Override
                    public void accept(P_OUT u) {
                        if (predicate.test(u))
                            downstream.accept(u);
                    }
                };
            }
        };
    }

2、使用Collectors.toMap() 实现根据某一属性去重（这个可以实现保留前一个还是后一个）

要注意 Collectors.toMap(key,value) 中 value 不能为空，会报错，key 可以为 null，但会被转换为字符串的 “null”

    @Test
    public void objectTest() {
        List<User> list = Arrays.asList(
                new User(null, 18),
                new User("张三", null),
                null,
                new User("张三", 24),
                new User("张三5", 24),
                new User("李四", 18)
        );

        System.out.println("初始对象列表：");
        list.forEach(System.out::println);
        System.out.println();
        System.out.println("======== 使用 Collectors.toMap() 实现根据某一属性去重 =========");
        System.out.println("根据名字过滤后的对象列表 写法1：");
        // (v1, v2) -> v1 的意思 两个名字一样的话（key一样），存前一个 value 值
        Map<String, User> collect = list.stream().filter(Objects::nonNull).collect(Collectors.toMap(User::getName, o -> o, (v1, v2) -> v1));
        // o -> o 也可以写为 Function.identity() ，两个是一样的，但后者可能比较优雅，但阅读性不高,如下
    hsixrsL    // Map<String, User> collect = list.stream().filter(Objects::nonNull).collect(Collectors.toMap(User::getName, Function.identity(), (v1, v2) -> v1));
        List<User> list2 = new ArrayList<>(collect.values());
        list2.forEach(System.out::println);
        System.out.println("根据名字过滤后的对象列表 写法2：");
        Map<String, User> map2 = list.stream().filter(o -> o != null && o.getName() != null)
                .collect(HashMap::new, (m, o) -> m.put(o.getName(), o), HashMap::putAll);
        list2 = new ArrayList<>(map2.values());
        list2.forEach(System.out::println);
        
        System.out.println("根据年龄过滤后的对象列表：");
        // (v1, k2) -> v2 的意思 两个年龄一样的话（key一样），存后一个 value 值
        Map<Integer, User> collect2 = list.stream().filter(Objects::nonNull).collect(Collectors.toMap(User::getAge, o -> o, (v1, v2) -> v2));
        list2 = new ArrayList<>(collect2.values());
        list2.forEach(System.out::println);

    }

测试

java8列表中通过stream流根据对象属性去重的三种方式

3、Collectors.toMap() 的变种 使用 Collectors.collectingAndThen()

Collectors.collectingAndThen() 函数 它可接受两个参数，第一个参数用于 reduce操作，而第二参数用于 map操作。

也就是，先把流中的所有元素传递给第一个参数，然后把生成的集合传递给第二个参数来处理。

    @Test
    public void objectTest() {
        List<User> list = Arrays.asList(
                new User(null, 18),
                new User("张三", null),
                null,
                new User("张三", 24),
                new User("张三5", 24),
                new User("李四", 18)
        );
        System.out.println("初始对象列表：");
        list.forEach(System.out::println);
        System.out.println();
        System.out.println("======== 使用 Collectors.toMap() 实现根据某一属性去重 =========");
        System.out.println("根据名字过滤后的对象列表：");
        ArrayList<User> collect1 = list.stream().filter(o -> o != null && o.getName() != null).collect(
                Collectors.collectingAndThen(Collectors.toMap(User::getName, o -> o, (k1, k2) -> k2), x-> new ArrayList<>(x.values())));
        collect1.forEach(System.out::println);
        System.out.println("======== 或者 ==========");
        List<User> collect = list.stream().filter(o -> o != null && o.getName() != null).collect(
                Collectors.collectingAndThen(Collectors.toCollection(
                        () -> new TreeSet<>(Comparator.comparing(User::getName))), ArrayList<User>::new));
        collect.forEach(System.out::println);
    }

测试

java8列表中通过stream流根据对象属性去重的三种方式

三、测试哪个方法比较快

    @Test
    public void objectTest() {
        List<User> list = new ArrayList<>(Arrays.asList(
                new User(null, 18),
                new User("张三", null),
                null,
                new User("张三", 24),
                new User("张三5", 24),
                new User("李四", 18)
        ));
        for (int i = 0; i < 100000; i++) {
            list.add(new User((Math.random() * 10) + "", (int) (Math.random() * 10)));
        }
        System.out.println("======== 测试速度 =========");
        long startTime = System.currentTimeMillis();
        List<User> list1 = list.stream().filter(o -> o != null && o.getName() != null)
                .filter(distinctPredicate(User::getName)).collect(Collectors.toList());
        long endTime = System.currentTimeMillis();
        System.out.println("filter 用时 ：" + (endTime - startTime));

        System.out.println();
        startTime = System.currentTimeMillis();
        Map<String, User> map1 = list.stream().filter(o -> o != null && o.getName() != null)
                .collect(Collectors.toMap(User::getName, o -> o, (v1, v2) -> v1));
        List<User> list2 = new ArrayList<>(map1.values());
        endTime = System.currentTimeMillis();
        System.out.println("map1 用时 ：" + (endTime - startTime));

        System.out.println();
        startTime = System.currentTimeMillis();
        ArrayList<User> list3 = list.stream().filter(o -> o != null && o.getName() != null).collect(
                Collectors.collectingAndThen(Collectors.toMap(User::getName, o -> o, (k1, k2) -> k2), x -> new ArrayList<>(x.values())));
        endTime = System.currentTimeMillis();
        System.out.println("map2 用时 ：" + (endTime - startTime));

        System.out.println();
        startTime = System.currentTimeMillis();
        List<User> list4 = list.stream().filter(o -> o != null && o.getName() != null).collect(
                Collectors.collectingAndThen(Collectors.toCollection(
                        () -> new TreeSet<>(Comparator.comparing(User::getName))), ArrayList<User>::new));
        endTime = System.currentTimeMillis();
        System.out.println("map3 用时 ：" + (endTime - startTime));

        System.out.println();
        startTime = System.currentTimeMillis();
        Map<String, User> map2 = list.stream().filter(o -> o != null && o.getName() != null)
                .collect(HashMap::new, (m, o) -> m.put(o.getName(), o), HashMap::putAll);
        List<User> list5 = new ArrayList<>(map2.values());
        endTime = System.currentTimeMillis();
        System.out.println("map4 用时 ：" + (endTime - startTime));
    }

测试：

java8列表中通过stream流根据对象属性去重的三种方式

总结

1、去重最快

	ArrayList<User> list3 = list.stream().filter(o -> o != null && o.getName() != null).collect(
                Collectors.collectingAndThen(Collectors.toMap(User::getName, o -> o, (k1, k2) -> k2), x -> new ArrayList<>(x.values())));
	// 或者
	Map<String, User> map2 = list.stream().filter(o -> o != null && o.getName() != null)
                .collect(HashMap::new, (m, o) -> m.put(o.getName(), o), HashMap::putAll);
	List<User> list5 = new ArrayList<>(map2.values());

2、其次

        Map<String, User> map1 = list.stream().filter(o -> o != null && o.getName() != null)
                .collect(Collectors.toMap(User::getName, o -> o, (v1, v2) -> v1));
        List<User> list2 = new ArrayList<>(map1.values());

		// distinctPredicate 是一个方法 本文中有 ，可以 ctrl + f 查找
        List<User> list1 = list.stream().filter(o -> o != null && o.getName() != null)
           python     .filter(distinctPredicate(User::getName)).collect(Collectors.toList());

3、最慢

	List<User> list4 = list.stream().filter(o -> o != null && o.getName() != null).collect(
                Collectors.collectingAndThen(Collectors.toCollection(
                        () -> new TreeSet<>(Comparator.comparing(User::getName))), ArrayList<User>::new));

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。

0

上一篇:

:下一篇

更多 开发 相关资讯：

精彩评论

暂无评论...
登录 注册
Qedev.com
验证码 换一张
取 消

关注公众号

热门标签

图文推荐

mysql字符集引起的java.sql.SQLException:Incorrect string value:问题

mysql字符集引起的java.sql.SQLException:Incorrect string value:问题
解决Feign异步调用丢失上下文问题

解决Feign异步调用丢失上下文问题
一文教会你使用Python来下一场雪

一文教会你使用Python来下一场雪
利用python调整Excel行高和列宽的操作示例

利用python调整Excel行高和列宽的操作示例
Python字符串检索方式

Python字符串检索方式
Android中常见内存泄漏的场景和解决方案详解

Android中常见内存泄漏的场景和解决方案详解
python解析网页上的json数据并保存到EXCEL

python解析网页上的json数据并保存到EXCEL
使用wxPython创建一个文件夹结构生成器

使用wxPython创建一个文件夹结构生成器

开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9