Java 你还在用list.contain做去重? 你是故意的还是不小心的?

这篇具有很好参考价值的文章主要介绍了Java 你还在用list.contain做去重? 你是故意的还是不小心的?。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

前言

最近又是一轮代码review , 发现了一些实现去重的代码,在使用 lsit.contain ......

如:
Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

我沉思,是不是其实很多初学者也存在这种去重使用问题?

所以我选择把这个事情整出来,分享一下。

正文


首先是造出一个 List<String> 模拟数据,一共2W条,里面有一半数据1W条是重复的:

    public static List<String> getTestList() {
        List<String> list = new ArrayList<>();
        for (int i = 1; i <= 10000; i++) {
            list.add(String.valueOf(i));
        }
        for (int i = 10000; i >= 1; i--) {
            list.add(String.valueOf(i));
        }
        return list;
    }

先看看 我们用contain 去重的 代码:

    /**
     * 使用 list.contain 去重
     *
     * @param testList
     */
    private static void useContain2Distinct(List<String> testList) {
        System.out.println("contains 开始去重,条数:" + testList.size());
        List<String> testListDistinctResult = new ArrayList<>();
        for (String str : testList) {
            if (!testListDistinctResult.contains(str)) {
                testListDistinctResult.add(str);
            }
        }
        System.out.println("contains 去重完毕,条数:" + testListDistinctResult.size());
    }

我们调用一下看看耗时:

    public static void main(String[] args) {
        List<String> testList = getTestList();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        useContainDistinct(testList);
        stopWatch.stop();
        System.out.println("去重 最终耗时" + stopWatch.getTotalTimeMillis());
    }

耗时:
Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

 评价: list.contain 的效率,我的建议是,知道就行,别用。


众所周知Set 不存在 重复数据, 所以我们来看看 使用HashSet去重的性能:
ps: 这里是采取使用 set的add 方法做去重

    /**
     * 使用set去重
     *
     * @param testList
     */
    private static void useSetDistinct(List<String> testList) {
        System.out.println("HashSet.add 开始去重,条数:" + testList.size());
        List<String> testListDistinctResult = new ArrayList<>(new HashSet(testList));
        System.out.println("HashSet.add 去重完毕,条数:" + testListDistinctResult.size());
    }

我们调用一下看看耗时:

    public static void main(String[] args) {
        List<String> testList = getTestList();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        useSetDistinct(testList);
        stopWatch.stop();
        System.out.println("去重 最终耗时" + stopWatch.getTotalTimeMillis());
    }

耗时:


Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

评价:HashSet 的效率,我的建议是,推荐。


为什么耗时 差距这么大?

不多说,我们看源码:

list.contains(o):

Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

 可以看到里面用到了 index(o) :

Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

时间复杂度 : O(n) n: 元素个数

那么我们看看 set.add(o) 是怎么样的 :

Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

map的add , 老生常谈就不谈了,hash完 直接塞到某个位置, 时间复杂度 : O(1)  。

所以 O(n) 和  O(1) 谁快  谁慢 ? 显然。

Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

ps: 顺嘴说下 hashset的 contain  

Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

时间复杂度也是 : O(1)   

Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

那么我们最后再看看别的去重:
 

双for循环 ,remove去重 

    /**
     * 使用双for循环去重
     * @param testList
     */
    private static void use2ForDistinct(List<String> testList) {
        System.out.println("list 双循环 开始去重,条数:" + testList.size());
        for (int i = 0; i < testList.size(); i++) {
            for (int j = i + 1; j < testList.size(); j++) {
                if (testList.get(i).equals(testList.get(j))) {
                    testList.remove(j);
                }
            }
        }
        System.out.println("list 双循环  去重完毕,条数:" + testList.size());
    }
    public static void main(String[] args) {
        List<String> testList = getTestList();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        use2ForDistinct(testList);
        stopWatch.stop();
        System.out.println("去重 最终耗时" + stopWatch.getTotalTimeMillis());
    }

耗时:

Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

 评价:知道就行,图个乐,别用,贼慢,而且代码看起来乱:。


stream的distinct去重:
 

    /**
     * 使用Stream 去重
     *
     * @param testList
     */
    private static void useStreamDistinct(List<String> testList) {
        System.out.println("stream 开始去重,条数:" + testList.size());
        List<String> testListDistinctResult = testList.stream().distinct().collect(Collectors.toList());
        System.out.println("stream 去重完毕,条数:" + testListDistinctResult.size());
    }
    public static void main(String[] args) {
        List<String> testList = getTestList();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        useStreamDistinct(testList);
        stopWatch.stop();
        System.out.println("去重 最终耗时" + stopWatch.getTotalTimeMillis());
    }

耗时:

Java 你还在用list.contain做去重? 你是故意的还是不小心的?,java大乱炖,java,list,contain,去重,性能

 评价:还不错,主要是代码也蛮简洁,有一点点动心。

好了,该篇就到这。文章来源地址https://www.toymoban.com/news/detail-622435.html

到了这里,关于Java 你还在用list.contain做去重? 你是故意的还是不小心的?的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • JDK20又来了!你还在用JDK8么?

    JDK20又来了!相信很多开发者和我一样都还在用JDK8稳定版。JDK8是最后一个免费商业化版本,很多公司也是因为这个原因不愿意升级。但是作为一个资深搬砖人,我们也还是需要了解新版本的特性。废话不多说,我们开始今天的主题——JDK 20新特性。 3月21日,甲骨文公司发布

    2023年04月23日
    浏览(38)
  • Java List按照某字段去重

    Java8流的新类java.util.stream.Collectors实现了java.util.stream.Collector接口,同时又提供了大量的方法对流(stream)的元素执行各种统计操作。 执行结果如下 但是这种方式必须要 每个键值对都一样,才会被判定成重复的 ,否则不会被判为重复,如下。 执行结果如下 虽然name的值一样,但

    2024年02月06日
    浏览(52)
  • Java中list集合stream流去重

    准备类: (1)根据单字段name去重 (2)根据多字段name price去重 (3)示例 输出打印结果

    2024年02月09日
    浏览(52)
  • 【Java】List集合去重的方式

    TreeSet可以将字符串类型的数据按照字典顺序进行排序,首字母相同则看第二位 去重前的集合元素:22 去重前的集合元素:11 去重前的集合元素:33 去重前的集合元素:66 去重前的集合元素:22 去重后的集合:[11, 22, 33, 66] 由于Set的特性是无序且不可重复,我们利用这个特性进

    2024年02月04日
    浏览(64)
  • Java8 list多属性去重

    大家好,我是三叔,很高兴这期又和大家见面了,一个奋斗在互联网的打工人。 在 Java 开发中,我们经常会面临对 List 中的对象属性去重的需求。然而,当需要根据多个属性来进行去重时,情况会稍微复杂一些。本篇博客将深入探讨如何使用 Java 8 的 Stream API 来实现 List 多属

    2024年02月14日
    浏览(87)
  • Java对List<Map>进行合并去重

    对List 进行合并去重,首先创建一个新的 List 用于存储合并去重后的结果,遍历原始的 List ,将每个 Map 对象中的键值对放入一个 Set 中进行去重,最后将去重后的键值对重新组装成一个新的 Map 对象,并添加到新的 List 中。 完整实例代码如下: 简单示例仅供参考

    2024年02月05日
    浏览(66)
  • Java中List集合对象去重及按属性去重的8种方法

    是大家最容易想到的,先把List数据放入Set,因为Set数据结构本身具有去重的功能,所以再将SET转为List之后就是去重之后的结果。这种方法在去重之后会改变原有的List元素顺序,因为HashSet本身是无序的,而TreeSet排序也不是List种元素的原有顺序。 去重后的集合: [kobe, james,

    2024年04月15日
    浏览(119)
  • # java合并两个list 并去重,指定保留其中一个list的重复数据

    在Java中,有多种方法可以合并两个List并去重,指定保留其中一个List的重复数据。下面介绍几种常见的方法,并附上代码示例。 该方法首先将一个List的所有元素加入到目标List中,然后遍历另一个List,如果目标List中不包含该元素,则将该元素加入到目标List中。最后得到的就

    2024年02月02日
    浏览(64)
  • React 你还在用 Redux 吗?更简化的状态管理工具(Recoil)

    以往传统的 Redux 状态管理工具使用起来代码太过于复杂。 你需要通过纯函数触发 action 再去修改 data 中定义的数据,而且要通过接口请求数据还需要借助 redux - think 这个中间件才能完成。。。 更加方便使用的工具:Recoil ~   由 facebook 推出契合 React 的状态管理 它的定义方式

    2024年02月06日
    浏览(52)
  • Java list集合中根据其中两个字段去重

    可以使用Java 8的Stream API和Collectors.toSet()方法来实现根据其中两个字段去重。 首先,使用Stream API将List转换为Stream,然后使用distinct()方法进行去重。distinct()方法默认使用元素的equals()和hashCode()方法进行去重。如果想要根据其中两个字段进行去重,需要重写equals()和hashCode()方法

    2024年02月16日
    浏览(57)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包