Java中數組的定義與使用
一、數組的基本用法
1.什麼是數組
數組本質上就是讓我們能 “批量” 創建相同類型的變量。
如果我們需要創建多個同一個類型的變量，則不可能手動一個接一個地創建，如：int n=10; int m =20;int y = 30;等等，因此數組能幫我們批量創建同一個類型的數據。
註意事項: 在 Java 中, 數組中包含的變量必須是相同類型。
2.創建數組
基本語法：
// 動態初始化
數據類型[] 數組名稱 = new 數據類型 [] { 初始化數據 };
// 靜態初始化
數據類型[] 數組名稱 = { 初始化數據 };
//不初始化
數據類型[] 數組名稱 = new 數據類型[需要創建的數組長度];
代碼示例：
int[] arr = new int[]{1, 2, 3};
int[] arr = {1, 2, 3};
int[] arr = new int[3];
註意事項: 靜態初始化的時候, 數組元素個數和初始化數據的格式是一致的。
雖然我們也可以使用：int arr[] = {1, 2, 3}; ，但是還是更推薦寫成 int[] arr 的形式，int和 [] 是一個整體。
3.數組的使用
int[] arr = {1, 2, 3};
// 獲取數組長度
System.out.println("length: " + arr.length); // 執行結果: 3
// 訪問數組中的元素
System.out.println(arr[1]); // 執行結果: 2
System.out.println(arr[0]); // 執行結果: 1
arr[2] = 100;
System.out.println(arr[2]); // 執行結果: 100
1.使用 arr.length 能夠獲取到數組的長度，. 這個操作為成員訪問操作符. 後面在面向對象中會經常用到。
2.使用 [ ] 按下標取數組元素. 需要註意, 下標從 0 開始計數。
3.使用 [ ] 操作既能讀取數據, 也能修改數據。
4.下標訪問操作不能超出有效范圍 [0, length – 1] , 如果超出有效范圍, 會出現下標越界異常。
代碼示例: 下標越界
int[] arr = {1, 2, 3};
System.out.println(arr[100]);
// 執行結果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100 at Test.main(Test.java:4)
拋出瞭 java.lang.ArrayIndexOutOfBoundsException 異常，使用數組一定要下標謹防越界。
代碼示例:遍歷數組
所謂 “遍歷” 是指將數組中的所有元素都訪問一遍, 不重不漏，通常需要搭配循環語句。
int[] arr = {1, 2, 3}; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]);
}
// 執行結果
1
2
3
代碼示例: 使用 for-each 遍歷數組
int[] arr = {1, 2, 3};
for (int x : arr) {
System.out.println(x);
}
// 執行結果
1
2
3
for-each 是 for 循環的另外一種使用方式，能夠更方便的完成對數組的遍歷，可以避免循環條件和更新語句寫錯。
for-each的另一種使用方式，它隻能遍歷數組的所有數據，遍歷時x能讀取數組中的對應下標中的數據。
代碼示例：
int[] arr={1,2,3,4,2};
int count = 0 ;
for (int x:arr) {
if(x==2) {
count++;
}
}
System.out.println(count);//結果為2
二、數據作為方法參數
1.基本用法
代碼示例: 打印數組內容
public static void main(String[] args) {
int[] arr = {1, 2, 3};
printArray(arr);
}
public static void printArray(int[] a) {
for (int x : a) {
System.out.println(x);
}
}
// 執行結果
1
2
3
註意：
1.int[] a 是函數的形參, int[] arr 是函數實參。
2.如果需要獲取到數組長度, 同樣可以使用 a.length 。
2.理解引用類型
代碼示例1 參數傳內置類型
public static void main(String[] args) {
int num = 0;
func(num);
System.out.println("num = " + num);
}
public static void func(int x) {
x = 10;
System.out.println("x = " + x);
}
// 執行結果
x = 10
num = 0
代碼示例2 參數傳數組類型
public static void main(String[] args) {
int[] arr = {1, 2, 3};
func(arr);
System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
a[0] = 10;
System.out.println("a[0] = " + a[0]);
}
// 執行結果
a[0] = 10
arr[0] = 10
我們發現, 在方法內部修改數組內容, 方法外部也發生改變.
此時數組名 arr 是一個 “引用” ， 當傳參的時候, 是按照引用傳參，引用類型類似於C語言中的指針，但卻有許多地方不同。
引用可以理解為：創建一個引用隻是相當於創建瞭一個很小的變量, 這個變量保存瞭一個整數, 這個整數表示內存中的一個地址。
針對 int[] arr = new int[]{1, 2, 3} 這樣的代碼, 內存佈局如圖：
當我們創建 new int[]{1, 2, 3} 的時候, 相當於創建瞭一塊內存空間保存三個 int。接下來執行 int[] arr = new int[]{1, 2, 3} 相當於又創建瞭一個 int[] 變量, 這個變量是一個引用類型, 裡面隻保存瞭一個整數(數組的起始內存地址)
3.接下來傳參相當於 int[] a = arr , 內存佈局如圖：
4. 接下來我們修改 a[0] , 此時是根據 0x100 這樣的地址找到對應的內存位置, 將值改成 100 。內存佈局如圖：
正是因為int[] arr與int[] a指向的內存空間都為在arr創建時的新的對象（三個整型數據），因此雖然其中一個數據改瞭，但是arr與a指向的空間不變，因此arr與a都會隨著對象的改變而改變，這就是引用。
總結: 所謂的 “引用” 本質上隻是存瞭一個地址，Java 將數組設定成引用類型, 這樣的話後續進行數組參數傳參, 其實隻是將數組的地址傳入到函數形參中，這樣可以避免對整個數組的拷貝(數組可能比較長, 那麼拷貝開銷就會很大）
3.認識null
null 在 Java 中表示 “空引用” , 也就是一個無效的引用。
代碼示例：
int[] arr = null;
System.out.println(arr[0]);
// 執行結果
Exception in thread “main” java.lang.NullPointerException at Test.main(Test.java:6)
null 的作用類似於 C 語言中的 NULL (空指針), 都是表示一個無效的內存位置。 因此不能對這個內存進行任何讀寫操作， 一旦嘗試讀寫, 就會拋出 NullPointerException.
註：Java 中並沒有約定 null 和 0 號地址的內存有任何關聯。即使是打印，打印的結果也為null。
4.JVM內存區域劃分
在一開始學Java時我們就知道JVM的全稱是Java虛擬機，它能夠運行Java編譯後的字節碼文件，實際上運行時它也要開辟棧幀、堆內分配內存等等，因此就有瞭JVM的內存佈局。
JVM內存佈局大概可以分為六個區域：程序計數器、JVM虛擬機棧、JVM本地方法棧、方法區、堆區及運行時常量池。它們之間的內存佈局：
- 程序計數器 (PC Register): 隻是一個很小的空間, 保存下一條執行的指令的地址
- 虛擬機棧(JVM Stack): 重點是存儲局部變量表(當然也有其他信息)，我們剛才創建的 int[] arr 這樣的存儲地址的引用就是在這裡保存。
- 本地方法棧(Native Method Stack): 本地方法棧與虛擬機棧的作用類似，隻不過保存的內容是Native方法的局部變量，native方法的運行速度是非常快的，在有些版本的 JVM 實現中(例如HotSpot), 本地方法棧和虛擬機棧是一起的。
- 堆(Heap): JVM所管理的最大內存區域. 使用 new 創建的對象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )
- 方法區(Method Area): 用於存儲已被虛擬機加載的類信息、常量、靜態變量、即時編譯器編譯後的代碼等數據，方法編譯出的的字節碼就是保存在這個區域。
- 運行時常量池(Runtime Constant Pool): 是方法區的一部分, 存放字面量(字符串常量)與符號引用(註意 從 JDK1.7 開始, 運行時常量池在堆上)
Native 方法:
JVM 是一個基於 C++ 實現的程序. 在 Java 程序執行過程中, 本質上也需要調用 C++ 提供的一些函數進行和操作系統底層進行一些交互. 因此在 Java 開發中也會調用到一些 C++ 實現的函數。
這裡的 Native 方法就是指這些 C++ 實現的, 再由 Java 來調用的函數。
此處對JVM的內存佈局隻做瞭解，重點掌握JVM虛擬機棧中存的是什麼，而堆上存的額又是什麼即可。
局部變量和引用保存在棧上, new 出的對象保存在堆上.
堆的空間非常大, 棧的空間比較小.
堆是整個 JVM 共享一個, 而棧每個線程具有一份(一個 Java 程序中可能存在多個棧).
5.數組作為方法的返回值
代碼示例: 寫一個方法, 將數組中的每個元素都 * 2
// 直接修改原數組
class Test {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
transform(arr);
printArray(arr);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void transform(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] * 2;
}
}
}
這個代碼固然可行, 但是破壞瞭原有數組. 有時候我們不希望破壞原數組, 就需要在方法內部創建一個新的數組, 並由方法返回出來。在Java中方法可以返回一個數組。
// 返回一個新的數組 class Test {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
int[] output = transform(arr);
printArray(output);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static int[] transform(int[] arr) {
int[] ret = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i] * 2;
}
return ret;
}
}
這樣的話就不會破壞原有數組瞭。
另外由於數組是引用類型, 返回的時候隻是將這個數組的首地址返回給函數調用者, 沒有拷貝數組內容, 從而比較高效。
6.關於數組的地址
在Java中，為瞭維護數據的安全，我們是拿不瞭數組的地址的（已經被特殊處理過）。若想打印數組的地址，我們會發現結果如下：
為什麼打印結果會如此呢？
我們進入println的源代碼中可以看到println中有一個方法是專門對地址進行特殊處理：
它是根據哈希來對數組地址進行處理的，雖然如此，但是數組的地址仍然是隻有唯一的一個。
四、數組練習
1.數組轉字符串
代碼示例：
import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
// 執行結果
[1, 2, 3, 4, 5, 6]
使用這個方法後續打印數組就更方便一些。
Java 中提供瞭 java.util.Arrays 包, 其中包含瞭一些操作數組的常用方法。
2.數組拷貝
代碼示例：
import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
int[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr)); System.out.println("newArr: " + Arrays.toString(newArr));
// 拷貝某個范圍.
int[] newArr = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));
註意事項: 相比於 newArr = arr 這樣的賦值, copyOf 是將數組進行瞭 深拷貝, 即又創建瞭一個數組對象, 拷貝原有數組中的所有元素到新數組中. 因此, 修改原數組, 不會影響到新數組。而淺拷貝則是拷貝時原數組。
其實拷貝數組的方法有4種。
1.for循環進行一個接一個地拷貝
2.Arrays.copyOf ，調用Arrays包中的類來實現
3.System.arraycopy ，能夠設置從什麼位置處開始拷貝到什麼位置結束(拷貝的速度最快)
4.數組名.clone()
雖然這四種拷貝數組的方法都是有瞭深拷貝具備的特點（拷貝到新數組中，改變新數組內的數據，原數組不會改變）。但是它們處理的都是簡單類型，面試時都回答它們是淺拷貝即可。
代碼示例：
for循環拷貝：
int[] arr={1,2,3,4};
int[] a=new int[4];
for(int i=0;i<arr.length;i++) {
a[i]=arr[i];
}
for (int x:a) {
System.out.println(x);
}
System.arraycopy拷貝：
int[] arr={1,2,3,4};
int[] a=new int[arr.length];
System.arraycopy(arr,0,a,0,arr.length);
System.out.println(Arrays.toString(a));
數組名.clone拷貝：
int[] arr={1,2,3,4};
int[] a=new int[arr.length];
a=arr.clone();
System.out.println(Arrays.toString(a));
五、二維數組
1.二維數組的語法
二維數組本質上也就是一維數組, 隻不過每個元素又是一個一維數組。
基本語法：
數據類型[][] 數組名稱 = new 數據類型 [行數][列數] { 初始化數據 };
代碼示例：
int[][] arr = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };
for (int row = 0; row < arr.length; row++) {
for (int col = 0; col < arr[row].length; col++) {
System.out.printf("%d\t", arr[row][col]);
}
System.out.println("");
}
// 執行結果
1 2 3
4 5 6
7 8 9
10 11 12
註意：Java中二維數組隻能省略列，不能省略行，否則編譯器會報錯。
二維數組可以自定義，那麼如何自定義呢？
代碼示例：
int[][] arr=new int[2][];
arr[0]=new int[]{1,2,3};
arr[1]=new int[]{4,5};
for (int[] a:arr) {
for (int x:a) {
System.out.print(x+" ");
}
System.out.println();
}
運行結果：
2.二維數組的結構
此處我們針對數組int[2][3]進行結構分析，同樣，在創建新的二維數組的對象時它們存儲在堆區，而數組名（變量）是引用，存放在棧區。
註意：在Java中要取到二維數組的行號，它實際上也是一個一維數組，因此上面的打印二維數組的代碼中取行號的方式是arr.length，正是行號是一個一維數組，因此要取二維數組的每一列的方式是arr[row].length。
3.用for-each遍歷二維數組
若要用foreach遍歷二維數組：
代碼示例：
int[][] arr={{1,2,3},{2,3,4}};
for (int[] tmp:arr) {
for (int x:tmp) {
System.out.print(x+" ");
}
System.out.println();
}
總結
本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！
推薦閱讀：
- Java中數組的使用與註意事項詳解（推薦）
- Java常問面試內容–數組、聲明、初始化、冒泡、多維數組、稀疏數組
- 數組在java中的擴容的實例方法
- Java打印數組的三種方法整理
- 帶你粗略瞭解Java數組的使用