List去重的方法

前言：在某些情况下我们需要对list去重，有人会问那为什么不一开始就使用Set或者LinkedHashSet去接收呢？因为我们可能会遇到历史遗留的问题，又或者说是方法返回值的类型只能是list，而我们又需要去重。那么有哪些方法呢

• 循环去重
  使用for循环或者增强for循环去重

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);
   }
}

运行结果：

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

• 迭代器去重

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);
   }
}

运行结果：

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

• 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);
   }
}

运行结果：

此方法的实现代码较为简洁，但缺点是 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);
    }
}

运行结果：

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

• 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);
    }
}

运行结果：

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

• Stream去重(有序)
  java8的新特性

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);
   }
}

运行结果：

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

附加：
数组转List的方法
1.CollUtil------cn.hutool.core.collection

    String[] col= new String[]{"a","b","c","d","e"};
    List<String> colList = CollUtil.newArrayList(col);
    String str = CollUtil.join(colList, "#"); //str -> a#b#c#d#e
    ~~~