四、陣列

1、陣列概述

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

2、陣列宣告建立

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

dataType[ ] arrayRefVar;l/首選的方法

或

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

Java語言使用new操作符來建立陣列，語法如下:

dataType[ ] arrayRefVar = new dataType[arraysize];
 

陣列的元素是通過索引訪問的，陣列索引從0開始。 獲取陣列長度:

arrays.length

int []nums;//1.宣告一個數組
nums=new int[10];//建立一個數組
System.out.println(num[8]);//取陣列中的值

陣列的四個基本特點 其長度是確定的。陣列一旦被建立，它的大小就是不可以改變的。 ​ 其元素必須是相同型別,不允許出現混合型別。 ​ 陣列中的元素可以是任何資料型別，包括基本型別和引用型別。 ​ 陣列變數屬引用型別，陣列也可以看成是物件，陣列中的每個元素相當於該物件的成員變數。陣列本身就是物件，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;

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

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

ArraylndexOutOfBoundsException :陣列下標越界異常! 小結: ​ 陣列是相同資料型別(資料型別可以為任意型別)的有序集合陣列也是物件。 ​ 陣列元素相當於物件的成員變數 ​ 陣列長度的確定的，不可變的。如果越界，則報:ArraylndexOutofBounds

3、陣列使用

For-Each迴圈

    int[] arrays={1,2,3,4,5};
    for (int array : arrays) {//沒有下標
      System.out.println(array);
     }

陣列作方法入參

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

陣列作返回值

    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;
   }

4、多維陣列

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

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

解析:以上二維陣列a可以看成一個兩行五列的陣列。 思考:多維陣列的使用?

num[1][0];

5、Arrays類

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

Arrays.sort(a);//陣列進行排序：升序
System.out.print(Arrays.toString(a));

氣泡排序：

氣泡排序無疑是最為出名的排序演算法之一，共有八大排序！ 冒泡的程式碼還是相當簡單的，兩層迴圈，外層冒泡輪數，裡層依次比較，江湖中人人盡皆知。

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

  public static void main(String[] args) {
    int[] a={1,5,2,34,85,3,58,3,2};
    int[] sort=sort(a);
    System.out.println(Arrays.toString(a));
   }
  //氣泡排序
  //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-i-1;j++){
        if(array[j+1]<array[j]){
          temp=array[j];
          array[j]=array[j+1];
          array[j+1]=temp;
         }
       }
       if (flag==false){
        break;
         }
     }
    return array;
   }

6、稀疏陣列

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

  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();
     }
    //轉換為稀疏陣列儲存
    //獲取有效值的個數
    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]+"\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:array1){
      for(int anInt:ints){
        System.out.print(anInt+"\t");
       }
      System.out.println();
     }
   }
}