陣列

陣列定義

• 陣列是一個相同型別的有序集合

• 每一個數據是陣列元素，可以通過下標來訪問它們

陣列宣告建立

//dataType[] arratRefVar  正常是這格式 
int[] numbers = new int[10];

這樣就是一個numbers陣列的建立了，這個陣列的長度為10，也就是裡面可以存放10個數組元素

三種初始化方式

• 靜態初始化

  //建立 + 賦值
  int[] a = {1, 2, 3, 43, 231}
  //也可以是類 
  //Class[] class = {new Class(1, 2), new Class(4, 2)};

• 動態初始化

  int[] b = new int[2];
  b[0] = 3;
  b[1] = 42;
 

動態初始化我們就要給他開闢一塊空間，然後要給它手動的去賦值

• 預設初始化

  這個是包含在動態初始化裡面的

  陣列是一個引用型別，一旦陣列分配了空間，它的每個元素也會按照例項變數型別相同方式被隱式初始化，比如int型別陣列，像上面一個new int[2]那麼b[0] b[1]就預設賦值0，如果是double陣列b，那就是0.0，其他型別就是null

陣列的特點

• 陣列一經建立，他的大小就不變了
• 陣列內所有元素都保持一致，int就是int 不允許又是int又是String混合
• 陣列元素可以是任何型別，可以是基本型別 也可以是引用型別
• 陣列本身就是一個引用型別，可以看成一個物件，每個陣列元素就相當與這個物件的成員變數，Java中物件是在堆裡的，所以陣列無論儲存原始型別，還是物件型別，陣列也是在堆裡的。

陣列的使用

• for-each迴圈

  int[] a = {1, 32, 223, 321, 1};
  for (i = 0; i < a.length; i++){
      System.out.print(a[i] + "\t");
  }

這個for-each迴圈就是遍歷陣列，然後可以訪問到陣列的每一個下標，然後給他打印出來

• 陣列做方法入參

  實際上就是增強for迴圈

  int[] arrays = {1, 32, 223, 321, 1};
  for (int array : arrays) {
      System.out.print(array);
  }
 

這個array就陣列arrays裡的陣列元素，這個增強for迴圈就是遍歷arrays陣列，然後列印每一個元素，這個方法適合列印輸出陣列。比較遺憾的是這個方法並不能訪問陣列的下標，有時候要通過訪問下標來進行一些操作的時候還是得靠for-each迴圈吶。

• 陣列當返回值

  public static void main(String[] args) {
  	int[] array = {1, 32, 223, 321, 1};
      printArray(array);
  }
  static void printArray(int[] arrays){
      for (i = 0; i < arrays.length; i++){
          System.out.print(arrays[i] + "\t");
      }
  }

這樣就是把array傳值給printArray方法，然後就打印出陣列array了

二維陣列

看成陣列的陣列，類比數學裡的集合的集合，很好理解

//把這個二維陣列當成陣列套陣列
//先定義 然後分配空間，便於理解可以看成一個2*3的矩陣
//然後他的下標就是00 01 02  10 11 12 還是有規律的
int[][] a = new int[2][3];
//現在陣列a的狀態就是 a = {{0，0，0}，{0，0，0}} 集合的集合 和數學裡的那個一模一樣

通過二維陣列也可以類推出三維，四維，或更高維的陣列，也會去使用了

畢竟下標是唯一的，弄清楚下標也就明白陣列的一些操作，當然實際上也用不到三四或者高維的陣列常用的多維陣列也是二維陣列，也很好理解

氣泡排序

經典排序

    public static void main(String[] args) {
//        經典氣泡排序
        int[] array = {1, 8, 62, 47, 2, 65, 4};
        for (int i = 0; i < array.length - 1; i++) {//這裡陣列長度為7 兩兩對比6個大迴圈就可													  //以迴圈完畢
            for (int j = 0; j < array.length - 1 - i; j++) {
                //i的每一次迴圈完畢，
                // 自然保證有一個最大的數在後面，需要對比的數字就少一個，這樣迴圈次數就會少i次
                int temp = 0;
                if (array[j+1] < array[j]){//如果前一個數比後一個數小，那麼就交換位置，這樣保											//證有一個最大的數字在後面
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        //這裡用到Arrays類的toString方法
        System.out.println(Arrays.toString(array));

    }

稀疏陣列

稀疏陣列就是一個壓縮陣列的一個方法

比如 0 0 2 0 0 這個陣列就是4*5的陣列 有效值兩個 座標(0, 2) (1, 1)
0 1 0 0 0 行 列 有效值
0 0 0 0 0 4 5 2
0 0 0 0 0 0 2 2
1 1 1

這樣就把一個4×5的陣列壓縮成一個 3×3的陣列了 稀疏陣列的第0行存放的是原陣列的行 列 有效值個數，從第1行開始存放的就是有效值的下標，第三列就是有效值的值，當然也可以通過稀疏陣列來還原原陣列。

​

public class SparseArray {
    //稀疏陣列
    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        array[2][1] = 1;


        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("=====================");
        //獲取有效值個數
        int sum = 0;
        for (int[] ints : array) {
            for (int anInt : ints) {
                if (anInt != 0){
                    sum ++;
                }
            }
        }
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = array.length;
        sparseArray[0][1] = array[0].length;
        sparseArray[0][2] = sum;
        int count = 0;//獲取稀疏陣列的行號
        //遍歷原陣列，獲取橫縱下標，值並賦給稀疏陣列
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                if (array[i][j] != 0){
                    count ++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = array[i][j];
                }
            }
        }
        //輸出稀疏陣列
        for (int i = 0; i < sparseArray.length; i++) {
            System.out.println(sparseArray[i][0] + "\t"
                    + sparseArray[i][1] + "\t"
                    + sparseArray[i][2] + "\t");
        }
        System.out.println("=====================");
        //還原稀疏陣列
        //從稀疏陣列第一行開始遍歷，i行第1列是橫座標，i行第2列是縱座標，i行第3列是存放的值
        int[][] array1 = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
                array1[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //列印陣列
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}