java入門(六)陣列(二)

5. 陣列的使用

6. 多維陣列（二維陣列）

7. Arrays類講解

8. 氣泡排序

9. 稀疏陣列

陣列的使用

public class ArrayDemo04 {
  public static void main(String[] args) {
    int[] arrays = {1,2,3,4,5};
    //jdk1.5,沒有下標
//     for (int array : arrays) {
//       System.out.println(array);
//     }
    int[] reverse = reverse(arrays);
    printArray(reverse);
   }
​
​
​
  //反轉陣列
  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;
   }
  //列印陣列元素
  public static void printArray(int[] arrays){
    for (int i = 0; i <arrays.length ; i++) {
      System.out.println(arrays[i]+"");
     }
   }
}
 

多維陣列

掌握理解，不要深究

多維陣列可以看成是陣列的陣列，比如二維陣列就是一個特殊的一維陣列，其每一個元素都是一個一維陣列。

二維陣列

int a[][] = new int [2][5];

解析：以上二維陣列a可以看成一個兩行五列的陣列。

多畫圖，才能多理解

public class ArrayDemo05 {
  public static void main(String[] args) {
    int[][] array = {{1,2},{2,3},{3,4},{4,5}};
​
    for (int i = 0; i <array.length ; i++) {
      for (int j = 0; j <array[i].length; j++) {
        System.out.println(array[i][j]);
       }
     }
   }
  //列印陣列元素
  public static void printArray(int[] arrays){
    for (int i = 0; i <arrays.length ; i++) {
      System.out.println(arrays[i]+"");
     }
   }
}
 

Arrays類講解

陣列的工具類java.util.Arrays

由於陣列物件本身並沒有什麼方法可以供我們呼叫，但API中提供了一個工具類Arrays供我們使用，從而可以對資料物件進行一些基本的操作

檢視JDK幫助文件

Arrays類中的方法都是static修飾的靜態方法，在使用的時候可以直接使用類名進行呼叫，而“不用”使用物件來呼叫（注意是不用而不是不能）

具有以下常用功能：

給陣列賦值：通過fill方法

對陣列排序：通過sort方法，按升序

比較陣列：通過equals方法比較陣列中元素值是否相等

查詢陣列元素：通過binarySearch方法能對排序好的陣列進行二分查詢法操作

public class ArrayDemo06 {
  public static void main(String[] args) {
    int[] a = {1,2,3,4,9090,5555,656};
    //System.out.println(a);//[I@74a14482
​
    //列印陣列元素Arrays.toString
    //System.out.println(Arrays.toString(a));
    //printArray(a);
    Arrays.sort(a);//陣列進行排序:升序
    System.out.println(Arrays.toString(a));
​
    Arrays.fill(a,0);//陣列填充
    System.out.println(Arrays.toString(a));
   }
​
  //不要重複造輪子
  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]+", ");
       }
​
     }
   }
}
​
 

氣泡排序

重要

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

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

當我們看到巢狀迴圈，應該立馬可以得出這個演算法的時間複雜度為O（n2）

public class ArrayDemo07 {
  public static void main(String[] args) {
    int[]a = {1,2,5,500,978,22};
    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標識位減少沒有意義的比較
​
      //內層迴圈，比價判斷兩個數，如果第一個數，比第二個數大，則交換位置
      for (int j = 0; j <array.length-1-i ; j++) {
        if (array[j+1]>array[j]){
          temp = array[j];
          array[j] = array[j+1];
          array[j+1] = temp;
          flag = true;
         }
       }
      if (flag==false){
        break;
       }
     }
    return array;
   }
}

這個案例我敲起來有難度，主要是邏輯問題，先放著，先去後邊

稀疏陣列

擴充套件內容，理解就好，不需要深究！

稀疏陣列是一種資料機構

稀疏陣列介紹：

當一個數組中大部分元素為0，或者為同一值的陣列時，可以使用稀疏陣列來儲存該陣列。

稀疏陣列的處理方式：

記錄陣列一共有幾行幾列，有多少個不同值

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

//稀疏陣列主要是思維
public class ArrayDemo08 {
  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 (int[] ints :array1  ) {
      for (int anInt : ints){
        System.out.print(anInt+"\t");
       }
      System.out.println();
     }
    //0太多，轉換為稀疏陣列儲存
    //獲取有效值的個數
    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個數："+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]+"\t");
     }
    System.out.println("=============");
    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();
     }
   }
}
​

稀疏陣列總結：

發散思維，一開始不理解正常，，不用深究。

本子複習筆記資料源自B站UP主：狂神說

點選此處跳轉B站視訊