• 學習來源遇見狂神說

定義

public class arrays {
    public static void main(String[] args) {
        int array[]; //宣告一個數組
        array = new int[10]; //建立一個數組

        int[] array1 = new int[10]; //宣告並建立一個數組
    }
}

記憶體分析

• 堆

  • 存放new的物件和陣列
  • 可被所有的執行緒共享，不會存放別的物件引用

• 棧

  • 存放基本變數型別（會包含基本型別的具體數值）
  • 引用物件的變數（會存放這個引用在堆裡面的具地址）

• 方法區

  • 可以被所有的執行緒共享
  • 包含了所有的class和static變數
    

三種初始化

public class arrays {
    public static void main(String[] args) {
        //靜態初始化
        int[] a ={1,2,3,4,5};
        
        //動態初始化
        int[] b = new int[2];
        b[0] = 1;
        b[1] = 2;
        
        //預設初始化
        /*
        陣列是引用型別，他的元素相當於類的例項變數，以此陣列空間一經分配，
        其中的每個元素也按照例項變數同樣的方式被隱式初始化
        */
    }
}
 

基本特點

• 長度確定，建立後大小不能改變

• 元素型別必須相同

• 元素可是是任何型別，包括基本資料型別和引用型別

• 陣列變數屬於引用型別，陣列也可以看作是物件，每個元素相當於該物件的成員變數。

  陣列物件本身是在堆中的

for-Each迴圈

public class arrays {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        for (int array : arrays){
            System.out.println(array);
        }
    }
}`
 

多維陣列

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

Arrays類示例

• 檢視jdk幫助文件學習更多類與方法

import java.lang.reflect.Array;
import java.util.Arrays;
public class arrays {
    public static void main(String[] args) {
        int[] array = {1, 6, 43, 7};
        System.out.println(Arrays.toString(array));
        Arrays.sort(array);  //排序
        System.out.println(Arrays.toString(array));
    }
}

氣泡排序

import java.lang.reflect.Array;
import java.util.Arrays;
public class arrays {
    public static void main(String[] args) {
        int[] a = {2,6,4,27,1};
        int[] b = bubbleSort(a);
        System.out.println(Arrays.toString(b));
    }

    /*氣泡排序
    1.比較陣列中兩個相鄰元素，如果第一個比第二個大，交換位置
    2.每一輪比較，都會產生一個最大的數放在arrays[arrays.length-1-i] i為第i次比較，初始值為0
    3.下一輪可以少一次比較
    4.迴圈至結束
     */
     public static int[] bubbleSort(int[] arrays){
         int tem = 0;
         for (int i = 0; i < arrays.length-1; i++) {
             boolean flag = false;
             for (int j = 0; j < arrays.length-i-1; j++) {
                 if(arrays[j] > arrays[j+1]){
                     tem = arrays[j];
                     arrays[j] = arrays[j+1];
                     arrays[j+1] = tem;
                     flag = true;
                 }
             }
             if(!flag){    //如果第i輪沒有發生過交換，結束迴圈
                 break;
             }
         }
         return arrays;
    }
}

稀疏陣列

• 第一行：記錄陣列一共有幾行幾列，有多少個不等於0的值
• 把不等於0的元素的行列位置和值記錄在小規模陣列中，縮小程式的規模

public class arrays {
    public static void main(String[] args) {
        //建立原陣列
        int count = 0;
        int[][] array1 = new int[10][10];
        array1[2][3] = 9;
        array1[5][7] = 2;

        System.out.println("列印原陣列：");
        for (int[] array : array1) {
            for (int elem : array) {
                if (elem != 0) {
                    count++;
                }
                System.out.print(elem + " ");
            }
            System.out.println();

        }
        System.out.println("不為零的元素個數：" + count);

        //稀疏陣列
        int[][] array2 = new int[count + 1][3];
        array2[0][0] = 10;
        array2[0][1] = 10;
        array2[0][2] = count;
        int index = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    index++;
                    array2[index][0] = i;
                    array2[index][1] = j;
                    array2[index][2] = array1[i][j];
                }
            }
        }
        System.out.println("================="+"\n列印稀疏陣列");
        for (int[] array : array2) {
            for (int elem : array) {
                System.out.print(elem + "\t");
            }
            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("======================"+"\n稀疏陣列還原為陣列：");
        for (int[] array : array3) {
            for (int elem : array) {
                System.out.print(elem + " ");
            }
            System.out.println();
        }
    }
}