Day05-Java基礎階段_陣列

阿新 • • 發佈：2020-09-13

陣列的定義
陣列宣告建立
記憶體分析
三種初始化
陣列的四個基本特點
陣列邊界
陣列使用
多維陣列
Arrays類
氣泡排序
稀疏陣列

陣列的定義

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

陣列宣告建立

首先必須宣告陣列變數，才能在程式中使用陣列，下面是宣告陣列變數的語法

dataType[] arrayRefVar;   //首選的方法
dataType arrayRefVar[];   //效果相同，擔不是首選方法

Java語言使用new操作符來建立陣列，語法如下：
```
dataType[] arrayRefVar = new dataType[arraySize];
 
```
陣列的元素是通過索引訪問的，陣列索引從0開始
獲取陣列長度
```
arrays.length
```
toSrting方法可以直接遍歷陣列元素
- ```
System.out.println(Arrays.toString())
```

記憶體分析

Java記憶體分析：
寫程式碼畫圖分析記憶體！

三種初始化

靜態初始化

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;

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

陣列的四個基本特點

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

陣列邊界

下標的合法區間：[0.length -1 ]，如果越界就會報錯

public static void main(String[] args){
    int[] a = new int[2];
    System.out.println(a[2]);
}

ArrayIndexOutOfBoundsException：陣列下標越界異常
小結：
- 陣列是相同資料型別（資料型別可以為任意型別）的有序集合
- 陣列也是物件。陣列元素相當於物件的成員變數
- 陣列長度是確定的，不可變的，如果越界，則報錯：ArrayIndexOutOfBoundsException

陣列使用

For-each迴圈

public class Demo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        for(int x : arrays){
            System.out.println(x);
        }
    }
}

陣列作為方法入參

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        printArray(arrays);
    }



    public static void printArray(int[] arrays){
        for (int array : arrays) {
            System.out.println(array);
        }
    }
}

陣列作為返回值

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

多維陣列

多維陣列可以看成是陣列的陣列，比如二維陣列就是一個特殊的一維陣列，其每一個元素都是一個一維陣列
二位陣列
```
int a[][] = new int[2][3];
```
解析：以上二維陣列a可以看成一個兩行三列的陣列
思考？多維陣列的使用

Arrays類

陣列的工具類java.util.Arrays
由於陣列物件本身並沒有什麼方法可以供我們呼叫，但API中提供類一個工具類Arrays供我們使用，從而可以堆資料物件進行一些基本的操作
檢視JDK幫助文件
Arrays類中的方法都是static修飾的靜態方法，在使用的時候可以直接使用類名進行呼叫，而“不用”使用物件來呼叫（注意：是“不用”而不是“不能”）
具有以下常用功能
- 給陣列賦值：通過fill方法
- 對陣列排序：通過sort方法，按升序
- 比較陣列：通過equals 方法比較陣列中元素值是否相等
- 查詢陣列元素：通過binarySearch方法能對排序好的陣列進行二分查詢法操作

氣泡排序

氣泡排序無疑是最出名的排序演算法之一，總共有八大排序！

冒泡的程式碼還是相當簡單的，兩層迴圈，外層冒泡輪數，裡層依次比較

public class Demo07 {
    public static void main(String[] args) {
        int[] a ={1,41,523,62,3,52,643,31,236,100};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }


    //氣泡排序
    //1、比較陣列中，兩個相鄰的元素，如果第一個數比第二個數大，我們就交換它們的未知
    //2、每一次比較都會產生一個最大或者最小的數字
    //3、下一輪可以少一此排序！
    //4、一次迴圈，知道結束！

    public static int[] sort(int[] array){

        int temp = 0;
        for (int i = 0; i < array.length; i++) {
            //內層迴圈，比較判斷兩個數
            for (int j = 0; j < array.length-1; j++) {
                if(array[j+1]<array[j]){
                    temp = array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }
}

我們看到巢狀迴圈，應該立馬就可以得出這個演算法的時間複雜度為O(n2)
思考：如何優化？

稀疏陣列

需求:編寫五子棋遊戲中，有存檔退出和續上盤的功能
分析問題：因為該二位陣列的很多預設值是0，因此記錄類許多沒有意義的資料
解決：稀疏陣列
黨一個數組中大部分元素為0，或者為同一值的陣列時，可以使用稀疏陣列來儲存該陣列

稀疏陣列的處理方式是：

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

package com.yushaoyi.Array;

/**
 * @author ZhuYuchen
 * @create 2020-09-13-20:27
 * @site https://www.cnblogs.com/yushaoyi/
 */
public class Demo08 {
    public static void main(String[] args) {
        //建立一個二位陣列
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //輸出原始的陣列
        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);

        //建立一個稀疏陣列的陣列
        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];
                }
            }
        }
        //輸出稀疏陣列
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
        }
        

    }
}