java中list集合数据去重方法大比拼，结果没想到赢家竟是它！

刚开始学习list的时候就学习了在list集合中如何去除重复数据，当时第一想到的就是通过循环判断来去除重复数据，后来慢慢接触的东西多了，就开始注重一个效率，当数据量巨大的时候，怎么样才能查的更快，怎样的代码会更好。
接下来总结list中去重的几个方法(效率效率效率！！！)

1、使用双重for循环实现List去重

    /**使用双重for循环实现List去重(有序)
     *
     * @param list
     * */
    public static List removeDuplicationBy2For(List<Integer> list) {
        for (int i=0;i<list.size();i++)
        {
            for (int j=i+1;j<list.size();j++)
            {
                if(list.get(i).equals(list.get(j))){
                    list.remove(j);
                }
            }
        }
        return list;
    }

2、使用List集合中contains方法循环遍历

    /**使用List集合contains方法循环遍历(有序)
     *
     * @param list
     * */
    public static List removeDuplicationByContains(List<Integer> list) {
        List<Integer> newList =new ArrayList<>();
        for (int i=0;i<list.size();i++)
        {
            boolean isContains =newList.contains(list.get(i));
            if(!isContains){
                newList.add(list.get(i));
            }
        }
        list.clear();
        list.addAll(newList);
        return list;
    }

3、使用HashSet实现List去重

    /**使用HashSet实现List去重(无序)
     *
     * @param list
     * */
    public static List removeDuplicationByHashSet(List<Integer> list) {
        HashSet set = new HashSet(list);
        //把List集合所有元素清空
        list.clear();
        //把HashSet对象添加至List集合
        list.addAll(set);
        return list;
    }

4、使用TreeSet实现List去重

    /**使用TreeSet实现List去重(有序)
     *
     * @param list
     * */
    public static List removeDuplicationByTreeSet(List<Integer> list) {
        TreeSet set = new TreeSet(list);
        //把List集合所有元素清空
        list.clear();
        //把HashSet对象添加至List集合
        list.addAll(set);
        return list;
    }

5、使用java8新特性stream流实现List去重

    /**使用java8新特性stream实现List去重(有序)
     *
     * @param list
     * */
    public static List removeDuplicationByStream(List<Integer> list) {
        List newList = list.stream().distinct().collect(Collectors.toList());
        return newList;
    }
    

测试各个方法效率

随机取100000个500以内的数字存入5个集合，分别调用5个方法进行测试，计算去除重复值所需的时间

public class Demo {
    public static void main(String[] args) {
​
            List<Integer> list1 = new ArrayList<>();
            List<Integer> list2 = new ArrayList<>();
            List<Integer> list3 = new ArrayList<>();
            List<Integer> list4 = new ArrayList<>();
            List<Integer> list5 = new ArrayList<>();
            Random random =new Random();
            for (int i = 0; i < 100000; i++) {
                int value =random.nextInt(500);
                list1.add(value);
                list2.add(value);
                list3.add(value);
                list4.add(value);
                list5.add(value);
            }
            long startTime ;
            long endTime;
            startTime = System.currentTimeMillis();
            removeDuplicationByHashSet(list1);
            endTime = System.currentTimeMillis();
            System.out.println("使用HashSet实现List去重时间:"+(endTime-startTime)+"毫秒");
            startTime = System.currentTimeMillis();
            removeDuplicationByTreeSet(list2);
            endTime = System.currentTimeMillis();
            System.out.println("使用TreeSet实现List去重时间:"+(endTime-startTime)+"毫秒");
            startTime = System.currentTimeMillis();
            removeDuplicationByStream(list3);
            endTime = System.currentTimeMillis();
            System.out.println("使用java8新特性stream实现List去重:"+(endTime-startTime)+"毫秒");
            startTime = System.currentTimeMillis();
            removeDuplicationBy2For(list4);
            endTime = System.currentTimeMillis();
            System.out.println("使用双重for循环实现List去重:"+(endTime-startTime)+"毫秒");
            startTime = System.currentTimeMillis();
            removeDuplicationByContains(list5);
            endTime = System.currentTimeMillis();
            System.out.println("使用List集合contains方法循环遍历:"+(endTime-startTime)+"毫秒");
​
    }
    /**使用双重for循环实现List去重(有序)
     *
     * @param list
     * */
    public static List removeDuplicationBy2For(List<Integer> list) {
        for (int i=0;i<list.size();i++)
        {
            for (int j=i+1;j<list.size();j++)
            {
                if(list.get(i).equals(list.get(j))){
                    list.remove(j);
                }
            }
        }
        return list;
    }

    /**使用List集合contains方法循环遍历(有序)
     *
     * @param list
     * */
    public static List removeDuplicationByContains(List<Integer> list) {
        List<Integer> newList =new ArrayList<>();
        for (int i=0;i<list.size();i++)
        {
            boolean isContains =newList.contains(list.get(i));
            if(!isContains){
                newList.add(list.get(i));
            }
        }
        list.clear();
        list.addAll(newList);
        return list;
    }

    /**使用HashSet实现List去重(无序)
     *
     * @param list
     * */
    public static List removeDuplicationByHashSet(List<Integer> list) {
        HashSet set = new HashSet(list);
        //把List集合所有元素清空
        list.clear();
        //把HashSet对象添加至List集合
        list.addAll(set);
        return list;
    }
​
    /**使用TreeSet实现List去重(有序)
     *
     * @param list
     * */
    public static List removeDuplicationByTreeSet(List<Integer> list) {
        TreeSet set = new TreeSet(list);
        //把List集合所有元素清空
        list.clear();
        //把HashSet对象添加至List集合
        list.addAll(set);
        return list;
    }
​
    /**使用java8新特性stream实现List去重(有序)
     *
     * @param list
     * */
    public static List removeDuplicationByStream(List<Integer> list) {
        List newList = list.stream().distinct().collect(Collectors.toList());
        return newList;
    }
}

- 结果1：

使用HashSet实现List去重时间:14毫秒
使用TreeSet实现List去重时间:20毫秒
使用java8新特性stream实现List去重:52毫秒
使用双重for循环实现List去重:355毫秒
使用List集合contains方法循环遍历:27毫秒

- 结果2：

使用HashSet实现List去重时间:21毫秒
使用TreeSet实现List去重时间:24毫秒
使用java8新特性stream实现List去重:67毫秒
使用双重for循环实现List去重:401毫秒
使用List集合contains方法循环遍历:37毫秒

- 结果3：

使用HashSet实现List去重时间:16毫秒
使用TreeSet实现List去重时间:72毫秒
使用java8新特性stream实现List去重:62毫秒
使用双重for循环实现List去重:350毫秒
使用List集合contains方法循环遍历:33毫秒

如果没有要求有序排列的时候，使用HashSet处理最好