String数组初始化

javap -help
Usage: javap <options> <classes>...where options include:
   -c                        Disassemble the code
   -classpath <pathlist>     Specify where to find user class files
   -extdirs <dirs>           Override location of installed extensions
   -help                     Print this usage message
   -J<flag>                  Pass <flag> directly to the runtime system
   -l                        Print line number and local variable tables
   -public                   Show only public classes and members
   -protected                Show protected/public classes and members
   -package                  Show package/protected/public classes
                             and members (default)
   -private                  Show all classes and members
   -s                        Print internal type signatures
   -bootclasspath <pathlist> Override location of class files loaded
                             by the bootstrap class loader
   -verbose                  Print stack size, number of locals and args for methods
                             If verifying, print reasons for failure

String[] str = {"1","2","3"}
内存中是静态初始化
String[] str = new String[]{"1","2","3"}
则是动态分配内存

你确定么？
String太特殊了。
我不敢确定

肯定有区别
String[] str = {"1","2","3"}，内存栈中会给分配内存，用于指向内存栈中的地址
String[] str = new String[]{"1","2","3"}是在堆中分配内存，用于指向堆中内存，同时会有一个引用的变量指向引用。这就是区别。你可以不用关心这些，直接用就可以了

你确定在String[]时的分配方式，是跟String时的方式是一样的么？

一样。《Java Rules 中文版》6.3.5 明确指出：这两个变量声明的结果是一样的。网上有电子书可下。搜索一下就找到了。

肯定有区别
String[] str = {"1","2","3"}，str在内存是在栈区
String[] str = new String[]{"1","2","3"}
str在内存是在堆区

有区别
String[] str = {"1","2","3"}
是创建0或1个对象
如果内存中没有{"1","2","3"}则创建一个新的对象
String[] str = new String[]{"1","2","3"}
是创建1或2个对象
这个是不管有没有都创建了对象

1\Test.class
1\Test.java
2\Test.class
2\Test.java
3\Test.class
3\Test.java
4\Test.class
4\Test.java
其中，1 2 对比；3 4 对比。
type 1\Test.java
public class Test{
        private String[] str = {"1","2","3"};
}
javac 1\Test.java
javap -classpath 1 -c 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:   aload_0
   5:   iconst_3
   6:   anewarray       #2; //class java/lang/String
   9:   dup
   10:  iconst_0
   11:  ldc     #3; //String 1
   13:  aastore
   14:  dup
   15:  iconst_1
   16:  ldc     #4; //String 2
   18:  aastore
   19:  dup
   20:  iconst_2
   21:  ldc     #5; //String 3
   23:  aastore
   24:  putfield        #6; //Field str:[Ljava/lang/String;
   27:  return}type 2\Test.javapublic class Test{
        private String[] str = new String[] {"1","2","3"};
}
javac 2\Test.java
javap -classpath 2 -c 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:   aload_0
   5:   iconst_3
   6:   anewarray       #2; //class java/lang/String
   9:   dup
   10:  iconst_0
   11:  ldc     #3; //String 1
   13:  aastore
   14:  dup
   15:  iconst_1
   16:  ldc     #4; //String 2
   18:  aastore
   19:  dup
   20:  iconst_2
   21:  ldc     #5; //String 3
   23:  aastore
   24:  putfield        #6; //Field str:[Ljava/lang/String;
   27:  return}
=================================================================================
type 3\Test.java
public interface Test{
        String[] str = new String[] {"1","2","3"};
}
javac 3\Test.java
javap -classpath 3 -c Test
Compiled from "Test.java"
public interface Test{
public static final java.lang.String[] str;static {};
  Code:
   0:   iconst_3
   1:   anewarray       #1; //class java/lang/String
   4:   dup
   5:   iconst_0
   6:   ldc     #2; //String 1
   8:   aastore
   9:   dup
   10:  iconst_1
   11:  ldc     #3; //String 2
   13:  aastore
   14:  dup
   15:  iconst_2
   16:  ldc     #4; //String 3
   18:  aastore
   19:  putstatic       #5; //Field str:[Ljava/lang/String;
   22:  return}type 4\Test.java
public interface Test{
        String[] str = {"1","2","3"};
}javac 4\Test.java
javap -classpath 4 -c Test
Compiled from "Test.java"
public interface Test{
public static final java.lang.String[] str;static {};
  Code:
   0:   iconst_3
   1:   anewarray       #1; //class java/lang/String
   4:   dup
   5:   iconst_0
   6:   ldc     #2; //String 1
   8:   aastore
   9:   dup
   10:  iconst_1
   11:  ldc     #3; //String 2
   13:  aastore
   14:  dup
   15:  iconst_2
   16:  ldc     #4; //String 3
   18:  aastore
   19:  putstatic       #5; //Field str:[Ljava/lang/String;
   22:  return}

又不是C++，java的对象怎么会出现在栈中？？

String[] str = {"1","2","3"}
//静态初始化、与堆内存无关、直接在栈内存完成初始值的赋予（栈存值）与String[] str = new String[]{"1","2","3"}
/**
* 一使用了堆内存和栈内存
* 程序首先通过NEW 关键字创建一个索引【栈中存放该索引的首地址】（栈存首地址）
* 然后通过创建一个对象【堆内存中】（堆存值）
/

《Java Rules 中文版》6.3.2 数组类是动态创建的
当执行数组初始化器或数组创建表达式时，数组被动态创建。数组的组件类型可以是任何类型并且是数组类型的一部分。如果通过扩展，将有无数种数组类型。有人说数组类型正交于（orthogonal）类型系统，这个数学术语说每个类型都有一个相关的数组类型。为潜在的无数种数组类型编写源代码是不可能的。建立一个数组类之前你必须知道组件类和维数。这就是数组为什么要动态创建的原因。你可以用java.lang.reflect.Array类里的newInstance(Class componentType,int length)方法自己创建数组类。

说不同的都是错误的。
我不相信相同的字节码，JVM 还会有不同的解释。
按我在24L写的自己编译比较一下知道谁对谁错了。

编译执行结果没有任何区别。
更不可能像有些人想当然说的在栈上分配空间，Java的对象都是在堆上分配空间的。这里的区别仅仅是代码书写上的：
String[] str = {"1","2","3"}; 这种形式叫数组初始化式（Array Initializer），只能用在声明同时赋值的情况下。
而 String[] str = new String[]{"1","2","3"} 是一般形式的赋值，=号的右边叫数组字面量（Array Literal），数组字面量可以用在任何需要一个数组的地方（类型兼容的情况下）。如：String[] str = {"1","2","3"};  // 正确的String[] str = new String[]{"1","2","3"} // 也是正确的而String[] str;
str = {"1","2","3"};   // 编译错误因为数组初始化式只能用于声明同时赋值的情况下。改为：String[] str;
str = new String[] {"1","2","3"};   // 正确了又如：void f(String[] str) {
}f({"1","2","3"});    // 编译错误正确的应该是：f(new String[] {"1","2","3"});从回帖看，太多人忽视这些基础知识的学习了。

有区别的
String[] str = {"1","2","3"} 是str内的元素直接指向内存中的静态区的，在静态区中存放"1","2","3"这三个数。
而String[] str = new String[]{"1","2","3"} 是在堆区存放指向静态区中这三个数的地址，再在栈区中创建三个引用指向堆区中的三个元素

String[] str = new String[] {这里执行动态加入元素的语法};
一般用作动态加入数组元素的,在不确定数组元素的情况下使用这样语句.

调试易

String数组初始化

解决方案 »