List 去重的 6 种方法,这个方法最完美!

这篇具有很好参考价值的文章主要介绍了List 去重的 6 种方法,这个方法最完美!。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

在日常的业务开发中,偶尔会遇到需要将 List 集合中的重复数据去除掉的场景。这个时候可能有同学会问:为什么不直接使用 Set 或者 LinkedHashSet 呢?这样不就没有重复数据的问题了嘛? ​

不得不说,能提这个问题的同学很机智,一眼就看到了问题的本质。 ​

但是,在实际的业务开发中遇到的情况会更复杂。比如,List 集合可能是历史遗留问题,也有可能是调用接口返回的类型限制,只能使用 List 接收,又或者是代码写了一半,在做多个集合合并的时候才发现了这个问题,总之造成问题的原因有很多种,这里就不一一列举了。 ​

当发现这个问题之后,如果可以通过改造原有代码,把原来的 List 类型替换成 Set 类型,那就可以直接修改集合的类型即可。但如果压根就修改不了,或者是修改的成本太大,那接下来这 6 种去重的方法,将帮你将解决问题。

前置知识

正式开始之前,先来搞懂两组概念:无序集合和有序集合 & 无序和有序。因为接下来的方法实现中,会反复提及这两组概念,所以有必要在正式开始之前,先把它们搞清楚。

无序集合

无序集合是指,数据读取的顺序和数据插入的顺序是不一致的。例如,插入集合的顺序是:1、5、3、7,而集合的读取顺序竟然是:1、3、5、7。

有序集合

有序集合的概念和无序集合的概念正好相反,它是指集合的读取顺序和插入顺序是一致的。例如,插入数据的顺序是:1、5、3、7,那么读取的顺序也是:1、5、3、7。

有序和无序

通过上面的无序集合和有序集合,我们可以得出有序和无序的概念。 有序指的是数据的排列顺序和读取顺序符合我们的预期就叫做有序。而无序指的是数据的排列顺序和读取顺序不符合我们的预期就叫做无序。

PS:如果对于有序和无序的概念不是很清楚也没关系,通过下面的事例,我们可以进一步的理解它们的含义。

方法1:contains判断去重(有序)

要进行数据去重,我们首先想到的是新建一个集合,然后循环原来的集合,每次循环判断原集合中的循环项,如果当前循环的数据,没有在新集合中存在就插入,已经存在了就舍弃,这样当循环执行完,我们就得到了一个没有重复元素的集合了,实现代码如下:

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(3);
            add(5);
            add(2);
            add(1);
            add(3);
            add(7);
            add(2);
        }};
        System.out.println("原集合:" + list);
        method(list);
    }

    /**
     * 自定义去重
     * @param list
     */
    public static void method(List<Integer> list) {
        // 新集合
        List<Integer> newList = new ArrayList<>(list.size());
        list.forEach(i -> {
            if (!newList.contains(i)) { // 如果新集合中不存在则插入
                newList.add(i);
            }
        });
        System.out.println("去重集合:" + newList);
    }
}
复制代码

以上程序执行的结果,如下所示: list去重,前端,css,html,javascript,css3 此方法的优点的:理解起来比较简单,并且最终得到的集合也是有序的,这里的有序指的是新集合的排列顺序和原集合的顺序是一致的;但缺点是实现代码有点多,不够简洁优雅。

方法2:迭代器去重(无序)

自定义 List 去重,除了上面的新建集合之外,我们也可以使用迭代器循环判断每一项数据,如果当前循环的数据,在集合中存在两份或两份以上,就将当前的元素删除掉,这样循环完之后,也可以得到一个没有重复数据的集合,实现代码如下:

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(3);
            add(5);
            add(2);
            add(1);
            add(3);
            add(7);
            add(2);
        }};
        System.out.println("原集合:" + list);
        method_1(list);
    }

    /**
     * 使用迭代器去重
     * @param list
     */
    public static void method_1(List<Integer> list) {
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            // 获取循环的值
            Integer item = iterator.next();
            // 如果存在两个相同的值
            if (list.indexOf(item) != list.lastIndexOf(item)) {
                // 移除最后那个相同的值
                iterator.remove();
            }
        }
        System.out.println("去重集合:" + list);
    }
}
复制代码

以上程序执行的结果,如下所示: list去重,前端,css,html,javascript,css3 此方法的实现比上一种方法的实现代码要少一些,并且不需要新建集合,但此方法得到的新集合是无序的,也就是新集合的排列顺序和原集合不一致,因此也不是最优的解决方案。

方法3:HashSet去重(无序)

我们知道 HashSet 天生具备“去重”的特性,那我们只需要将 List 集合转换成 HashSet 集合就可以了,实现代码如下:

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(3);
            add(5);
            add(2);
            add(1);
            add(3);
            add(7);
            add(2);
        }};
        System.out.println("原集合:" + list);
        method_2(list);
    }

    /**
     * 使用 HashSet 去重
     * @param list
     */
    public static void method_2(List<Integer> list) {
        HashSet<Integer> set = new HashSet<>(list);
        System.out.println("去重集合:" + set);
    }
}
复制代码

以上程序执行的结果,如下所示: list去重,前端,css,html,javascript,css3 此方法的实现代码较为简洁,但缺点是 HashSet 会自动排序,这样新集合的数据排序就和原集合不一致了,如果对集合的顺序有要求,那么此方法也不能满足当前需求。

方法4:LinkedHashSet去重(有序)

既然 HashSet 会自动排序不能满足需求,那就使用 LinkedHashSet,它既能去重又能保证集合的顺序,实现代码如下:

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(3);
            add(5);
            add(2);
            add(1);
            add(3);
            add(7);
            add(2);
        }};
        System.out.println("原集合:" + list);
        method_3(list);
    }

    /**
     * 使用 LinkedHashSet 去重
     * @param list
     */
    public static void method_3(List<Integer> list) {
        LinkedHashSet<Integer> set = new LinkedHashSet<>(list);
        System.out.println("去重集合:" + set);
    }
}
复制代码

以上程序执行的结果,如下所示: list去重,前端,css,html,javascript,css3 从上述代码和执行结果可以看出,LinkedHashSet 是到目前为止,实现比较简单,且最终生成的新集合与原集合顺序保持一致的实现方法,是我们可以考虑使用的一种去重方法。

方法5:TreeSet去重(无序)

除了以上的 Set 集合之外,我们还可以使用 TreeSet 集合来实现去重功能,实现代码如下:

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(3);
            add(5);
            add(2);
            add(1);
            add(3);
            add(7);
            add(2);
        }};
        System.out.println("原集合:" + list);
        method_4(list);
    }

    /**
     * 使用 TreeSet 去重(无序)
     * @param list
     */
    public static void method_4(List<Integer> list) {
        TreeSet<Integer> set = new TreeSet<>(list);
        System.out.println("去重集合:" + set);
    }
}
复制代码

以上程序执行的结果,如下所示: list去重,前端,css,html,javascript,css3 比较遗憾的是,TreeSet 虽然实现起来也比较简单,但它有着和 HashSet 一样的问题,会自动排序,因此也不能满足我们的需求。

方法6:Stream去重(有序)

JDK 8 为我们带来了一个非常实用的方法 Stream,使用它可以实现很多功能,比如下面的去重功能:

public class ListDistinctExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(3);
            add(5);
            add(2);
            add(1);
            add(3);
            add(7);
            add(2);
        }};
        System.out.println("原集合:" + list);
        method_5(list);
    }

    /**
     * 使用 Stream 去重
     * @param list
     */
    public static void method_5(List<Integer> list) {
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重集合:" + list);
    }
}
复制代码

以上程序执行的结果,如下所示: list去重,前端,css,html,javascript,css3 Stream 实现去重功能和其他方法不同的是,它不用新创建集合,使用自身接收一个去重的结果就可以了,并且实现代码也很简洁,并且去重后的集合顺序也和原集合的顺序保持一致,是我们最优先考虑的去重方法。

总结

本文我们介绍了 6 种集合去重的方法,其中实现最简洁,且去重之后的顺序能和原集合保持一致的实现方法,只有两种:LinkedHashSet 去重和 Stream 去重,而后一种去重方法无需借助新集合,是我们优先考虑的去重方法。

是非审之于己,毁誉听之于人,得失安之于数。

博主介绍:80 后程序员,写博客这件事“坚持”了 11 年,爱好:读书、慢跑、羽毛球。

我的公众号:Java面试真题解析

个人微信:GG_Stone,欢迎围观朋友圈,做个点赞只交。文章来源地址https://www.toymoban.com/news/detail-770813.html

来源:https://juejin.cn/post/7038578863873458183

到了这里,关于List 去重的 6 种方法,这个方法最完美!的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

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

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

相关文章

  • Stream流实践(二):list 对象数组根据某字段去重的三种基本思路

    相信大家对于list简单数组的去重很熟悉了,例如以下代码 那我们来探讨下,对于list中保存为对象的数组,根据内部对象的 某一个字段 去重有什么好的思路呢? 给出一个简单的Student对象 大家学废了吗?

    2024年02月16日
    浏览(71)
  • Java中5种List的去重方法及它们的效率对比,你用对了吗?

    效率测试代码  使用HashSet实现List去重时间:40毫秒 使用TreeSet实现List去重时间:36毫秒 使用java8新特性stream实现List去重:78毫秒 使用两个for循环实现List去重:533毫秒 使用List集合contains方法循环遍历:40毫秒 更多测试结果 随机数在100范围内: 使用HashSet实现List去重时间:32毫秒 使用

    2024年04月16日
    浏览(26)
  • 【linux】linux去重的方法

    多种linux文本去重方法 awk去重法【1】 awk去重法【2】 awk去重法【3】 sort去重法【1】 sort去重法【2】 (用于多个文件一次性去重) sort去重法【3】 (查找非重复行) sort去重法【4】 (统计字符出现次数) grep去重法【1】 grep去重法【2】

    2024年02月11日
    浏览(42)
  • JS数组去重的12种方法

    Set 对象是 ES6 中新定义的数据结构,类似数组,它允许存储任何类型的唯一值,不管是原始值还是对象引用。 Array.from() 方法 就是将一个类数组对象或者可遍历对象转换成一个真正的数组 不考虑兼容性,这种去重的方式代码最少。这种方法无法去掉 {} 空对象,后面的高阶方

    2024年02月06日
    浏览(39)
  • 分享6个对象数组去重的方法

    大家好,关于对象数组去重的业务场景,想必大家都遇到过类似的需求吧,针对这样的需求,你是怎么做的呢。 下面我就先和大家讨论下基于对象的某个属性如何去重。 使用 filter() 方法过滤掉重复的元素,使用 findIndex() 方法判断对象是否重复,代码如下: 使用 reduce() 方法

    2024年02月16日
    浏览(44)
  • Python列表去重的几种方法和实例

    Python列表去重的几种方法和实例 在 Python 中,列表去重有多种方法,下面分别介绍这些方法的实现。 set() 函数可以将列表转换成集合,集合中不允许有重复的元素,因此可以实现列表去重。 可以使用列表推导式,将列表中不重复的元素生成一个新的列表。 通过字典的键唯一

    2024年02月06日
    浏览(44)
  • C# list<T>去重

    List object is int object is decimal object is char object is bool object is string List List 集合里有三条记录,其中两条重复。 使用Distinct后,还有三条,说明distinct失败 原因是,引用类型即使属性一样,引用地址是不一样的。 只能用别的方式去避免。

    2024年02月05日
    浏览(51)
  • 对List集合、数组去重

    还记得在2021我发布的第一篇博客就是关于数组的去重,从那一刻开始,命运的齿轮开始转动…… 扯远了哈哈哈,我重新写这篇文章只是想让去重方式更加严谨(ps:我才不会说是因为技术成长了,看不上之前写的了哈哈哈  依据Set集合的特性,使用set去重(最简洁高效)  使

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

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

    2024年02月02日
    浏览(63)
  • Java List按照某字段去重

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

    2024年02月06日
    浏览(51)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包