Question

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

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

任何人都可以解释这两件事之间的区别，例如内存分配，访问效率还是其他任何事情？

Answer 1

它们是等价的（假设您实际上将第一个中的值更改为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

}

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

唯一的区别是“内联”版本每次都使用dup来访问x，而不是使用aload_0。

内存使用情况将是相同的，我希望JITted代码相同（因为它应该能够发现aload_0和dup在这里做同样的事情。）< / p>

Answer 2

它们是等价的。

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

索引的值用1,2 ... 5初始化。

int[] arr1 = new int[5];

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

arr1 [0] = 0; arr1 [1] = 1; ..等

Answer 3

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

创建一个数组并设置值。

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

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

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

Answer 4

在效率或内存分配方面没有区别。

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

使用int[] arr = { 1, 2, 3, 4, 5 };向值填充它纯粹是为了方便程序员。

Answer 5

不，不应该有任何性能差异。现代编译器应该将这两种情况减少到（几乎）类似的字节代码。

数组声明的差异

5 个答案: