Question

我对自动装箱和性能感到好奇，因为我在我的应用程序中做了很多速度敏感的数学运算，所以我进行了一些测试......

public static void main(String[] args) {
    // Some initialization so I know it's not involved
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(0);
    int[] regArray = new int[1];
    long total = 0;

    // This one uses an array and primitive type
    long start = System.currentTimeMillis();
    for (int i = 0; i < 10000000; i++) {
        regArray[0] = i + 10;
        if (regArray[0] % 1000 == 0) total += regArray[0];
    }
    System.out.println("Runtime in millis: " + (System.currentTimeMillis() - start));
    System.out.println(total);

    // This one autoboxes, but still uses the Object type because it's a list
    total = 0;
    start = System.currentTimeMillis();
    for (int i = 0; i < 10000000; i++) {
        list.set(0, i + 10);
        if (list.get(0) % 1000 == 0) total += list.get(0);
    }
    System.out.println("Runtime in millis: " + (System.currentTimeMillis() - start));
    System.out.println(total);

    // This one doesn't autobox
    total = 0;
    start = System.currentTimeMillis();
    for (int i = 0; i < 10000000; i++) {
        list.set(0, new Integer(i + 10));
        if (list.get(0).intValue() % 1000 == 0) total += list.get(0).intValue();
    }
    System.out.println("Runtime in millis: " + (System.currentTimeMillis() - start));
    System.out.println(total);
}

以下是示例输出：

Runtime in millis: 78
50005000000
Runtime in millis: 250
50005000000
Runtime in millis: 250
50005000000

这似乎表明我应该远离List<>和子类，对速度敏感的应用程序。你同意吗，stackoverflow？

编辑：我的实际用例是，我需要存储几百个int和float s，它们会经常变化，而且很大程度上是不可预测的（我说很大程度上是因为它们会保持在一个狭窄的范围内，但我不知道他们会在那个狭窄的范围内做什么），我需要在这些数字上进行数学计算的毫秒级响应时间。

Answer 1

微观标记很难！我重写了您的基准以使用caliper：

import com.google.caliper.Runner;
import com.google.caliper.SimpleBenchmark;

import java.util.ArrayList;

public class ListsBenchmark extends SimpleBenchmark {

    private final ArrayList<Integer> list = new ArrayList<Integer>();
    int[] regArray = new int[1];
    long total;

    @Override
    protected void setUp() throws Exception {
        list.add(0);
        total = 0;
    }

    public long timeArrayAndPrimitiveType(int reps) {
        for (int i = 0; i < reps; i++) {
            regArray[0] = i + 10;
            if (regArray[0] % 1000 == 0)
                total += regArray[0];
        }
        return total;
    }

    public long timeListWithAutoboxing(int reps) {
        for (int i = 0; i < reps; i++) {
            list.set(0, i + 10);
            if (list.get(0) % 1000 == 0)
                total += list.get(0);
        }
        return total;
    }

    public long timeNoAutoboxing(int reps) {
        for (int i = 0; i < reps; i++) {
            list.set(0, new Integer(i + 10));
            if (list.get(0).intValue() % 1000 == 0)
                total += list.get(0).intValue();
        }
        return total;
    }

    public static void main(String[] args) {
        Runner.main(ListsBenchmark.class, new String[]{});
    }

}

我没有修改原始代码。我发现的是：

数组大约快3倍
创建新的Integer稍微快一些（！），也许缓存有一些价格，或者它只是我的架构（32位Ubuntu有4核和3 GiB内存笔记本电脑）

在图表上（随意自行运行！）：

Caliper

Answer 2

如果您有预定数量的整数，那么将它们存储在一个数组中（假设它们需要存储且无法流式传输！）通常比java.util.ArrayList更快，是的。

但是，在许多情况下，您可能会有不同的数据大小，因此可动态调整大小的集合变得非常有用 - 替代方法通常是编写您自己的ArrayList实现！

幸运的是，有many third party libraries基于原始类型（int等）而不是对象（Integer等）实现列表。你可以看看这些。

Answer 3

编写基准测试是一项艰巨的任务，而且您的基准测试不是很好，至少有以下原因：

在main方法中执行所有操作，不让Hotspot进入并且JIT编译代码会导致结果错误
使用new Integer()代替Integer.valueOf()不允许您使用整数缓存
价值观和操作不切合实际。大多数情况下，值接近0，而不是10,000,000范围

基元和数组通常比对象和集合更快，但是在没有测量实际代码的情况下，在实际条件下，很难判断使用基元和数组获得的增益是重要的还是完全可以忽略不计。大多数情况下，IO操作会丢失性能。

列表，原始类型和性能

3 个答案: