【0 基礎學 Java】（九）數組

碼字不易，對你有幫助 點贊/轉發/關注 支持一下作者

微信搜公衆號：不會編程的程序圓

看更多幹貨，獲取第一時間更新

看更多示例和代碼： https://github.com/hairrrrr/EasyJava，歡迎 star

思維導圖

上面的高清思維導圖獲取方式：請看原文的文末哦~

閱讀原文

正文

一數組的基本用法

1.1 什麼是數組

數組本質上就是讓我們能 “批量” 創建相同類型的變量。

例如:
如果需要表示兩個數據, 那麼直接創建兩個變量即可 int a; int b 。

如果需要表示五個數據, 那麼可以創建五個變量 int a1; int a2; int a3; int a4; int a5 。

但是如果需要表示一萬個數據, 那麼就不能創建一萬個變量了. 這時候就需要使用數組, 幫我們批量創建。

注意事項: 在 Java 中, 數組中包含的變量必須是 相同類型。

1.2 創建數組

基本語法

// 動態初始化
數據類型[] 數組名稱 = new 數據類型 [ ] { 初始化數據 };

// 靜態初始化
數據類型[] 數組名稱 = { 初始化數據 };

例如：

int[] arr1 = new int[3];//定義但不初始化
int [] arr2 = {1,2,3};//定義並初始化，數組大小爲 3
int[] arr3 = new int[]{1, 2, 3};//定義並初始化，數組大小爲 3。後面的[]內不能寫數字

沒有初始化的數組元素默認值爲 0

其實數組也可以寫成:

int arr[] = {1, 2, 3}；

這樣就和 C 語言更相似了. 但是我們還是更推薦寫成 int[] arr 的形式. int和 [] 是一個整體

1.3 數組的使用

1）獲取長度 & 成員訪問

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

注意

使用 arr.length 能夠獲取到數組的長度. . 這個操作爲成員訪問操作符. 後面在面向對象中會經常用到.
使用 [ ] 按下標取數組元素. 需要注意, 下標從 0 開始計數
使用 [ ] 操作既能讀取數據, 也能修改數據.
下標訪問操作不能超出有效範圍 [0, length - 1] , 如果超出有效範圍, 會出現下標越界異常

2）下標越界

int[] arr = {1, 2, 3};
System.out.println(arr[100]);
// 執行結果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at Test.main(Test.java:4)

3）遍歷數組

所謂 “遍歷” 是指將數組中的所有元素都訪問一遍, 不重不漏. 通常需要搭配循環語句。

for 循環遍歷

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

使用 Arrays 類的方法

int[] arr = {1, 2, 3};
System.out.println(Arrays.toString(arr));//將 數組 轉化爲 字符串

將數據內容以字符串的形式輸出

在 Java 中提供了一個工具類，這個工具可以幫助我們操作數組。

int[] arr = new int[]{1,2,3};
System.out.println(Arrays.toString(arr));
//輸出：
//[1, 2, 3]

二數組作爲方法的參數

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

注意

int[] a 是函數的形參, int[] arr 是函數實參
如果需要獲取到數組長度, 同樣可以使用 a.length

2.2 引用類型

普通變量作爲方法參數與數組作爲方法參數的不同

普通變量作爲方法參數：

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

我們發現, 修改形參 x 的值, 不影響實參的 num 值

數組作爲參數：

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 是一個 “引用” ，當傳參的時候, 是按照引用傳參。

總結

所謂的 “引用” 本質上只是存了一個地址. Java 將數組設定成引用類型, 這樣的話後續進行數組參數傳參, 其實只是將數組的地址傳入到函數形參中. 這樣可以避免對整個數組的拷貝(數組可能比較長, 那麼拷貝開銷就會很大) 。

2. 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)

2.4 JVM 內存區域劃分

Java 跨平臺一個很重要的原因就是最終 Java 的程序都是在 JVM 上運行的。

注意：

從 JDK1.7 開始，運行時常量池移入堆中。
每一個線程（Thread）中都有一個虛擬機棧，程序計數器，本地方法棧，而堆和方法區是共享的。

2.5 淺拷貝與深拷貝

int[] arr1 = new int[3]{1, 2, 3};
int[] arr2 = arr1;
int[] arr3 = Arrays.copyOf(arr1);
arr1[0] = 0;
System.out.println(arr2[0]);
System.out.println(arr3[0]);

//輸出：
0
1

Arrays.copyOf() 是包含在 Arrays 類中的方法，使用需要導入包java.util.Arrays，作用是拷貝數組 arr1 到 arr3 中（這句話其實很耐人尋味）。

我們發現：改變 arr1 中元素的值，arr2 中的元素也被改變了，但是 arr3 的元素並沒有被改變，這是爲什麼呢？

int[] arr2 = arr1這樣讓兩個引用指向同一塊內存的拷貝稱爲 淺拷貝

int[] arr3 = Arrays.copyOf(arr1) 這樣讓兩個引用指向的是不同內存的拷貝稱爲 深拷貝

三數組作爲方法的返回值

如果我想將數組每個元素都乘以 2，我們可以這麼做：

class Test1{
    public static void main(String[] args) {

        int[] arr = {3, 4, 2, 1};
        Double(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void Double(int[] arr) {

       for(int i = 0; i < arr.length; i++) {
           arr[i] *= 2;
       }
    }

}

但是，如果我們不想改變原有數組的內容，上面這種方式就不合適了。這時，我們可以在函數內創建一個新的數組，然後返回運算後的數組即可。

class Test1{
    
    public static void main(String[] args) {

        int[] arr = {3, 4, 2, 1};
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(Double(arr)));
    }
    public static int[] Double(int[] arr) {
        int[] ret = new int[arr.length];
       for(int i = 0; i < arr.length; i++) {
           ret[i] = arr[i] * 2;
       }
       return ret;
    }

}
//輸出：
[3, 4, 2, 1]
[6, 8, 4, 2]

四二維數組

二維數組本質上也就是一維數組, 只不過每個元素又是一個一維數組

5.1 二維數組的創建

 int[][] arr1 = {{1, 2}, {3, 4}, {5, 6}};
 int[][] arr2 = new int[][]{{1, 2, 3}, {4, 5, 6}};
 //不規則二維數組,可手動指定列數
 int[][] arr3 = new int[2][];
 arr3[0] = new int[]{1,2};
 arr3[1] = new int[]{3, 4, 5, 6};
 System.out.println(Arrays.deepToString(arr3));

5.2 遍歷數組

for 循環

class Test1{
    public static void main(String[] args) {
        int[][] arr1 = {{1, 2}, {3, 4}, {5, 6}};
        for(int row = 0; row < arr1.length; row++){
            for(int col = 0; col < arr1[row].length; col++){
                System.out.print(arr1[row][col] + " ");
            }
            System.out.println();
        }
    }

}

for-each

class Test1{
    public static void main(String[] args) {
        int[][] arr1 = {{1, 2}, {3, 4}, {5, 6}};
        for(int[] row : arr1){
            for(int col : row){
                System.out.print(col + " ");
            }
            System.out.println();
        }
    }

}