事实上，初始化方式 {1,2} 是 new int[]{1,2} 的简写。下面演示两者：

    1. public void arrayTest1(){
    2.     int[] array = new int[]{1,2,3};
    3. }
    5. public void arrayTest2(){
    6.     int[] array = {1,2,3};  
    7. }

    看下反编译结果，两者是一样的。

    1.   public void arrayTest1();
    2.     Code:
    3.        0: iconst_3
    4.        1: newarray       int
    5.        3: dup
    6.        4: iconst_0
    7.        5: iconst_1
    8.        6: iastore
    9.        7: dup
    10.        8: iconst_1
    11.        9: iconst_2
    12.       10: iastore
    13.       11: dup
    14.       12: iconst_2
    15.       13: iconst_3
    16.       14: iastore
    17.       15: astore_1
    18.       16: return
    20.   public void arrayTest2();
    21.     Code:
    22.        0: iconst_3
    23.        1: newarray       int
    24.        3: dup
    25.        4: iconst_0
    26.        5: iconst_1
    27.        6: iastore
    28.        7: dup
    29.        8: iconst_1
    30.        9: iconst_2
    31.       10: iastore
    32.       11: dup
    33.       12: iconst_2
    34.       13: iconst_3
    35.       14: iastore
    36.       15: astore_1
    37.       16: return

    但他们又略有不同，简写形式只能用于 int[] 类型变量初始化。

    1. int arr[] = {1,2}; //✅
    3. int arr[];
    4. arr = {1,2}; // ❌ERROR

    第4行是赋值，不是初始化，不能用简写形式。

    1. int arr[];
    2. arr = new int[] {1,2}; //✅