一维数组与二维数组的声明

一维数组的声明：

1. int[] a; //只声明数组a，没有初始化

2. int[] a = new int[5]; //初始化为默认值，int型为0

3. int[] a = {1,2,3,4,5}; //初始化为给定值

4. int[] a = new int[] {1,2,3,4,5}; //初始化为给定值

   int[] a = new int[5] {1,2,3,4,5}; //错误，如果提供了数组初始化操作，则不能定义维表达式

5. int[] a; a = new int[5]; //正确，与（2）相同

   int[] a; a = {1,2,3,4,5}; //错误，数据常量只能在初始化操作中使用，如（3）

6. int a[]; a[0] = 1; a[1] = 2; //错误，因为数组没有初始化，不能直接赋值

二维数组的声明：

1. int[][] a; //只声明数组a，没有初始化

2. int[][] a = new int[2][3]; //初始化为默认值，int型为0

3. int[][] a = {
   {1,2},{2,3},{3,4}}; //初始化为给定值

   int[][] a = {
   {1,2},{2,3},{3,4,5}}; //正确，数组空间不是连续分配的，所以不要求每一维的空间大小相同

4. int[][] a = new int[2][];

   a[0] = new int[3]; // a[0]其实就是一个一维数组

   a[1] = new int[4]; //每一维的大小可以不一样

5. int[][] a = new int[][]{
   {1,2},{2,3},{3,4,5}}; //正确，与（3）相同

   int[] a = new int[5]{
   {1,2},{2,3},{3,4,5}}; //错误，如果提供了数据初始化操作，则不能定义维度表达式

   int[][] a = new int[2][]; a[0] = {1,2,3,4,5}; //错误，数组常量只能在初始化操作中使用

6. int[][] a = new int[2][]; a[0][1] = 1; //错误，第二维没有初始化，不能赋值。出现java.lang.NullPointerException异常

总结

1. 数组是对象类型数据，声明数组时注意new的使用 二维数组就是数组的数组，里面的数组大小不要求一样
2. 不管是一维数组还是二维数组，在使用前（赋值，访问）必须初始化，可以使用new默认初始化，也可以用数组常量初始化
3. 声明数组是，一定要考虑数组的最大容量，防止容量不够的现象。数组一旦被声明，它的容量就固定了，不容改变。如果想在运行程序时改变容量，就需要用到数组列表
4. 数组有一个缺点，就是一旦声明，就不能改变容量，这个也是其使用率不高的原因，一般存储数据会使用数组列表或vector，这两种数据结构来存储数据

数组的初始化

• 动态初始化：数组定义与为数组分配空间和赋值操作分开进行(静态初始化是在声明数组的同时进行辅助，动态初始化是在先声明数组，然后再对其进行赋值)
• 静态初始化：在定义数组的同时就为数组元素分配空间并赋值(静态初始化是在声明数组的同时进行辅助，动态初始化是在先声明数组，然后再对其进行赋值)
• 默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被默认初始化

静态初始化

int intArray[] = { 
   1,2,3,4};
String stringArray[] = { 
   "abc" ,"bcd", "cde" };

//TestS.java（静态）
public class TestS{ 
   
    public static void main(String[] args) { 
   
		int[] a = { 
   1,2,3};
		Time times[] = { 
   new Time(15,53,23),new Time(15,52,24),new Time(15,51,25)};
		System.out.println("a[0] = " + a[0] + "\n" + "a[1] = " + a[1] + "\n"  + "a[2] = " + a[2]);
	}
}
 
class Time{ 
   
	int hour,min,sec;
	Time(int hour,int min,int sec){ 
   
		this.hour = hour;
		this.min = min;
		this.sec = sec;
	}
}

动态初始化

int intArray[];    intArray = new int[5];
String stringArray[];    stringArray = new String[3];  //为数组中每个元素开辟引用空间（32位）
stringArray[0] = new String("How");  //为第一个数组元素开辟引用空间（32位）
stringArray[1] = new String("are");  //为第二个数组元素开辟引用空间（32位）
stringArray[2] = new String("you");  //为第三个数组元素开辟引用空间（32位）

//TestD.java（动态）
public class TestD{ 
   
	public static void main(String[] args) { 
   
		int[] a;
		a = new int[3];
		a[0] = 0;
		a[1] = 1;
		a[2] = 2;
 
		Date days[];
		days = new Date[3];
		days[0] = new Date(2019,1,7);
		days[1] = new Date(2019,1,8);
		days[2] = new Date(2019,1,9);
 
		System.out.println("days[0] = "+days[0] + "\n" +"days[1] = "+days[1] + "\n"+"days[2] = "+days[2]);
	}
}
class Date{ 
   
    int year,month,day;
    Date(int year,int month,int day){ 
   
    	this.year = year;
    	this.month = month;
    	this.day = day;
    }	
}

默认初始化

//TestDefault（默认）
public class TestDefault{ 
   
	public static void main(String[] args) { 
   
		int[] a = new int[5];
		System.out.println(""+a[3]);
	}
}

今天的文章java一维数组、二维数组初始化分享到此就结束了，感谢您的阅读。