总阅读量:30次

⭐⭐⭐ Spring Boot 项目实战 ⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 blog.csdn.net/qq_35387940/article/details/129885310 「小目标青年」欢迎转载，保留摘要，谢谢！

前言

最近又是一轮代码review , 发现了一些实现去重的代码，在使用 lsit.contain ......

如：

我沉思，是不是其实很多初学者也存在这种去重使用问题？

所以我选择把这个事情整出来，分享一下。

正文

首先是造出一个 List<String>模拟数据,一共2W条，里面有一半数据1W条是重复的:

public static List<String> getTestList() {
    List<String> list = new ArrayList<>();
    for (int i = 1; i <= 10000; i++) {
        list.add(String.valueOf(i));
    }
    for (int i = 10000; i >= 1; i--) {
        list.add(String.valueOf(i));
    }
    return list;
}

先看看 我们用contain 去重的 代码：

/**
 * 使用 list.contain 去重
 *
 * @param testList
 */
private static void useContain2Distinct(List<String> testList) {
    System.out.println("contains 开始去重，条数：" + testList.size());
    List<String> testListDistinctResult = new ArrayList<>();
    for (String str : testList) {
        if (!testListDistinctResult.contains(str)) {
            testListDistinctResult.add(str);
        }
    }
    System.out.println("contains 去重完毕，条数：" + testListDistinctResult.size());
}

我们调用一下看看耗时：

public static void main(String[] args) {
    List<String> testList = getTestList();
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    useContainDistinct(testList);
    stopWatch.stop();
    System.out.println("去重 最终耗时" + stopWatch.getTotalTimeMillis());
}

耗时：

评价： list.contain 的效率，我的建议是，知道就行，别用。

众所周知Set 不存在 重复数据， 所以我们来看看 使用HashSet去重的性能：

ps： 这里是采取使用 set的add 方法做去重

/**
 * 使用set去重
 *
 * @param testList
 */
private static void useSetDistinct(List<String> testList) {
    System.out.println("HashSet.add 开始去重，条数：" + testList.size());
    List<String> testListDistinctResult = new ArrayList<>(new HashSet(testList));
    System.out.println("HashSet.add 去重完毕，条数：" + testListDistinctResult.size());
}

我们调用一下看看耗时：

public static void main(String[] args) {
    List<String> testList = getTestList();
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    useSetDistinct(testList);
    stopWatch.stop();
    System.out.println("去重 最终耗时" + stopWatch.getTotalTimeMillis());
}

耗时：

评价：HashSet 的效率，我的建议是，推荐。

为什么耗时 差距这么大？

不多说，我们看源码：

list.contains(o)：

可以看到里面用到了 index（o） :

时间复杂度 ： O（n） ，n: 元素个数

那么我们看看 set.add（o） 是怎么样的 ：

map的add , 老生常谈就不谈了，hash完 直接塞到某个位置， 时间复杂度 ：O(1) 。

所以 O（n） 和 O(1) 谁快 谁慢 ？ 显然。

ps： 顺嘴说下 hashset的 contain

时间复杂度也是 ： O(1)

那么我们最后再看看别的去重：

双for循环 ，remove去重

/**
 * 使用双for循环去重
 * @param testList
 */
private static void use2ForDistinct(List<String> testList) {
    System.out.println("list 双循环 开始去重，条数：" + testList.size());
    for (int i = 0; i < testList.size(); i++) {
        for (int j = i + 1; j < testList.size(); j++) {
            if (testList.get(i).equals(testList.get(j))) {
                testList.remove(j);
            }
        }
    }
    System.out.println("list 双循环  去重完毕，条数：" + testList.size());
}
public static void main(String[] args) {
    List<String> testList = getTestList();
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    use2ForDistinct(testList);
    stopWatch.stop();
    System.out.println("去重 最终耗时" + stopWatch.getTotalTimeMillis());
}

耗时：

评价：知道就行，图个乐，别用，贼慢，而且代码看起来乱：。

stream的distinct去重：

/**
 * 使用Stream 去重
 *
 * @param testList
 */
private static void useStreamDistinct(List<String> testList) {
    System.out.println("stream 开始去重，条数：" + testList.size());
    List<String> testListDistinctResult = testList.stream().distinct().collect(Collectors.toList());
    System.out.println("stream 去重完毕，条数：" + testListDistinctResult.size());
}
public static void main(String[] args) {
    List<String> testList = getTestList();
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    useStreamDistinct(testList);
    stopWatch.stop();
    System.out.println("去重 最终耗时" + stopWatch.getTotalTimeMillis());
}

耗时：

评价：还不错，主要是代码也蛮简洁，有一点点动心。

好了，该篇就到这。

精进