CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章java List 去重的六种完美方法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

在日常的业务开发中，偶尔会遇到需要将 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判断去重(有序)

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

1. public class ListDistinctExample { 
2.     public static void main(String[] args) { 
3.         List<Integer> list = new ArrayList<Integer>() {{ 
4.             add(1); 
5.             add(3); 
6.             add(5); 
7.             add(2); 
8.             add(1); 
9.             add(3); 
10.             add(7); 
11.             add(2); 
12.         }}; 
13.         System.out.println("原集合:" + list); 
14.         method(list); 
15.     } 
16.  
17.     /** 
18.      * 自定义去重 
19.      * @param list 
20.      */ 
21.     public static void method(List<Integer> list) { 
22.         // 新集合 
23.         List<Integer> newList = new ArrayList<>(list.size()); 
24.         list.forEach(i -> { 
25.             if (!newList.contains(i)) { // 如果新集合中不存在则插入 
26.                 newList.add(i); 
27.             } 
28.         }); 
29.         System.out.println("去重集合:" + newList); 
30.     } 
31. } 

以上程序执行的结果，如下所示:

此方法的优点的：理解起来比较简单，并且最终得到的集合也是有序的，这里的有序指的是新集合的排列顺序和原集合的顺序是一致的;但缺点是实现代码有点多，不够简洁优雅.

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

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

1. public class ListDistinctExample { 
2.     public static void main(String[] args) { 
3.         List<Integer> list = new ArrayList<Integer>() {{ 
4.             add(1); 
5.             add(3); 
6.             add(5); 
7.             add(2); 
8.             add(1); 
9.             add(3); 
10.             add(7); 
11.             add(2); 
12.         }}; 
13.         System.out.println("原集合:" + list); 
14.         method_1(list); 
15.     } 
16.  
17.     /** 
18.      * 使用迭代器去重 
19.      * @param list 
20.      */ 
21.     public static void method_1(List<Integer> list) { 
22.         Iterator<Integer> iterator = list.iterator(); 
23.         while (iterator.hasNext()) { 
24.             // 获取循环的值 
25.             Integer item = iterator.next(); 
26.             // 如果存在两个相同的值 
27.             if (list.indexOf(item) != list.lastIndexOf(item)) { 
28.                 // 移除最后那个相同的值 
29.                 iterator.remove(); 
30.             } 
31.         } 
32.         System.out.println("去重集合:" + list); 
33.     } 
34. } 

以上程序执行的结果，如下所示:

此方法的实现比上一种方法的实现代码要少一些，并且不需要新建集合，但此方法得到的新集合是无序的，也就是新集合的排列顺序和原集合不一致，因此也不是最优的解决方案.

方法3：HashSet去重(无序)

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

1. public class ListDistinctExample { 
2.     public static void main(String[] args) { 
3.         List<Integer> list = new ArrayList<Integer>() {{ 
4.             add(1); 
5.             add(3); 
6.             add(5); 
7.             add(2); 
8.             add(1); 
9.             add(3); 
10.             add(7); 
11.             add(2); 
12.         }}; 
13.         System.out.println("原集合:" + list); 
14.         method_2(list); 
15.     } 
16.  
17.     /** 
18.      * 使用 HashSet 去重 
19.      * @param list 
20.      */ 
21.     public static void method_2(List<Integer> list) { 
22.         HashSet<Integer> set = new HashSet<>(list); 
23.         System.out.println("去重集合:" + set); 
24.     } 
25. } 

以上程序执行的结果，如下所示:

此方法的实现代码较为简洁，但缺点是 HashSet 会自动排序，这样新集合的数据排序就和原集合不一致了，如果对集合的顺序有要求，那么此方法也不能满足当前需求.

方法4：LinkedHashSet去重(有序)

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

1. public class ListDistinctExample { 
2.     public static void main(String[] args) { 
3.         List<Integer> list = new ArrayList<Integer>() {{ 
4.             add(1); 
5.             add(3); 
6.             add(5); 
7.             add(2); 
8.             add(1); 
9.             add(3); 
10.             add(7); 
11.             add(2); 
12.         }}; 
13.         System.out.println("原集合:" + list); 
14.         method_3(list); 
15.     } 
16.  
17.     /** 
18.      * 使用 LinkedHashSet 去重 
19.      * @param list 
20.      */ 
21.     public static void method_3(List<Integer> list) { 
22.         LinkedHashSet<Integer> set = new LinkedHashSet<>(list); 
23.         System.out.println("去重集合:" + set); 
24.     } 
25. } 

以上程序执行的结果，如下所示:

从上述代码和执行结果可以看出，LinkedHashSet 是到目前为止，实现比较简单，且最终生成的新集合与原集合顺序保持一致的实现方法，是我们可以考虑使用的一种去重方法.

方法5：TreeSet去重(无序)

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

1. public class ListDistinctExample { 
2.     public static void main(String[] args) { 
3.         List<Integer> list = new ArrayList<Integer>() {{ 
4.             add(1); 
5.             add(3); 
6.             add(5); 
7.             add(2); 
8.             add(1); 
9.             add(3); 
10.             add(7); 
11.             add(2); 
12.         }}; 
13.         System.out.println("原集合:" + list); 
14.         method_4(list); 
15.     } 
16.  
17.     /** 
18.      * 使用 TreeSet 去重(无序) 
19.      * @param list 
20.      */ 
21.     public static void method_4(List<Integer> list) { 
22.         TreeSet<Integer> set = new TreeSet<>(list); 
23.         System.out.println("去重集合:" + set); 
24.     } 
25. } 

以上程序执行的结果，如下所示:

比较遗憾的是，TreeSet 虽然实现起来也比较简单，但它有着和 HashSet 一样的问题，会自动排序，因此也不能满足我们的需求.

方法6：Stream去重(有序)

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

1. public class ListDistinctExample { 
2.     public static void main(String[] args) { 
3.         List<Integer> list = new ArrayList<Integer>() {{ 
4.             add(1); 
5.             add(3); 
6.             add(5); 
7.             add(2); 
8.             add(1); 
9.             add(3); 
10.             add(7); 
11.             add(2); 
12.         }}; 
13.         System.out.println("原集合:" + list); 
14.         method_5(list); 
15.     } 
16.  
17.     /** 
18.      * 使用 Stream 去重 
19.      * @param list 
20.      */ 
21.     public static void method_5(List<Integer> list) { 
22.         list = list.stream().distinct().collect(Collectors.toList()); 
23.         System.out.println("去重集合:" + list); 
24.     } 
25. } 

以上程序执行的结果，如下所示:

Stream 实现去重功能和其他方法不同的是，它不用新创建集合，使用自身接收一个去重的结果就可以了，并且实现代码也很简洁，并且去重后的集合顺序也和原集合的顺序保持一致，是我们最优先考虑的去重方法.

总结

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

原文链接：https://mp.weixin.qq.com/s/-YDV42heDTF6FkOpxjd7kg 。

最后此篇关于java List 去重的六种完美方法的文章就讲到这里了,如果你想了解更多关于java List 去重的六种完美方法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。