Java中5种List的去重方法及它们的效率对比

使用两个for循环实现List去重(有序)

/**
     * 使用两个for循环实现List去重(有序)
     *
     * @param list
     * @return
     */
    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方法循环遍历(有序)

/**
     * 使用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去重(无序)

/**
     * 使用HashSet实现List去重(无序)
     *
     * @param list
     */
    public static List removeDuplicationByHashSet(List<Integer> list) {
        HashSet hashSet = new HashSet(list);
        list.clear();
        list.addAll(hashSet);
        return list;
    }

使用TreeSet实现List去重(有序)

/**
     * 使用TreeSet实现List去重(有序)
     *
     * @param list
     */
    public static List removeDuplicationByTreeSet(List<Integer> list) {
        TreeSet treeSet = new TreeSet(list);
        list.clear();
        list.addAll(treeSet);
        return list;
    }

使用java8的stream实现List去重(有序)

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

使用Main方法测试

 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) + "毫秒");
    }

结果：
使用HashSet实现List去重时间:21毫秒
使用TreeSet实现List去重时间:28毫秒
使用java8新特性stream实现List去重:80毫秒
使用两个for循环实现List去重:470毫秒
使用List集合contains方法循环遍历:42毫秒

随机数在100范围内：

使用HashSet实现List去重时间:15毫秒
使用TreeSet实现List去重时间:18毫秒
使用java8新特性stream实现List去重:64毫秒
使用两个for循环实现List去重:289毫秒
使用List集合contains方法循环遍历:16毫秒

随机数在10000范围内：

使用HashSet实现List去重时间:20毫秒
使用TreeSet实现List去重时间:42毫秒
使用java8新特性stream实现List去重:67毫秒
使用两个for循环实现List去重:3904毫秒
使用List集合contains方法循环遍历:845毫秒