例子：一個足球隊有很多人，認識某個人的時候先是把他看作某某隊的隊員，然後再利用他們身上的編號去區分隊員

Java中是建議在型別後面加[]代表是陣列

int num[]:是C/C++語言風格的

畫圖工具：ProcessOn

陣列就是一個物件，因為它是new出來的

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

        //arrays.for   增強型for迴圈  JDK1.5以上支援  沒有下標  適合列印輸出
        //arrays代表一個數組，array代表陣列中的每一個元素
        for (int array : arrays) {
            System.out.println(array);
        }

    }
}
 

public class Demo3 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        
        int[] a = reverse(array);
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }


    }

    //反轉陣列
    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;   //Java中方法的返回值可以是陣列
    }
}

 

Java中方法的返回值可以是陣列

三維陣列：

int array[3][2][2] = {0,1,2,3,4,5,6,7};//相當於3個2 * 2 的二維陣列
printf("%d %d %d %d\n",&array[0],&array[0][0],&array[0][0][0],&array);
//如果說把三維陣列比作一個立方體的話，那麼這個立方體底邊是個2*2的正方形，高為3
//注意：三維陣列的高維度是寫在最前面的，也就是立方體的z

要研究一個類，如Arrays，在IDEA所寫程式碼中打出Arrays，檢視原始碼，左側點選Structure，可以看到類中所有方法

public class Demo4 {
    public static void main(String[] args) {
        int[] a={5,9,3,7,6};
        System.out.println(a);   //[I@1b6d3586

        //列印陣列元素Arrays.toString
        System.out.println(Arrays.toString(a));   //[5, 9, 3, 7, 6]

        //對陣列進行排序:升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));   //[3, 5, 6, 7, 9]
        
        //填充
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));   //[3, 5, 0, 0, 9]

        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));   //[0, 0, 0, 0, 0]
    }
}

//氣泡排序
//    1.比較陣列中2個相鄰的元素，若滿足比較條件，則交換它們的位置
//    2.每一次比較都會產生出一個最大或最小的數字
//    3.則下一輪可以少一次排序
//    4.依次迴圈，直到結束
public class Demo5 {
    public static void main(String[] args) {
        int[] a = {5,9,3,1,7,6,2,4,2};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(a));
    }




    public static int[] sort(int[] array){
        int temp = 0;

        //外層迴圈判斷要經過幾輪，一般為length-1   比較的輪數
        for (int i = 0; i <array.length-1 ; i++) {
        //比較2個數    數與數之間需要比較的次數
            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;
                }
            }
        }

        return array;
    }
}

public class Demo6 {
    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;

        //輸出原始的陣列    array1.for
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        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.建立一個稀疏陣列的陣列    有效值個數+1為行數，列固定為3列
        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.給其中的元素還原它的值
        //注意i從1開始，第0行存放的是頭部資訊
        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();
        }

    }
}