Java 學(xué)習(xí)筆記（六）數(shù)組

數(shù)組

數(shù)組就是用來存儲同一個類型中若干數(shù)據(jù)的容器

定義一個變量可以存儲一個數(shù)據(jù), 定義兩個變量可以存儲2個數(shù)據(jù), 如果需要存儲50個整數(shù), 或者存儲100個小數(shù), 或者存儲20個字符串, 這種情況就可以選擇使用數(shù)組

數(shù)組的定義

定義數(shù)組的語法：

數(shù)據(jù)類型 [] 數(shù)組名 = new 數(shù)據(jù)類型[長度];

int [] data = new int [6];
或者

數(shù)據(jù)類型數(shù)組名 [] = new 數(shù)據(jù)類型[長度];

double data2 [] = new double[5];

先定義數(shù)組隔崎，再給數(shù)組的元素賦值拾酝，稱為數(shù)組的動態(tài)初始化；也可以在定義數(shù)組的同時給數(shù)組的元素賦值噪猾，稱為靜態(tài)初始化

靜態(tài)初始化：

數(shù)據(jù)類型 [] 數(shù)組名 = new 數(shù)據(jù)類型 []{元素}

int [] data3 = new int [] {1,2,3};
或者

int [] data4 = {4,5,6};

image

數(shù)組元素的訪問

定義了數(shù)組之后 ,系統(tǒng)會給每個元素指定一個索引值(下標), 通過索引值來訪問數(shù)組元素. 訪問格式為: 數(shù)組名[索引值]. 注意數(shù)組元素的索引值是從0開始的

比如 int [] data = new int [6]; 定義了存儲6個整數(shù)的數(shù)組 data

可以通過索引值向 data 中存儲6個整數(shù)

data[0] = 1;
data[1] = 2;
data[2] = 3;
data[3] = 4;
data[4] = 5;
data[5] = 6;

image

每個數(shù)組都有一個length屬性侠仇，它會返回數(shù)組的長度轻姿，可以使用它來遍歷數(shù)組的每個元素，來訪問每個元素的值

for(int i = 0; i < data.length; i++){
      System.out.println(data[i]);
}

數(shù)組做為方法的參數(shù)和返回值

數(shù)組屬于引用類型逻炊，相同類型的數(shù)組可以相互賦值

/**
 * 數(shù)組是引用類型踢代，相同類型的數(shù)組可以相互賦值
 */
public class Example01 {
    public static void main(String[] args) {
        // 定義數(shù)組，在棧區(qū)分配空間嗅骄，存儲變量名 data1胳挎，在堆區(qū)分配空間，存儲值：0 0 0 0 0 溺森，變量名存儲堆區(qū)的引用
        int [] data1 = new int[5];
        // 定義數(shù)組慕爬，在棧區(qū)分配空間，存儲變量名 data2屏积，在堆區(qū)分配空間医窿，存儲值：3 1 2 6 9 ，變量名存儲堆區(qū)的引用
        int [] data2 = {3,1,2,6,9};

        // data2 賦值給 data1炊林，data1 指向堆區(qū)data2的地址
        data1 = data2;
        // 輸出 data1 中的元素姥卢，輸出結(jié)果：3 1 2 6 9
        for (int i = 0; i < data1.length; i++) {
            System.out.print( data1[i] + " ");
        }
    }
}

數(shù)組可以做為方法的參數(shù)

/**
 * 數(shù)組可以做為方法參數(shù)
 */

public class Example02 {
    public static void main(String[] args) {
        int [] data = {11, 55, 33, 88, 66};
        printArray(data);

        int [] data2 = {6, 6, 6, 6, 6};
        printArray(data2);
     }

    // 定義方法，通過參數(shù)接收一個數(shù)組
    public static void printArray(int[] array) {
        // 遍歷數(shù)組中的元素
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }
    }
}

數(shù)組可以做為方法的返回值

/**
 * 數(shù)組可以做為方法的返回值
 */

public class Example03 {
    public static void main(String[] args) {
        // 調(diào)用方法，接收返回的數(shù)組
        int [] data = getArray(10);
        // 遍歷數(shù)組独榴，輸出數(shù)組中的元素
        for(int x : data){
            System.out.print(x + " ");
        }
        System.out.println();
        
        // 再次調(diào)用方法僧叉，給數(shù)組重新賦值
        data = getArray(5);
        // 調(diào)用Test02中的方法輸出數(shù)組中的元素
        Test02.printArray(data);
    }

    // 定義方法返回一個int類型的數(shù)組
    public static int [] getArray(int capacity){
        // 傳入的參數(shù)指定數(shù)組的長度
        int [] array = new int[capacity];
        // 給數(shù)組的各個元素賦值一個隨機數(shù)
        for(int i = 0; i < array.length; i++) {
            int num = (int)(Math.random() * 100);
            array[i] = num;
        }
        return array;
    }
}

可變長參數(shù)

作用：用來接收任意個數(shù)據(jù)

定義格式：

方法名（[類型參數(shù)名,] 類型 ... 可變長參數(shù)名）{}

注意：

一個方法最多只能有一個可變長參數(shù)
可變長參數(shù)只能在參數(shù)列表的最后

/**
 * 可變長參數(shù)
 */

public class Example04 {
    public static void main(String[] args) {
        // 在調(diào)用方法是，可以傳遞任意個參數(shù)
        sum();
        sum(1);
        sum(1,2,3);
        sum(1,2,3,4,5,6);
        int [] array = {10, 20 ,30};
        sum(array);
    }

    // 定義方法棺榔，計算任意個整數(shù)的和瓶堕，需要通過參數(shù)來接收任意個整數(shù)，可以通過可變長參數(shù)來實現(xiàn)
    public static void sum (int ... data) {
        // 在方法中症歇，可以把可變長參數(shù)當作數(shù)組使用
        int sum = 0;
        for (int i = 0; i < data.length; i++) {
            sum += data[i];
        }
        System.out.println("這些整數(shù)的和為： " + sum);
    }
}

數(shù)組擴容

定義數(shù)組時需要指定數(shù)組長度郎笆，即數(shù)組中能夠存儲數(shù)據(jù)的個數(shù)就已經(jīng)確定了。當數(shù)組已滿忘晤，還想向數(shù)組中存儲更多數(shù)據(jù)時宛蚓，就需要對數(shù)組進行擴容

數(shù)據(jù)擴容就是定義一個更大的數(shù)組，把原來數(shù)組的內(nèi)容復(fù)制到新數(shù)組中设塔，讓原來的數(shù)組名指向新的數(shù)組

/**
 * 數(shù)組擴容
 */

public class Example05 {
    public static void main(String[] args) {
        int [] data = {1,2,3,4,5};
        // 對數(shù)組 data 進行擴容
        // 1. 定義更大的數(shù)組
        int [] another = new int[data.length * 2];
        // 2. 把原來數(shù)組中的元素復(fù)制到新的數(shù)組中
//        for (int i = 0; i < data.length; i++) {
//            another[i] = data[i];
//        }
        // arraycopy 方法可以方便的賦值數(shù)組
        System.arraycopy(data, 0, another, 0, data.length);
        // 3. 讓原來的數(shù)組指向新的數(shù)組
        data = another;
        // 4. 遍歷數(shù)組苍息，快捷鍵 iter
        for (int x : data) {
            System.out.print(x + " ");
        }
    }

}

image

數(shù)組特點

優(yōu)點：

采用順序存儲，可以通過索引值（下標）計算每個數(shù)組元素的地址壹置，訪問數(shù)速快

缺點：

向數(shù)組中插入元素，刪除元素時表谊，需要復(fù)制钞护，移動大量元素，效率低

應(yīng)用場景：

數(shù)組適用于訪問為主爆办，較少添加难咕，刪除元素的情況

image

/**
 * 數(shù)組插入元素
 */

public class Example06 {
    public static void main(String[] args) {
        int [] data = {34, 56, 12, 87, 49};
        data = insert(data, 2, 666);
        for (int x : data) {
            System.out.print(x + " ");
        }

    }
    // 定義方法，向array數(shù)組索引值為i的位置插入元素key
    public static int [] insert(int[] array, int i, int key) {
        // 定義新數(shù)組
        int [] another = new int[array.length + 1];
        // 把 array 數(shù)組 [0,i)范圍內(nèi)的元素復(fù)制到新數(shù)組中
        System.arraycopy(array, 0, another, 0, i);
        // 把 key 元素保存的新數(shù)組的 i 位置
        another[i] = key;
        // 把 array 數(shù)組[i, array.length) 范圍內(nèi)的元素復(fù)制到新數(shù)組從 1+1 開始的位置
        System.arraycopy(array, i, another, i + 1, array.length - i);
        // 返回新數(shù)組
        return another;
    }
}

Arrays 工具類

/**
 * Arrays 工具類常用方法
 */

public class Example07 {
    public static void main(String[] args) {
        int [] data = {11,22,88,66,77,55};

        // 調(diào)用 Arrays.toString() 把數(shù)組中的元素轉(zhuǎn)換為字符串
        System.out.println(Arrays.toString(data));

        // Arrays.sort() 對數(shù)組元素排序
        Arrays.sort(data);
        System.out.println(Arrays.toString(data));

        // Arrays.copyOf(原數(shù)組距辆，新數(shù)組長度) 復(fù)制數(shù)組
        int [] another = Arrays.copyOf(data, data.length * 2);
        System.out.println(Arrays.toString(another));
        int [] tmp = Arrays.copyOf(data, data.length / 2);
        System.out.println(Arrays.toString(tmp));
    }
}

二維數(shù)組

/**
 * 二維數(shù)組
 */

public class Example08 {
    public static void main(String[] args) {
        // 定義數(shù)組
        int [] data1 = new int[10];
        int [] data2 = {1,2,3,4,5,6};
        // 也可以這樣
        int x = 10;
        int y = 20;
        int [] data3 = {x, y};
        // 定義二維數(shù)組
        int [][] data4 = {data1, data2, data3};

        // 打印二維數(shù)組的長度余佃，輸出結(jié)果：3
        System.out.println(data4.length);

        // 遍歷二維數(shù)組
        for (int i = 0; i < data4.length; i++) {
            for (int j = 0; j < data4[i].length; j++) {
                System.out.print(data4[i][j]);
            }
            System.out.println();
        }

        // 定義二維數(shù)組時，指定二維數(shù)組的長度
        int [][] data5 = new int [5][];
        // 定義二維數(shù)組是跨算，指定每個一維數(shù)組的長度
        int [][] data6 = new int [5][7];

        // 使用 foreach 遍歷二維數(shù)組
        for (int[] ints : data4) {
            for (int xx : ints) {
                System.out.println(xx + " ");
            }
            System.out.println();
        }

        // 二維數(shù)組的靜態(tài)初始化
        int [][] data7 = new int[][]{data1, data2, data3};
        int [][] data8 = {data1, data2, data3};
        int [][] data9 = {new int[5], new int[]{1,2,3}, {4,5,6}};

        // Arrays.deepTosString() 可以把二維數(shù)組的元素轉(zhuǎn)換為字符串
        System.out.println(Arrays.deepToString(data9));
    }
}