06.陣列

1.陣列概述

陣列是相同型別資料的有序集合；
陣列描述的是相同型別的若干各資料，按照一定的先後次序排列組合而成；
其中，每一個資料稱作一個陣列元素，每個陣列元素可以透過一個下標來訪問它們。

2.陣列宣告建立

首先必須宣告陣列變數，才能在程式中使用陣列：

dataType[] arrayRefvar; // 首選方法
dataType arrayRefvar[]; // 效果相同

Java 語言使用 new 運算子來建立陣列，語法：

dataType[] arrayRefvar = new dataType[arraySize];
//例
int[] nums = new int[10]; // 建立一個可以儲存10個空間大小的int型別陣列
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;

System.out.println(nums[2]);

//計算所有元素和
int sum = 0;
for (int i = 0; i < nums.length; i++){
    sum += nums[i];
}
System.out.println(sum);

陣列的元素是透過索引訪問的，陣列索引從 0 開始。
獲取陣列長度：arrays.length

陣列的四個基本特點：

• 其長度是確定的。陣列一旦被建立，它的大小就是不可變的；
• 其元素必須是相同型別，不允許出現混合型別；
• 陣列中的元素可以是任何資料型別，包括基本型別和引用型別；
• 資料變數屬於引用型別，資料也可以看成是物件，陣列中的每個元素相當於該物件的成員變數；陣列本身就是物件，Java 中物件是在堆中的，因此陣列無論儲存原始型別還是其它物件型別，陣列物件本身是在堆中的。

Java 記憶體分析（簡單）：

• 堆：
  • 存放 new 的物件和陣列
  • 可以被所有的執行緒共享，不會存放別的物件引用
• 棧：
  • 存放基本變數型別（會包含這個基本型別的具體數值
  • 引用物件的變數（會存放這個引用在堆裡面的具體地址）
• 方法區：
  • 可以被所有的執行緒共享
  • 包含了所有的 class 和 static 變數

如果訪問陣列中元素的下標超過了陣列的空間，那麼會產生異常：java.lang.ArrayIndexOfBoundsException（表示陣列下標越界異常）

陣列三種初始化
靜態初始化：

int[] a = {1,2,3};
Man[] mans = {new Man(1,1), new Man(2,2)}; //引用型別的陣列

動態初始化：

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

陣列的預設初始化：陣列是引用型別，他的元素相當於類的例項，因此陣列一經分配空間，其中的每個元素也被按照例項變數同樣的方式被隱式初始化。

3.陣列使用

3.1.for-each 迴圈

        int[] arrays = {1, 2, 3, 4, 5};
        // 列印全部的陣列元素
        for (int array : arrays) {
            System.out.println(array); // 遍歷每個元素，無法取下標
        }

3.2.陣列作為方法入參

    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++){
            System.out.println(arrays[i] + " ");
        }
    }

3.3.陣列作為返回值

    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        // 反轉操作
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }
        return result;
    }

3.4.for 迴圈

4.多維陣列

可以看成是陣列的陣列。

    public static void main(String[] args) {
        int[][] nums = {{1,2},{2,3},{3,4},{4,5}};
        printArray(nums[0]); // 1 2
        System.out.println(nums[0][1]); // 2

        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                System.out.println(nums[i][j]);
            }
        }
    }
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++){
            System.out.println(arrays[i] + " ");
        }
    }

5.Arrays 類

陣列的工具類 java.util.Arrays
Arrays 類中的方法都是 static 修飾的靜態方法，在使用的時候可以直接使用類名進行呼叫，而 “不用” 使用物件來呼叫（並非不能）。
具有以下常用功能：

• 給陣列賦值：透過 fill 方法
• 對陣列排序：透過 sort 方法，升序
• 比較陣列：透過 equals 方法比較陣列中元素值是否相等
• 查詢陣列元素：透過 binarySearch 方法能對排序好的陣列進行二分查詢法操作

        int[] a = {12,234,5,2,34,534};
        System.out.println(Arrays.toString(a)); // 輸出所有元素
        Arrays.sort(a); // 排序
        System.out.println(Arrays.toString(a));

        Arrays.fill(a, 2, 4, 0); //將下標為 2（包含） 到下標為 4（不包含） 之間的元素填充為 0
        System.out.println(Arrays.toString(a));

6.氣泡排序

兩層迴圈，外層冒泡輪數，裡層依次比較（相鄰兩個元素比較，然後根據大小前移或後移）

    public static void main(String[] args) {
        int[] a = {12,234,5,2,34,534};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    /**
     * 氣泡排序
     * 1.比較陣列中，兩個相鄰元素，如果第一個數比第二個數大，就交換他們的位置
     * 2.每一次比較都會產生一個最大，或最小的數字
     * 3.下一輪則可以少一次排序
     * 4.依次迴圈，直到結束
     */
    public static int[] sort(int[] arrays){
        // 臨時變數
        int temp = 0;
        // 外層迴圈，判斷這個要走多少次
        for (int i = 0; i < arrays.length - 1; i++) {
            // 透過 flag 標識位減少沒有意義的比較
            boolean flag = false;
            // 內層迴圈，如果第一個數比第二個數大，則交換兩個數的位置
            for (int j = 0; j < arrays.length - 1 - i; j++) {
                if (arrays[j] > arrays[j+1]){
                    temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                    flag = true;
                }
                // 減少最後一輪的比較
                if (flag == true){
                    break;
                }
            }
        }
        return arrays;
    }

7.稀疏陣列

一種資料結構
需求：編寫五子棋遊戲中，有存檔退出和續上盤的功能

問題：因為該二維陣列的很多值是預設值（0），因此記錄了很多沒有意義的資料

當一個陣列中大部分元素為 0，或為同一值的陣列時，可以使用稀疏陣列來儲存該陣列。
處理方式：

• 記錄陣列一共有幾行幾列，有多少個不同值；
• 把具有不同值得元素和行列及值記錄在一個小規模的陣列中，從而縮小程式的規模。

如下圖：左邊是原始陣列，右邊是稀疏陣列

public class Demo1 {
    public static void main(String[] args) {
        // 1.建立一個二維陣列 11*11 0：沒有棋子，1：黑棋，2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;
        // 輸出原始的陣列
        System.out.println("輸出原始陣列：");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        // 轉換為稀疏陣列儲存
        // 獲取有效值個數
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值個數：" + sum);
        //2.建立一個稀疏陣列的陣列
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        // 遍歷二維陣列，將非零的值，存放在稀疏陣列中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //輸出稀疏陣列
        System.out.println("稀疏陣列");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" +array2[i][2]);
        }

        System.out.println("還原");
        //1.讀取稀疏陣列
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.給其中的元素還原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.列印
        System.out.println("輸出還原陣列：");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}