陣列的基本概念

如果說現在要求你定義100個整型變數，那麼如果按照之前的做法，可能現在定義的的結構如下：

int i1,i2,i3,... i100;

但是這個時候如果按照此類方式定義就會非常麻煩，因為這些變數彼此之間沒有任何的關聯，也就是說如果現在突然再有一個要求，要求你輸出這100個變數的內容，意味著你要編寫System.out.println()語句100次。

其實所謂的陣列指的就是一組相關型別的變數集合，並且這些變數可以按照統一的方式進行操作。陣列本身屬於引用資料型別，那麼既然是引用資料型別，這裡面實際又會牽扯到記憶體分配，而陣列的定義語法有如下兩類。

陣列動態初始化：

宣告並開闢陣列：

• 資料型別 [] 陣列名稱 = new 資料型別[長度];
• 資料型別 [] 陣列名稱 = new 資料型別[長度];
  

分佈進行陣列空間開闢（例項化）

| Tables | Are |

| ------------- |:-------------?

| 宣告陣列： | 陣列型別 陣列名稱[] = null; | | | 陣列型別 [] 陣列名稱 =null; | | 開闢陣列空間： | 陣列名稱 =new` 陣列型別[長度]; |

那麼當陣列開闢空間之後，就可以採用如下的方式的操作：

• 陣列的訪問通過索引完成，即：“陣列名稱[索引]”，但是需要注意的是，陣列的索引從0開始，所以索引的範圍就是0 ~ 陣列長度-1，例如開闢了3個空間的陣列，所以可以使用的索引是：0,1,2，如果此時訪問的時候超過了陣列的索引範圍，會產生java.lang.ArrayIndexOutOfBoundsException 異常資訊；
• 當我們陣列採用動態初始化開闢空間後，數組裡面的每一個元素都是該陣列對應資料型別的預設值；
• 陣列本身是一個有序的集合操作，所以對於陣列的內容操作往往會採用迴圈的模式完成，陣列是一個有限的資料集合，所以應該使用 for 迴圈。
• 在 Java 中提供有一種動態取得陣列長度的方式：陣列名稱.length；
  

範例： 定義一個int型陣列

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = new int[3]; /*開闢了一個長度為3的陣列*/
		data[0] = 10; // 第一個元素
		data[1] = 20; // 第二個元素
		data[2] = 30; // 第三個元素
		for(int x = 0; x < data.length; x++) {
			System.out.println(data[x]); //通過迴圈控制索引
		}
	}
}

陣列本身除了宣告並開闢空間之外還有另外一種開闢模式。

範例： 採用分步的模式開闢陣列空間

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null; 
		data = new int[3]; /*開闢了一個長度為3的陣列*/
		data[0] = 10; // 第一個元素
		data[1] = 20; // 第二個元素
		data[2] = 30; // 第三個元素
		for(int x = 0; x < data.length; x++) {
			System.out.println(data[x]); //通過迴圈控制索引
		}
	}
}

但是千萬要記住，陣列屬於引用資料型別，所以在陣列使用之前一定要開闢控制元件（例項化），如果使用了沒有開闢空間的陣列，則一定會出現 NullPointerException 異常資訊：

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null; 
		System.out.println(data[x]);
	}
}

這一原則和之前講解的物件是完全相同的。

陣列在開發之中一定會使用，但是像上面的操作很少。在以後的實際開發之中，會更多的使用陣列概念，而直接使用，99%情況下都只是做一個 for 迴圈輸出。

陣列引用傳遞

既然陣列屬於引用資料型別，那麼也一定可以發生引用傳遞。在這之前首先來研究一下陣列的空間開闢。

範例： 觀察一道程式

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null;
		data = new int[3]; //開闢一個長度為3的陣列
		data[0] = 10;
		data[1] = 20;
		data[2] = 30;
	}
}

那麼既然說到了引用資料型別了，就一定可以發生引用傳遞，而現在的引用傳遞的本質也一定是：同一塊堆記憶體空間可以被不同的棧記憶體所指向。

範例： 定義一個程式

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null;
		data = new int[3]; //開闢一個長度為3的陣列
		int temp[] = null; //宣告物件
		data[0] = 10;
		data[1] = 20;
		data[2] = 30;
		temp = data; //int temp[] = data;
		temp[0] = 99;
		for(int i = 0; i < temp.length; i++) {
			System.out.println(data[i]);
		}
	}
}

引用傳遞分析都是一個套路。同一塊堆記憶體被不同的棧記憶體所指向。

陣列靜態初始化

在之前所進行的陣列定義都有一個明顯特點：陣列先開闢記憶體空間，而後再使用索引進行內容的設定，實際上這種做法都叫做動態初始化，而如果希望陣列在定義的時候可以同時出現設定內容，那麼就可以採用靜態初始化完成。

陣列的靜態初始化一共分為以下兩種型別：

範例： 採用靜態初始化定義陣列

public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = {1,2,4,545,11,32,13131,4444};
		for(int i = 0; i < data.length; i++) {
			System.out.println(data[i]);
		}
	}
}

在開發之中，對於靜態陣列的初始化強烈建議使用完整語法模式，這樣可以輕鬆地使用匿名陣列這一概念。

public class ArrayDemo {
	public static void main(String args[]) {
		System.out.println(new int[] {1,4444}.length);
	}
}

以後使用靜態方式定義陣列的時候一定要寫上完整格式。

陣列最大的缺陷：長度固定。

二維陣列

在之前所使用的陣列發現只需要一個索引就可以進行訪問，那麼這樣的陣列實際上非常像一個數據行的概念。

現在痛過一個索引就可以取得唯一的一個記錄。所以這樣的陣列可以簡單理解為一維陣列，而二維陣列本質上指的是行列集合，也如果要確定某一個數據需要行索引和列索引來進行定位。

如果要想確定一個數據則資料使用的結構是“陣列名稱[行索引][列索引]”，所以這樣的結構就是一個表的結構。

那麼對二維陣列的定義有兩種宣告形式：

• 陣列的動態初始化：資料型別 物件陣列[][] = new 資料型別[行個數][列個數];
• 陣列的靜態初始化：資料型別 物件陣列[][] = new 資料型別[行個數][列個數]{{值,…},{值,…};
  

陣列的陣列就是二維陣列。

範例： 定義一個二維陣列

public class ArrayDemo {
	public static void main(String args[]) {
		//此時的陣列並不是一個等列陣列
		int data[][] = new int[][] {
			{1,3},{4,5},{6,7,8,9}};
		//如果在進行輸出的時候一定要使用雙重迴圈，
		//外部的迴圈控制輸出的行數，而內部的迴圈控制輸出列數
		for(int i = 0; i < data.length; i++) {
			for(int j = 0; j < data[i].length; j++) {
				System.out.print("data[" + i + "][" + j + "]=" + data[i][j] + "、");
			}
			System.out.println();
		}
	}
}

由於輸出麻煩，所以可以忽略了，在進行開發之中，出現二位陣列的機率並不高。

總結

到此這篇關於Java中陣列的定義和使用的文章就介紹到這了,更多相關Java陣列的定義和使用內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！