java数组初始化详解

末蓝、 2022-04-10 13:13 315阅读 0赞

### 一维数组： ###

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

### 数组的初始化： ###

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

静态初始化是在声明数组的同时进行辅助，动态初始化是在先声明数组，然后再对其进行赋值

1. 静态初始化

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;
    	}
    }

2. 动态初始化

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]);
    	}
    }

### 数组元素的引用： ###

一维数组元素的引用方式为： **arrayName\[index\]**

index为数组下标，它可以为整型常数或表达式，下标从0开始。每个数组都有一个属性length来指明它的长度。

例如：intArray.length指明数组intArray的长度

在编写程序的过程中，如果要引用数组的长度，一般是使用变量“length”，在程序中一般是使用下列格式：

数组名.length

--------------------

**补充：**

java中接口的对象声明，初始化只能为null，无法创建接口对象。