1、一维数组的声明方式：
 
type[] arrayName; 或 type arrayName[];
 
附：推荐使用第一种格式，因为第一种格式具有更好的可读性，表示type[]是一种引用类型(数组)而不是type类型。建议不要使用第二种方式
 
下面是典型的声明数组的方式：
 
// 声明整型数组
 
int[] intArray0 ;
 
int intArray1 [];
 
// 声明浮点型数组
 
float floatArray0 [];
 
float[] floatArray1 ;
 
// 声明布尔型数组
 
boolean boolArray0 [];
 
boolean[] boolArray1 ;
 
// 声明字符型数组
 
char charArray0 [];
 
char[] charArray1 ;
 
// 声明字符串数组
 
String stringArray0[];
 
String[] stringArray1;
 
// 错误的声明数组的方式，声明数组的时候不能指定其大小
 
// int [5] intErrorArray0;
 
// int intErrorArray1[5];
 
注：Java语言中声明数组时不能指定其长度(数组中元素的个数)，这是因为数组是一种引用类型的变量，，因此使用它定义一个变量时，仅仅表示定义了一个引用变量(也就是定一个了一个指针)，这个引用变量还未指向任何有效的内存，所以定义数组时不能指定数组的长度。而且由于定义数组仅仅只是定一个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，因此这个数组也不能使用，只有在数组进行初始化后才可以使用。
 
2、一维数组的创建
 
Java中使用关键字new创建数组对象，格式为：数组名 = new 数组元素的类型 [数组元素的个数]
 
// 创建数组，如果在创建的同时不初始化数组则必须指定其大小
 
intArray0 = new int[3];
 
// 错误的创建数组的方式，如果创建数组时不指定大小则必须初始化
 
// intArray1 = new int[];
 
// 创建数组时，不指定数组大小则必须在创建的同时初始化数组
 
intArray1 = new int[]{0,1,2};
 
使用new创建数组对象但是分配数组时会自动为数组分配默认值，具体如下：
 
System.out.println( "intArray0[0]=" + intArray0 [0]);
 
floatArray0 = new float[3];
 
System. out.println("floatArray0[0]=" + floatArray0[0]);
 
boolArray0 = new boolean[3];
 
System. out.println("boolArray0[0]=" + boolArray0[0]);
 
charArray0 = new char[3];
 
System. out.println("charArray0[0]=" + charArray0[0]);
 
stringArray0 = new String[3];
 
System. out.println("stringArray0[0]=" + stringArray0[0]);
 
输出如下：
 
intArray0[0]=0
 
floatArray0[0]=0.0
 
boolArray0[0]=false
 
charArray0[0]=
 
stringArray0[0]=null
 
附:一旦使用new关键字为数组分配了内存空间，每个内存空间存储的内容就是数组元素的值，也就是数组元素就有了初始值，即使这个内存空间存储的内容是空，这个空也是一个值null。也就是说不可能只分配内容空间而不赋初始值，即使自己在创建数组对象(分配内容空间)时没有指定初始值，系统也会自动为其分配
 
附：诸如基础数据类型的包装类，其默认的初始化值均为null，因为基础数据类型的包装类创建的数组属于引用数组(对象数组)，对象数组默认的初始化值都是null
 
3、一维数组的初始化
 
数组的初始化分为静态初始化、动态初始化和默认初始化：
 
静态初始化是数组在初始化时由程序员显式指定每个数组元素的初始值而数组长度由系统决定。
 
动态初始化是数组在初始化时只指定数组长度，由系统为数组元素分配初始值。
 
a、数组静态初始化的语法格式：
 
arrayName = new type[]{element1,element2,element3...}
 
或者使用简化的语法格式：
 
arrayName = {element1,element2,element3...}
 
b、数组动态初始化的语法格式：
 
arrayName = new type[length]；
 
附：静态初始化时不能指定元素个数，而动态初始化时则必须指定元素个数。静态初始化时数组能够知道元素的个数所以不需要指定，而动态初始化时数组元素个数未知因此必须指定。
 
// 静态初始化
 
int intArray2 [] = new int[]{20,21,22};
 
// 静态初始化简化方式
 
int intArray3 [] = {30,31,32};
 
// 动态初始化
 
int[] intArray4 = new int[3];
 
// 错误写法：静态初始化不能指定元素个数
 
// int intErrorArray5[] = new int[3]{50,51,52};
 
// 错误写法：动态初始化必须指定元素个数
 
// int intErrorArray6[] = new int[];
 
注：一维数组这一块记住两点，数组声明的时候是不能指定大小的，也就是说等号左边的中括号中不能包含数字。另外一旦使用new关键字那么肯定在内存中为数组分配了空间，则必然数组有默认值。数组是对象数据类型
 
注：不要静态初始化和动态初始化同时使用，也就是说不要再进行数组初始化时，既指定数组长度，也为每个数组元素分配初始值。
 
4、数组进行动态初始化时系统分配初始值的规则
 
数组元素类型是基本类型中的整数类型(byte、short、int、long)，则数组元素的值是0
 
数组元素类型是基本类型中的浮点类型(float、double)，则数组元素的值是0.0
 
数组元素类型是基本类型中的字符类型(char)，则数组元素的值是'\u0000'
 
数组元素类型是基本类型中的布尔类型(boolean)，则数组元素的值是false
 
数组元素类型是基本类型中的引用类型(类、接口、数组)，则数组元素的值是null
 
附：这部分源代码：
 
package javabase;
 
public class CreateArray {
 
public static void main(String args[]){
 
/**************数组的声明*******************/
 
// 声明整型数组
 
int[] intArray0 ;
 
int intArray1 [];
 
// 声明浮点型数组
 
float floatArray0 [];
 
float[] floatArray1 ;
 
// 声明布尔型数组
 
boolean boolArray0 [];
 
boolean[] boolArray1 ;
 
// 声明字符型数组
 
char charArray0 [];
 
char[] charArray1 ;
 
// 声明字符串数组
 
String stringArray0[];
 
String[] stringArray1;
 
// 错误的声明数组的方式，声明数组的时候不能指定其大小
 
// int [5] intErrorArray0;
 
// int intErrorArray1[5];
 
/*********************数组的创建***********************/
 
// 创建数组，如果在创建的同时不初始化数组则必须指定其大小
 
intArray0 = new int[3];
 
// 错误的创建数组的方式，如果创建数组时不指定大小则必须初始化
 
// intArray1 = new int[];
 
// 创建数组时，不指定数组大小则必须在创建的同时初始化数组
 
intArray1 = new int[]{0,1,2};
 
System. out.println("intArray0[0]=" + intArray0[0]);
 
floatArray0 = new float[3];
 
System. out.println("floatArray0[0]=" + floatArray0[0]);
 
boolArray0 = new boolean[3];
 
System. out.println("boolArray0[0]=" + boolArray0[0]);
 
charArray0 = new char[3];
 
System. out.println("charArray0[0]=" + charArray0[0]);
 
stringArray0 = new String[3];
 
System. out.println("stringArray0[0]=" + stringArray0[0]);
 
/**********************数组的初始化*************************/
 
// 静态初始化
 
int intArray2 [] = new int[]{20,21,22};
 
// 静态初始化简化方式
 
int intArray3 [] = {30,31,32};
 
// 动态初始化
 
int[] intArray4 = new int[3];
 
// 错误写法：静态初始化不能指定元素个数
 
// int intErrorArray5[] = new int[3]{50,51,52};
 
// 错误写法：动态初始化必须指定元素个数
 
// int intErrorArray6[] = new int[];
 
System. out.println("intArray2[0]=" +intArray2 [0]);
 
System. out.println("intArray3[0]=" +intArray3 [0]);
 
System. out.println("intArray4[0]=" +intArray4 [0]);
 
}
 
}
 
以上就是小编为大家带来的Java创建数组的几种方式总结的全部内容了，希望对大家有所帮助，多多支持脚本之家~

创建数组的三种方式：其实分为2类,一种是静态的创建，如方式一。一种是动态的创建，只不过根据写法的不同分为方式二和方式三：
 
      // 数组初始化的三种方式

      //1、声明，分配空间并赋值
      int[] arr0 = {0,1,2};
      //2、
      int[] arr1 ;   //声明，此时存放一个引用，为null
      arr1 = new int[]{0,1,2};   //分配空间并赋值
      //3、
      int[] arr2 ;  //声明，此时存放一个引用，为null
      arr2 = new int[3];        //分配空间
      //注：内存一旦分配不能改变，所有说数组长度固定
 
 
 
他们的区别，方式一：在声明的时候直接就已经分配空间，并赋值，方式一是不能写成如下这种形式的。
 
int[] arr1;
arr1 = {1,2,3};//错误写法 编译不同过
 

 方式二和方式三,声明和内存分配是分开的，如上面的例子，
 int[] arr2;  和  int[] arr3;
 这一步是在栈空间分配一个引用，存放的是一个引用，null
 
arr2 = new int[]{1,2,3};
 
到这一步的时候jvm才开始在内存堆区域分配空间，并赋值，方式二直接赋值 1,2,3  方式三 默认初始化，基本类型是 0  布尔类型是 false 引用类型为null，
  

 
Java创建数组的几种方式
 
1、一维数组的声明方式：
 
type［］ arrayName; 或 type arrayName［］;
 
附：推荐使用第一种格式，因为第一种格式具有更好的可读性，表示type［］是一种引用类型(数组)而不是type类型。建议不要使用第二种方式
 
下面是典型的声明数组的方式：
 
// 声明整型数组
 
int［］ intArray0 ;
 
int intArray1 ［］;
 
// 声明浮点型数组
 
float floatArray0 ［］;
 
float［］ floatArray1 ;
 
// 声明布尔型数组
 
boolean boolArray0 ［］;
 
boolean［］ boolArray1 ;
 
// 声明字符型数组
 
char charArray0 ［］;
 
char［］ charArray1 ;
 
// 声明字符串数组
 
String stringArray0［］;
 
String［］ stringArray1;
 
// 错误的声明数组的方式，声明数组的时候不能指定其大小
 
// int ［5］ intErrorArray0;
 
// int intErrorArray1［5］;
 
注：Java语言中声明数组时不能指定其长度(数组中元素的个数)，这是因为数组是一种引用类型的变量，因此使用它定义一个变量时，仅仅表示定义了一个引用变量(也就是定一个了一个指针)，这个引用变量还未指向任何有效的内存，所以定义数组时不能指定数组的长度。而且由于定义数组仅仅只是定一个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，因此这个数组也不能使用，只有在数组进行初始化后才可以使用。
 

 
2、一维数组的创建
 
Java中使用关键字new创建数组对象，格式为：数组名 = new 数组元素的类型 ［数组元素的个数］
 
// 创建数组，如果在创建的同时不初始化数组则必须指定其大小
 
intArray0 = new int［3］;
 
// 错误的创建数组的方式，如果创建数组时不指定大小则必须初始化
 
// intArray1 = new int［］;
 
// 创建数组时，不指定数组大小则必须在创建的同时初始化数组
 
intArray1 = new int［］{0，1，2};
 
使用new创建数组对象但是分配数组时会自动为数组分配默认值，具体如下：
 
System.out.println( “intArray0［0］=” + intArray0 ［0］);
 
floatArray0 = new float［3］;
 
System. out.println(“floatArray0［0］=” + floatArray0［0］);
 
boolArray0 = new boolean［3］;
 
System. out.println(“boolArray0［0］=” + boolArray0［0］);
 
charArray0 = new char［3］;
 
System. out.println(“charArray0［0］=” + charArray0［0］);
 
stringArray0 = new String［3］;
 
System. out.println(“stringArray0［0］=” + stringArray0［0］);
 
输出如下：
 
intArray0［0］=0
 
floatArray0［0］=0.0
 
boolArray0［0］=false
 
charArray0［0］=
 
stringArray0［0］=null
 
附：一旦使用new关键字为数组分配了内存空间，每个内存空间存储的内容就是数组元素的值，也就是数组元素就有了初始值，即使这个内存空间存储的内容是空，这个空也是一个值null。也就是说不可能只分配内容空间而不赋初始值，即使自己在创建数组对象(分配内容空间)时没有指定初始值，系统也会自动为其分配
 
附：诸如基础数据类型的包装类，其默认的初始化值均为null，因为基础数据类型的包装类创建的数组属于引用数组(对象数组)，对象数组默认的初始化值都是null
 

 
3、一维数组的初始化
 
数组的初始化分为静态初始化、动态初始化和默认初始化：
 
静态初始化是数组在初始化时由程序员显式指定每个数组元素的初始值而数组长度由系统决定。
 
动态初始化是数组在初始化时只指定数组长度，由系统为数组元素分配初始值。
 
a、数组静态初始化的语法格式：
 
arrayName = new type［］{element1，element2，element3.。.}或者使用简化的语法格式：arrayName = {element1，element2，element3.。.}
 
b、数组动态初始化的语法格式：
 
arrayName = new type［length］；
 
附：静态初始化时不能指定元素个数，而动态初始化时则必须指定元素个数。静态初始化时数组能够知道元素的个数所以不需要指定，而动态初始化时数组元素个数未知因此必须指定。
 
// 静态初始化
 
int intArray2 ［］ = new int［］{20，21，22};
 
// 静态初始化简化方式
 
int intArray3 ［］ = {30，31，32};
 
// 动态初始化
 
int［］ intArray4 = new int［3］;
 
// 错误写法：静态初始化不能指定元素个数
 
// int intErrorArray5［］ = new int［3］{50，51，52};
 
// 错误写法：动态初始化必须指定元素个数
 
// int intErrorArray6［］ = new int［］;
 
注：一维数组这一块记住两点，数组声明的时候是不能指定大小的，也就是说等号左边的中括号中不能包含数字。另外一旦使用new关键字那么肯定在内存中为数组分配了空间，则必然数组有默认值。数组是对象数据类型
 
注：不要静态初始化和动态初始化同时使用，也就是说不要再进行数组初始化时，既指定数组长度，也为每个数组元素分配初始值。
 

 
4、数组进行动态初始化时系统分配初始值的规则
 
数组元素类型是基本类型中的整数类型(byte、short、int、long)，则数组元素的值是0
 
数组元素类型是基本类型中的浮点类型(float、double)，则数组元素的值是0.0
 
数组元素类型是基本类型中的字符类型(char)，则数组元素的值是‘\u0000’
 
数组元素类型是基本类型中的布尔类型(boolean)，则数组元素的值是false
 
数组元素类型是基本类型中的引用类型(类、接口、数组)，则数组元素的值是null
 
附：这部分源代码：
 
package javabase;
 
public class CreateArray {
 
public static void main(String args［］){
 
/**************数组的声明*******************/
 
// 声明整型数组
 
int［］ intArray0 ;
 
int intArray1 ［］;
 
// 声明浮点型数组
 
float floatArray0 ［］;
 
float［］ floatArray1 ;
 
// 声明布尔型数组
 
boolean boolArray0 ［］;
 
boolean［］ boolArray1 ;
 
// 声明字符型数组
 
char charArray0 ［］;
 
char［］ charArray1 ;
 
// 声明字符串数组
 
String stringArray0［］;
 
String［］ stringArray1;
 
// 错误的声明数组的方式，声明数组的时候不能指定其大小
 
// int ［5］ intErrorArray0;
 
// int intErrorArray1［5］;
 
/*********************数组的创建***********************/
 
// 创建数组，如果在创建的同时不初始化数组则必须指定其大小
 
intArray0 = new int［3］;
 
// 错误的创建数组的方式，如果创建数组时不指定大小则必须初始化
 
// intArray1 = new int［］;
 
// 创建数组时，不指定数组大小则必须在创建的同时初始化数组
 
intArray1 = new int［］{0，1，2};
 
System. out.println(“intArray0［0］=” + intArray0［0］);
 
floatArray0 = new float［3］;
 
System. out.println(“floatArray0［0］=” + floatArray0［0］);
 
boolArray0 = new boolean［3］;
 
System. out.println(“boolArray0［0］=” + boolArray0［0］);
 
charArray0 = new char［3］;
 
System. out.println(“charArray0［0］=” + charArray0［0］);
 
stringArray0 = new String［3］;
 
System. out.println(“stringArray0［0］=” + stringArray0［0］);
 

 
/**********************数组的初始化*************************/
 
// 静态初始化
 
int intArray2 ［］ = new int［］{20，21，22};
 
// 静态初始化简化方式
 
int intArray3 ［］ = {30，31，32};
 
// 动态初始化
 
int［］ intArray4 = new int［3］;
 
// 错误写法：静态初始化不能指定元素个数
 
// int intErrorArray5［］ = new int［3］{50，51，52};
 
// 错误写法：动态初始化必须指定元素个数
 
// int intErrorArray6［］ = new int［］;
 
System. out.println(“intArray2［0］=” +intArray2 ［0］);
 
System. out.println(“intArray3［0］=” +intArray3 ［0］);
 
System. out.println(“intArray4［0］=” +intArray4 ［0］);
 
}
 
}
 
java 创建数组的三种方式的区别
 
他们的区别，方式一：在声明的时候直接就已经分配空间，并赋值，方式一是不能写成如下这种形式的。
 
int［］ arr1;
 
arr1 = {1，2，3};//错误写法 编译不同过
 
方式二和方式三，声明和内存分配是分开的，如上面的例子，
 
int［］ arr2; 和 int［］ arr3;
 
这一步是在栈空间分配一个引用，存放的是一个引用，null
 
arr2 = new int［］{1，2，3};
 
arr3 = new int［3］;
 
到这一步的时候jvm才开始在内存堆区域分配空间，并赋值，方式二直接赋值 1，2，3 方式三 默认初始化，基本类型是 0 布尔类型是 false 引用类型为null，
 
注：内存一旦分配不能改变，所有说数组长度固定

 
1、一维数组的声明方式：
 
type[] arrayName; 或 type arrayName[];
 
附：推荐使用第一种格式，因为第一种格式具有更好的可读性，表示type[]是一种引用类型(数组)而不是type类型。建议不要使用第二种方式
 
下面是典型的声明数组的方式：
 
// 声明整型数组
 
int[]
 
intArray0
 
;
 
int
 
intArray1
 
[];
 
// 声明浮点型数组
 
float
 
floatArray0
 
[];
 
float[]
 
floatArray1
 
;
 
// 声明布尔型数组
 
boolean
 
boolArray0
 
[];
 
boolean[]
 
boolArray1
 
;
 
// 声明字符型数组
 
char
 
charArray0
 
[];
 
char[]
 
charArray1
 
;
 
// 声明字符串数组
 
String
 
stringArray0[];
 
String[]
 
stringArray1;
 
// 错误的声明数组的方式，声明数组的时候不能指定其大小
 
//
 
int [5] intErrorArray0;
 
//
 
int intErrorArray1[5];
 
注：Java语言中声明数组时不能指定其长度(数组中元素的个数)，这是因为数组是一种引用类型的变量，，因此使用它定义一个变量时，仅仅表示
 
定义了一个引用变量(也就是定一个了一个指针)，这个引用变量还未指向任何有效的内存，所以定义数组时不能指定数组的长度。而且由于定义数组仅仅只是定一
 
个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，因此这个数组也不能使用，只有在数组进行初始化后才可以使用。
 
2、一维数组的创建
 
Java中使用关键字new创建数组对象，格式为：数组名 = new 数组元素的类型 [数组元素的个数]
 
// 创建数组，如果在创建的同时不初始化数组则必须指定其大小
 
intArray0
 
=
 
new
 
int[3];
 
// 错误的创建数组的方式，如果创建数组时不指定大小则必须初始化
 
// intArray1 = new
 
int[];
 
// 创建数组时，不指定数组大小则必须在创建的同时初始化数组
 
intArray1
 
=
 
new
 
int[]{0,1,2};
 
使用new创建数组对象但是分配数组时会自动为数组分配默认值，具体如下：
 
System.out.println(
 
"intArray0[0]="
 
+
 
intArray0
 
[0]);
 
floatArray0
 
=
 
new
 
float[3];
 
System.
 
out.println("floatArray0[0]="
 
+
 
floatArray0[0]);
 
boolArray0
 
=
 
new
 
boolean[3];
 
System.
 
out.println("boolArray0[0]="
 
+
 
boolArray0[0]);
 
charArray0
 
=
 
new
 
char[3];
 
System.
 
out.println("charArray0[0]="
 
+
 
charArray0[0]);
 
stringArray0
 
=
 
new
 
String[3];
 
System.
 
out.println("stringArray0[0]="
 
+
 
stringArray0[0]);
 
输出如下：
 
intArray0[0]=0
 
floatArray0[0]=0.0
 
boolArray0[0]=false
 
charArray0[0]=
 
stringArray0[0]=null
 
附:
 
一旦使用new关键字为数组分配了内存空间，每个内存空间存储的内容就是数组元素的值，也就是数组元素就有了初始值，即使这个内存空间存储的内容是空，这
 
个空也是一个值null。也就是说不可能只分配内容空间而不赋初始值，即使自己在创建数组对象(分配内容空间)时没有指定初始值，系统也会自动为其分配
 
附：诸如基础数据类型的包装类，其默认的初始化值均为null，因为基础数据类型的包装类创建的数组属于引用数组(对象数组)，对象数组默认的初始化值都是null
 
3、一维数组的初始化
 
数组的初始化分为静态初始化、动态初始化和默认初始化：
 
静态初始化是数组在初始化时由程序员显式指定每个数组元素的初始值而数组长度由系统决定。
 
动态初始化是数组在初始化时只指定数组长度，由系统为数组元素分配初始值。
 
a、数组静态初始化的语法格式：
 
arrayName = new type[]{element1,element2,element3...}或者使用简化的语法格式：arrayName = {element1,element2,element3...}
 
b、数组动态初始化的语法格式：
 
arrayName = new type[length]；
 
附：静态初始化时不能指定元素个数，而动态初始化时则必须指定元素个数。静态初始化时数组能够知道元素的个数所以不需要指定，而动态初始化时数组元素个数未知因此必须指定。
 
// 静态初始化
 
int
 
intArray2
 
[] =
 
new
 
int[]{20,21,22};
 
// 静态初始化简化方式
 
int
 
intArray3
 
[] = {30,31,32};
 
// 动态初始化
 
int[]
 
intArray4
 
=
 
new
 
int[3];
 
// 错误写法：静态初始化不能指定元素个数
 
//
 
int intErrorArray5[] = new
 
int[3]{50,51,52};
 
// 错误写法：动态初始化必须指定元素个数
 
//
 
int intErrorArray6[] = new
 
int[];
 
注：一维数组这一块记住两点，数组声明的时候是不能指定大小的，也就是说等号左边的中括号中不能包含数字。另外一旦使用new关键字那么肯定在内存中为数组分配了空间，则必然数组有默认值。数组是对象数据类型
 
注：不要静态初始化和动态初始化同时使用，也就是说不要再进行数组初始化时，既指定数组长度，也为每个数组元素分配初始值。
 
4、数组进行动态初始化时系统分配初始值的规则
 
数组元素类型是基本类型中的整数类型(byte、short、int、long)，则数组元素的值是0
 
数组元素类型是基本类型中的浮点类型(float、double)，则数组元素的值是0.0
 
数组元素类型是基本类型中的字符类型(char)，则数组元素的值是'\u0000'
 
数组元素类型是基本类型中的布尔类型(boolean)，则数组元素的值是false
 
数组元素类型是基本类型中的引用类型(类、接口、数组)，则数组元素的值是null
 
附：这部分源代码：
 
package
 
javabase;
 
public
 
class
 
CreateArray {
 
public
 
static
 
void
 
main(String
 
args[]){
 
/**************数组的声明*******************/
 
// 声明整型数组
 
int[]
 
intArray0
 
;
 
int
 
intArray1
 
[];
 
// 声明浮点型数组
 
float
 
floatArray0
 
[];
 
float[]
 
floatArray1
 
;
 
// 声明布尔型数组
 
boolean
 
boolArray0
 
[];
 
boolean[]
 
boolArray1
 
;
 
// 声明字符型数组
 
char
 
charArray0
 
[];
 
char[]
 
charArray1
 
;
 
// 声明字符串数组
 
String
 
stringArray0[];
 
String[]
 
stringArray1;
 
// 错误的声明数组的方式，声明数组的时候不能指定其大小
 
//
 
int [5] intErrorArray0;
 
//
 
int intErrorArray1[5];
 
/*********************数组的创建***********************/
 
// 创建数组，如果在创建的同时不初始化数组则必须指定其大小
 
intArray0
 
=
 
new
 
int[3];
 
// 错误的创建数组的方式，如果创建数组时不指定大小则必须初始化
 
// intArray1 = new
 
int[];
 
// 创建数组时，不指定数组大小则必须在创建的同时初始化数组
 
intArray1
 
=
 
new
 
int[]{0,1,2};
 
System.
 
out.println("intArray0[0]="
 
+
 
intArray0[0]);
 
floatArray0
 
=
 
new
 
float[3];
 
System.
 
out.println("floatArray0[0]="
 
+
 
floatArray0[0]);
 
boolArray0
 
=
 
new
 
boolean[3];
 
System.
 
out.println("boolArray0[0]="
 
+
 
boolArray0[0]);
 
charArray0
 
=
 
new
 
char[3];
 
System.
 
out.println("charArray0[0]="
 
+
 
charArray0[0]);
 
stringArray0
 
=
 
new
 
String[3];
 
System.
 
out.println("stringArray0[0]="
 
+
 
stringArray0[0]);
 
/**********************数组的初始化*************************/
 
// 静态初始化
 
int
 
intArray2
 
[] =
 
new
 
int[]{20,21,22};
 
// 静态初始化简化方式
 
int
 
intArray3
 
[] = {30,31,32};
 
// 动态初始化
 
int[]
 
intArray4
 
=
 
new
 
int[3];
 
// 错误写法：静态初始化不能指定元素个数
 
//
 
int intErrorArray5[] = new
 
int[3]{50,51,52};
 
// 错误写法：动态初始化必须指定元素个数
 
//
 
int intErrorArray6[] = new
 
int[];
 
System.
 
out.println("intArray2[0]="
 
+intArray2
 
[0]);
 
System.
 
out.println("intArray3[0]="
 
+intArray3
 
[0]);
 
System.
 
out.println("intArray4[0]="
 
+intArray4
 
[0]);
 
}
 
}