Java List

前置知识

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

无序集合

无序集合是指,数据读取的顺序和数据插入的顺序是不一致的。
例如,插入集合的顺序是: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. * @param list
  19. */
  20. public static void method(List<Integer> list) {
  21. // 新集合
  22. List<Integer> newList = new ArrayList<>(list.size());
  23. list.forEach(i -> {
  24. if (!newList.contains(i)) { // 如果新集合中不存在则插入
  25. newList.add(i);
  26. }
  27. });
  28. System.out.println("去重集合:" + newList);
  29. }
  30. }

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

方法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. * @param list
  19. */
  20. public static void method_1(List<Integer> list) {
  21. Iterator<Integer> iterator = list.iterator();
  22. while (iterator.hasNext()) {
  23. // 获取循环的值
  24. Integer item = iterator.next();
  25. // 如果存在两个相同的值
  26. if (list.indexOf(item) != list.lastIndexOf(item)) {
  27. // 移除最后那个相同的值
  28. iterator.remove();
  29. }
  30. }
  31. System.out.println("去重集合:" + list);
  32. }
  33. }

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

方法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. * 使用 HashSet 去重
  18. * @param list
  19. */
  20. public static void method_2(List<Integer> list) {
  21. HashSet<Integer> set = new HashSet<>(list);
  22. System.out.println("去重集合:" + set);
  23. }
  24. }

以上程序执行的结果,如下所示:List 去重的 6 种方法 - 图3此方法的实现代码较为简洁,但缺点是 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. * 使用 LinkedHashSet 去重
  18. * @param list
  19. */
  20. public static void method_3(List<Integer> list) {
  21. LinkedHashSet<Integer> set = new LinkedHashSet<>(list);
  22. System.out.println("去重集合:" + set);
  23. }
  24. }

以上程序执行的结果,如下所示:List 去重的 6 种方法 - 图4从上述代码和执行结果可以看出,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. * 使用 TreeSet 去重(无序)
  18. * @param list
  19. */
  20. public static void method_4(List<Integer> list) {
  21. TreeSet<Integer> set = new TreeSet<>(list);
  22. System.out.println("去重集合:" + set);
  23. }
  24. }

以上程序执行的结果,如下所示:List 去重的 6 种方法 - 图5比较遗憾的是,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. * 使用 Stream 去重
  18. * @param list
  19. */
  20. public static void method_5(List<Integer> list) {
  21. list = list.stream().distinct().collect(Collectors.toList());
  22. System.out.println("去重集合:" + list);
  23. }
  24. }

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

总结

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