JAVA陣列基礎03

Arrays 類

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

public static void main(String[] args) {
    int[] a = {1,2,4,5,4134,434,1233,3,23};
    int[] b = {2,3,4,5,1,11231,};
    System.out.println(a);// [I@4554617c 記憶體地址
    //列印陣列元素 Array.toString
    System.out.println(Arrays.toString(a));
    printArray(a);

    Arrays.sort(a);//陣列進行排序
    System.out.println(Arrays.toString(a));
    Arrays.fill(a,1,5,0);//陣列填充
    System.out.println(Arrays.toString(a));
    System.out.println(Arrays.equals(a,b));//判斷2個數組是否相等
    System.out.println(Arrays.binarySearch(a,3));

}

public static void printArray(int[] a){
    for (int i = 0; i < a.length; i++) {
        if(i==0){
            System.out.print("[");
        }
        if(i==a.length-1){
            System.out.print(a[i]+"]");
        }else{
            System.out.print(a[i]+", ");
        }

    }
}
 

氣泡排序(重點)

• 2層迴圈，外層冒泡輪數，裡層依次比較
• 看到巢狀迴圈，應該立馬就可以得出這個演算法得時間複雜度為o（n2）
• 思考：如何優化

public static void main(String[] args) {
    int[] a = {2,5,12,4,23,45,22,8,6,25};

    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-1; i++) {

        boolean flag = false; //通過flag標識減少沒有意義的比較

        //內層迴圈,比較判斷2個數，如果第一個數比第二個數大，則交換位置
        //第一趟比較完成後，最後一個數一定是陣列中最大的一個數，所以第二趟比較的時候最後一個數不參與比較；
        //第二趟比較完成後，倒數第二個數也一定是陣列中第二大的數，所以第三趟比較的時候最後兩個數不參與比較；
        //依次類推，每一趟比較次數-i；
        for (int j = 0; j < array.length-1-i; j++) {
            if(array[j+1]>array[j]){//若是從小到大排序則交換j和j+1的位置即可
                temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
                flag = true;
            }
        }
        if(flag==false){
            break;
        }
    }
    return array;
    /*
    可能是最優化的版本
    int [] intarr = {4,12,45,48,79,46,9,6};
    for (int i = 0 ; i < intarr.length ; i++){//冒泡
        for (int o = i+1 ; o < intarr.length ; o++){
            if(intarr [i] > intarr[o]){
                intarr[i] ^= intarr[o];
                intarr[o] ^= intarr[i];
                intarr[i] ^= intarr[o];
            }
        }
    }
    System.out.println(Arrays.toString(intarr));
     */


}
 

稀疏陣列

• 需求：編寫五子棋遊戲，有存檔退出和續上盤的功能
• 分析問題：因為該二維陣列很多值是預設值0，因此記錄了很多沒有意義的資料
• 解決：稀疏陣列

• 當一個數組中大部分元素為0，或者為同一值的陣列時，可以使用稀疏陣列來儲存該陣列
• 稀疏陣列的處理方式是：
  • 記錄陣列一共有幾行幾列，有多少個不同值
  • 把具有不同值的元素和行列及值記錄在一個小規模的陣列中，從而縮小程式的規模

• [0] 6,7,8的意思是指這個原始陣列有6行，7列，共8個值
• [1]0,3,22的意思是第一個值的位置是第0行，第3列，值為22，其餘以此類推

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] = 2;
    //輸出原始陣列
    System.out.println("輸出原始陣列");
    ////取二維陣列的第一種方法 ，for迴圈
    //for (int i = 0; i < array1.length; i++) { //二維陣列的長度指的是最外層的陣列長度
    //for (int j = 0; j < array1[i].length; j++) {
    //System.out.println(array1[i][j]);
    ////取二維陣列的第二種方法,增強for迴圈
    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;
    
    //遍歷二維陣列，將非0的值，存放到稀疏陣列
    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("=================================");
    System.out.println("還原");
    //讀取稀疏陣列
    int[][] array3 = new int[array2[0][0]][array2[0][1]];

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