Java 为什么整型到整型比整型快10倍？

我有两个相同大小的数组和两个方法

public class Client {
    private static int[] ints;
    private static final int COUNT = 10000000;
    private static Integer[] integers;

    public static void main(String[] args) {
        Random rand = new Random();
        integers = new Integer[COUNT];
        for (int i = 0; i < integers.length; i++) {
            integers[i] = rand.nextInt();
        }

        ints = new int[COUNT];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = rand.nextInt();
        }

        primitiveToObject();
        objectsToPrimitiveToObject();
    }

    public static  void primitiveToObject() {
        long start = new Date().getTime();
        List<Integer> objects = new ArrayList<>(ints.length);
        for (int i = 0; i < ints.length; i++) {
            int value = ints[i] + 1;
            objects.add(value);          //Boxing
        }
        System.out.println("prim -> object = " + (new Date().getTime() - start));
    }

    public static void objectsToPrimitiveToObject() {
        long start = new Date().getTime();
        List<Integer> result= new ArrayList<>(integers.length);
        for (int i = 0; i < integers.length; i++) {
            int value = integers[i] + 1; //Unboxing
            result.add(value);           //Boxing
        }
        System.out.println("obj -> prim -> object = " + (new Date().getTime() - start));
    }
}

公共类客户端{
私有静态int[]int；
私有静态最终整数计数=10000000；
私有静态整数[]整数；
公共静态void main（字符串[]args）{
Random rand=新的Random（）；
整数=新整数[计数]；
for（int i=0；iobject=“+（new Date（）.getTime（）-start））；
}
公共静态void objectsToPrimitiveToObject（）{
长启动=新日期（）.getTime（）；
列表结果=新的ArrayList（integers.length）；
for（int i=0；iprim->object=“+（new Date（）.getTime（）-start））；
}
}

---

为什么带装箱和取消装箱的

objectsToPrimitiveToObject（）

比不带取消装箱的

primitiveToObject（）快10倍？
我认为这是您如何对代码进行基准测试的人工制品

我使用JVM
1.7.0\u 09
和
-XX:+AggressiveOpts-XX:CompileThreshold=1运行了以下基准测试：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Main {
    static final int COUNT = 1000000;
    static int[] ints = new int[COUNT];
    static Integer[] integers = new Integer[COUNT];

    static void primitiveToObject() {
        List<Integer> objects = new ArrayList<Integer>(ints.length);
        for (int i = 0; i < ints.length; i++) {
            int value = ints[i] + 1;
            objects.add(value);                    //boxing
        }
    }

    static void objectsToPrimitiveToObject() {
        List<Integer> result= new ArrayList<Integer>(integers.length);
        for (int i = 0; i < integers.length; i++) {
            int value = integers[i] + 1;           //unboxing
            result.add(value);                     //boxing
        }
    }

    public static void main(String[] args) {
        Random rand = new Random();
        for (int i = 0; i < COUNT; ++i) {
            int val = rand.nextInt();
            ints[i] = val;
            integers[i] = val;
        }
        for (int i = 0; i < 10; ++i) {
            long start_p = System.currentTimeMillis();
            for (int j = 0; j < 100; ++j) {
                primitiveToObject();
            }
            long end_p = System.currentTimeMillis();
            long start_o = System.currentTimeMillis();
            for (int j = 0; j < 100; ++j) {
                objectsToPrimitiveToObject();
            }
            long end_o = System.currentTimeMillis();
            System.out.printf("p2o:%d o2p2o:%d\n", end_p - start_p, end_o - start_o);
        }
    }
}

正如您所看到的，在初始预热之后，
primitiveToObject（）
速度更快，正如人们所期望的那样，方法所做的工作更少

为了完整性，我还使用JDK 6对此进行了测试，并观察到类似的结果。
这是您提到的一件有趣的事情！你也能发布你的发现吗？我还想看一看。你能发布你的基准代码和结果吗？试着对你的基准做一些小的改变，比如交换你做测试的顺序，重新排列代码，或者对实际代码做一些改变。结果稳定吗？我正在使用JUnit进行基准测试，它会给出稳定的结果。请稍等，我会在没有JUnit的情况下检查它。无法复制。在热身之后，这两个都在我的JVM上花费相同的时间。谢谢。我的错误是对每个方法使用一次调用，而不是多次调用。
p2o:2043 o2p2o:818
p2o:709 o2p2o:748
p2o:670 o2p2o:756
p2o:675 o2p2o:742
p2o:679 o2p2o:750
p2o:700 o2p2o:757
p2o:738 o2p2o:733
p2o:706 o2p2o:786
p2o:684 o2p2o:752
p2o:676 o2p2o:799