为什么 Intellij Idea 建议在使用循环将数组转换为 Set 时创建中间列表？

Question

假设我有以下代码：

public Set<String> csvToSet(String src) {
    String[] splitted = src.split(",");
    Set<String> result = new HashSet<>(splitted.length);
    for (String s : splitted) {
        result.add(s);
    }
    return result;
}

所以我需要将一个数组转换为 Set。 Intellij Idea 建议将我的 for-each 循环替换为 Collection.addAll one-liner 所以我得到：

...
Set<String> result = new HashSet<>(splitted.length);
result.addAll(Arrays.asList(splitted));
return result;

完整的检查信息是：

在调用批量方法（例如 collection.addAll(listOfX) 时，可以替换循环中调用某些方法（例如 collection.add(x)）时的此检查警告。 如果选中复选框“使用 Arrays.asList() 包装数组”，则即使原始代码迭代数组而批量方法需要 Collection，检查也会发出警告。在这种情况下，快速修复操作将使用 Arrays.asList() 调用自动包装一个数组。

从检查描述来看，它听起来像预期的那样工作。

如果我们参考关于将数组转换为 Set (How to convert an Array to a Set in Java) 的问题的最佳答案，建议使用相同的一行：

Set<T> mySet = new HashSet<T>(Arrays.asList(someArray));

尽管从数组创建一个 ArrayList 是 O(1)，但我不喜欢创建一个额外的 List 对象的想法。

通常我相信 Intellij 检查并假设它不会提供任何效率较低的东西。 但今天我很好奇为什么两者：顶级 SO 答案和 Intellij Idea（使用默认设置）建议使用相同的单线创建无用的中间 List 对象，而自 JDK 6 以来还有一个 Collections.addAll(destCollection, yourArray)。

我看到的唯一原因是（检查和答案）都太旧了。如果是这样，这就是改进intellij想法并为提出Collections.addAll()的答案提供更多投票的原因：)

Answer 1

关于为什么 Intellij 不建议将 Arrays.asList 替换为的提示

Set<String> result = new HashSet<>(splitted.length);
result.addAll(Arrays.asList(splitted));
return result;

在source code for HashSet(Collection):

public HashSet(Collection<? extends E> c) {
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}

注意集合的容量不是c的大小。

因此，更改在语义上不会等效。

---

不用担心创建List。 真的便宜。它不是免费的；但是您必须在真正对性能至关重要的循环中使用它才能注意到。

Answer 2

我写了一个小函数来测量将数组添加到 HashSet 的三种方式的性能，下面是结果。

首先是所有人使用的基本代码，它将生成一个maxSize 数组，其值在0-100 之间

    int maxSize = 10000000; // 10M values
    String[] s = new String[maxSize];
    Random r = new Random();

    for (int i = 0; i < maxSize; i++) {
        s[i] = "" + r.nextInt(100);
    }

然后是基准函数：

public static void benchmark(String name, Runnable f) {
    Long startTime = System.nanoTime();
    f.run();
    Long endTime = System.nanoTime();
    System.out.println("Total execution time for: " + name + ": " + (endTime-startTime) / 1000000 + "ms");
}

所以第一种方法是使用带有循环的代码，对于 10M values，它需要在 150ms and 190ms 之间（我为每种方法运行了几次基准测试）

    Main.benchmark("Normal loop ", () -> {
        Set<String> result = new HashSet<>(s.length);
        for (String a : s) {
            result.add(a);
        }
    });

第二次使用result.addAll(Arrays.asList(s));，它在180ms and 220ms之间使用

        Main.benchmark("result.addAll(Arrays.asList(s)): ", () -> {
            Set<String> result = new HashSet<>(s.length);
            result.addAll(Arrays.asList(s));
        });

第三种方法是使用Collections.addAll(result, s);，它在170ms and 200ms之间进行

    Main.benchmark("Collections.addAll(result, s); ", () -> {
        Set<String> result = new HashSet<>(s.length);
        Collections.addAll(result, s);
    });

---

现在解释一下。从运行时复杂性来看，它们都在 O(n) 中运行，这意味着对于 N values N operations 将运行（基本上添加 N 值）。

从内存复杂性的角度来看，同样是O(N)。只有新的HashSet 被创建。

Arrays.asList(someArray) 没有创建 new 数组，只是创建了一个新对象，该对象具有 reference 到该数组。在java代码中可以看到：

    private final E[] a;

    ArrayList(E[] array) {
        a = Objects.requireNonNull(array);
    }

除此之外，所有addAll 方法都将完全按照您所做的操作，for-loop：

// addAll method for Collections.addAll(result, s);
public static <T> boolean addAll(Collection<? super T> c, T... elements) {
    boolean result = false;
    for (T element : elements)
        result |= c.add(element);
    return result;
}

// addAll method for result.addAll(Arrays.asList(s));
public boolean addAll(Collection<? extends E> c) {
    boolean modified = false;
    for (E e : c)
        if (add(e))
            modified = true;
    return modified;
}

---

总而言之，运行时差异如此之小，IntelliJ 提出了一种以更清晰和更少代码编写代码的方法。