Java 数组声明中的差异

最近我遇到了java中的数组声明类型

       int[] arr = { 1, 2, 3, 4, 5 };
       int[] arr1 = new int[5];
       arr1[0] = 0;
       arr1[1] = 1; ..etc

谁能解释一下这两件事之间的区别，比如内存分配、访问效率或其他方面吗？

它们是等价的

int[] arr = { 1, 2, 3, 4, 5 };

索引的值初始化为1,2…5

int[] arr1 = new int[5];

索引的值初始化为0。然后按如下所示设置索引的值

arr1[0]=0； arr1[1]=1。。etc

它们是等价的（假设您实际将第一个中的值更改为0、1、2、3、4。）

事实上，它们甚至可以编译成几乎相同的字节码；Java字节码没有任何巧妙的方法来简化这一过程，因此编译器几乎只是将“内联”版本扩展为“创建和填充”版本

您可以通过编译一个简短的测试应用程序看到这一点：

public class Test {
    private static void inline() {
        int[] x = { 0, 1, 2 };
    }

    private static void explicit() {
        int[] x = new int[3];
        x[0] = 0;
        x[1] = 1;
        x[2] = 2;
    }
}

然后使用

javap

显示字节码：

$ javap -c --private Test

Compiled from "Test.java"
public class Test extends java.lang.Object{
public Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

private static void inline();
  Code:
   0:   iconst_3
   1:   newarray int
   3:   dup
   4:   iconst_0
   5:   iconst_0
   6:   iastore
   7:   dup
   8:   iconst_1
   9:   iconst_1
   10:  iastore
   11:  dup
   12:  iconst_2
   13:  iconst_2
   14:  iastore
   15:  astore_0
   16:  return

private static void explicit();
  Code:
   0:   iconst_3
   1:   newarray int
   3:   astore_0
   4:   aload_0
   5:   iconst_0
   6:   iconst_0
   7:   iastore
   8:   aload_0
   9:   iconst_1
   10:  iconst_1
   11:  iastore
   12:  aload_0
   13:  iconst_2
   14:  iconst_2
   15:  iastore
   16:  return

}

$javap-c——私有测试
从“Test.java”编译而来
公共类测试扩展了java.lang.Object{
公开考试（）；
代码：
0:aload_0
1:invokespecial#1；//方法java/lang/Object。“：（）V
4：返回
私有静态void inline（）；
代码：
0:iconst_3
1:newarray int
3:dup
4:iconst_0
5:iconst_0
6:iStore
7:dup
8:iconst_1
9:iconst_1
10:iStore
11:dup
12:iconst_2
13:iconst_2
14:iStore
15:astore_0
16：返回
私有静态void explicit（）；
代码：
0:iconst_3
1:newarray int
3:astore_0
4:aload_0
5:iconst_0
6:iconst_0
7:iStore
8:aload_0
9:iconst_1
10:iconst_1
11:iStore
12:aload_0
13:iconst_2
14:iconst_2
15:iStore
16：返回
}

（使用股票JDK 7编译。当然，确切的编译器行为可能会有所不同。）

唯一的区别是“内联”版本每次都使用

dup

访问

x

，而不是使用

aload\u 0

内存使用将是相同的，我希望JITted代码是相同的（因为它应该能够发现

aload\u 0

和

dup

在这里做同样的事情）

创建一个数组并设置值

int[] arr1 = new int[5];
arr1[0] = 0;
arr1[1] = 1;

第一行创建一个数组，该数组可以包含5个值，但未设置它们。 这就是最后两行所做的

---

关于性能，它取决于读写操作，在内存中大小相同

在效率或内存分配方面没有差异

因为这是一个基元数组，所以空间直接填充了值，而不仅仅是引用。因此，如果您声明一个包含5个整数的整数数组，那么直接为这些整数分配内存

---

使用

int[]arr={1,2,3,4,5}填充值纯粹是为了方便程序员。
不，不应该有任何性能差异。现代编译器应该将这两种情况减少到（几乎）相似的字节码。
多亏了现代java编译器，应该不会有任何区别。我不怀疑这一点，但在这里，javap转储会很好。非常好-我已经开始了基准测试路线（确认没有区别）-但你的观察平息了争论！
int[] arr1 = new int[5];
arr1[0] = 0;
arr1[1] = 1;