前言

一維陣列

創建一維陣列

一維陣列的使用

陣列作引數

認識 JVM 記憶體區域劃分

陣列做引數基本用法

理解參考型別

認識 null

陣列作為方法的回傳值

二維陣列

二維陣列的長度

二維陣列的遍歷

陣列練習

前言

本章主要講解：

一維陣列的定義和使用
陣列在記憶體的基本存盤知識
二維陣列的定義和使用
陣列練習

一維陣列

什么是陣列：

陣列本質上就是讓我們能 "批量" 創建相同型別的變數（相同的型別）

注：特別是表示大量的資料，用陣列非常便捷

創建一維陣列

基本語法：

// 動態初始化
資料型別[] 陣列名稱 = new 資料型別 [] { 初始化資料 };
// 靜態初始化
資料型別[] 陣列名稱 = { 初始化資料 };

示例：

int[] arr = new int[]{1, 2, 3};
int[] arr = new int[3];	// 默認元素為0
int[] arr = {1, 2, 3};

注：靜態初始化的時候, 陣列元素個數和初始化資料的格式要一致

一維陣列的使用

示例：

int[] arr = {1, 2, 3};
// 獲取陣列長度（本身屬性）
System.out.println("length: " + arr.length); // 執行結果: 3
// 訪問陣列中的元素
System.out.println(arr[1]); // 執行結果: 2
System.out.println(arr[0]); // 執行結果: 1
arr[2] = 100;
System.out.println(arr[2]); // 執行結果: 100

注意：

使用arr.length能夠獲取到陣列的長度：. 這個操作為成員訪問運算子（進行修改和讀取）
使用[ ]按下標取陣列元素, 下標從0開始計數（[]寫在變數名前后都行）
下標訪問操作不能超出有效范圍 [0, length - 1] ，否則會出現下標越界
陣列型別中 [] 內不能寫數值

示例：遍歷陣列

//回圈遍歷
int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}
//用 for-each 遍歷
int[] arr = {1, 2, 3};
for (int x : arr) {
    System.out.println(x);
}
//使用 Arrays 類中的 toString 方法(toString的功能就是將當前的陣列轉換成字串的形式回傳)
// 使用 Arrays 類前先匯入它的包
import java.util.Arrays;
public class TestDemo{
    public static void main(Strings[] args){
        int[] array = {1, 2, 3};
        String ret = Arrays.toString(array);
        System.out.println(ret);
    }
}
// 輸出結果：[1, 2, 3]

陣列作引數

認識 JVM 記憶體區域劃分

一個 Java 檔案的執行需要先通過編譯變成位元組碼檔案，位元組碼檔案再通過 Java 虛擬機運行

JVM 記憶體劃分：

各區域作用：

程式計數器：是一個很小的空間，保存下一條執行的指令地址
Java 虛擬機堆疊：這就是我們平常說的堆疊，它重點是存盤區域變數（如創建的陣列的存盤地址的參考就存在這里）
本地方法堆疊：本地方法堆疊與虛擬機堆疊的作用類似，只不過保存的內容是 Native 方法（ Java 中呼叫的一些 C++ 實作的函式）的區域變數
堆：這就是我們平常說的堆，是 JVM 所管理的最大的記憶體區，使用 new 創建的物件都是在堆上保存
方法區：用于存盤已被虛擬機加載的類資訊、常量、靜態變數、即時編譯器編譯后的代碼等資料（方法編譯出的位元組碼就是保存在這里）
運行時常量池：這個是方法區的一部分用來存放字面量（字串常量）與符號參考（注意：從 JDK 1.8 開始，運行時常量池在堆上）

陣列做引數基本用法

結論：陣列為參考型別，陣列做引數傳遞的是地址

示例：列印陣列內容

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    printArray(arr);
}
public static void printArray(int[] a) {
    for (int x : a) {
        System.out.println(x);
    }
}
//int[] a 是函式的形參, int[] arr 是函式實參

理解參考型別

示例：引數傳內置型別

public static void main(String[] args) {
    int num = 0;
    func(num);
    System.out.println("num = " + num);
}
public static void func(int x) {
    x = 10;
    System.out.println("x = " + x);
}
// 執行結果
x = 10
num = 0

注：修改形參 x 的值, 不影響實參的 num 值（形參是實參的一份臨時拷貝：開辟另一個空間來存實參的內容，修改形參與實參無關）

示例：引數傳陣列型別

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    func(arr);
    System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
    a[0] = 10;
    System.out.println("a[0] = " + a[0]);
}
// 執行結果
a[0] = 10
arr[0] = 10

注：此時陣列名 arr 是一個 "參考" ：當傳參的時候, 是按照參考傳參（找到對應元素空間，直接對元素內容）

簡單類比：參考相當于一個 "別名", 也可以理解成一個指標

創建一個參考只是相當于創建變數來保存一個整數, 這個整數表示記憶體中的一個地址

圖解：對于上述例題

而修改 a[0]是根據 0x100 這樣的地址找到對應的記憶體位置, 將內容改成 100

注：傳地址可以避免對整個陣列的拷貝(特別是長陣列, 拷貝開銷會很大）

認識 null

null 在 Java 中表示 "空參考" , 也就是一個無效的參考(不能進行訪問)

作用類似C語言中NULL (空指標), 都是表示一個無效的記憶體位置，但Java并沒有約定 null 和 0 號地址的記憶體有任何關聯

示例：

int[] arr = null;
System.out.println(arr[0]);//err

陣列作為方法的回傳值

示例：寫一個方法, 將陣列中的每個元素都 * 2

// 直接修改原陣列
class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        transform(arr);
        printArray(arr);
    }
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void transform(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] = arr[i] * 2;
        }
    }
}
//破壞原有陣列

// 回傳一個新的陣列
class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] output = transform(arr);
        printArray(output);
    }
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static int[] transform(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i] * 2;
        }
    return ret;
    }
}
//回傳的時候只是將這個陣列的首地址回傳給函式呼叫者, 沒有拷貝陣列內容, 從而比較高效

二維陣列

二維陣列本質上也就是一維陣列, 只不過每個元素又是一個一維陣列

基本語法：

資料型別[][] 陣列名稱 = new 資料型別 [行數][列數] { 初始化資料 };

示例：

int[][] arr = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};
for (int row = 0; row < arr.length; row++) {
    for (int col = 0; col < arr[row].length; col++) {
        System.out.printf("%d\t", arr[row][col]);
    }
    System.out.println("");
}
// 執行結果
1 2 3 4
5 6 7 8
9 10 11 12

注意：在 Java 當中的二維陣列不能省略行，但可以省略列

示例：

int[][] array = new int[2][];

注意：但需要正常列印前，需要初始化，不然二維陣列元素都為 null

//不規則二維陣列(列是不確定)
int[][] array = new int[2][];
array[0] = new int[4];
array[1] = new int[2];
System.out.println(Arrays.deepToString(array));
//列印結果為：[[0, 0, 0, 0], [0, 0]]

二維陣列的長度

示例：

int[][] array = {{1, 2, 3}, {4, 5, 6}};
System.out.println(array.length);//array為整個二維陣列
//輸出結果：2（兩個元素）
System.out.println(array[0].length);//array[0]為二維陣列第一個元素，即一維陣列
System.out.println(array[1].length);
// 輸出結果：3 3

注：對于不規則二維陣列求長度同樣適用

二維陣列的遍歷

//使用 for 回圈遍歷列印
int[][] array = {{1, 2, 3}, {4, 5, 6}};
for(int i = 0; i < array.length; i++){
    for(int j = 0; j < array[0].length; j++){
        System.out.println(arrat[i][j] + " ");
    }
}
//使用 for-each 遍歷列印
int[][] array = {{1, 2, 3}, {4, 5, 6}};
for(int[] arr : array){//二維陣列的元素為一維陣列，即int[] arr
    for(int x : arr){//一維陣列的元素為int元素，即int x
        System.out.println(x);
    }
}
//使用 Arrays.deepToString 列印
int[][] array = {{1, 2, 3}, {4, 5, 6}};
System.out.println(Arrays.deepToString(array));

陣列練習

例題1：陣列轉字串（模擬實作 toString ）

示例：

public static String myToString(int[] array){
    String str = "[";
    for(int i = 0; i < array.length; i++){
        if(i == 0){
            str +=array[i];
        }else{
            str +=", " + array[i];
        }
    }
    str += "]";
    return str;
}
//如果還想完善的話，注意陣列長度為0或者陣列為 null 的情況

例題2：陣列拷貝

示例1：

// for 回圈拷貝
public static int[] copyArray(int[] array){
    int[] newArray = new int[array.length];
    for(int i = 0; i < array.length; i++){
        newArray[i] = array[i];
    }
    return newArray;
}

示例2：

//使用 Array 包的工具類
//copyOf(原陣列，要回傳的副本的長度)方法
int[] array = {1, 2, 3};
int[] ret1 = Arrays.copyOf(array ,array.length);
System.out.println(Arrays.toString(ret1));
//copyOfRange(原陣列，起始索引值，終點索引值的后一個值)方法
//這里的起點和終點(下標)范圍是一個左閉右開區間，如下示例范圍為：[1,3) （java中大部分都是如此）
int[] ret2 = Arrays.copyOfRange(array ,1, 3);
System.out.println(Arrays.toString(ret2));
// 輸出結果：[2, 3]

示例3：

//本地方法（native） arraycopy(原陣列（src）,原陣列的起始位置（srcPos）,目的陣列（dest）,目的陣列（dest）的起始位置（destPos）)
int[] array = {1, 2, 3};
int[] ret3 = new int[array.length];// length 不能超過原陣列的長度,否則越界
System.arraycopy(array, 0, ret5, 0, array.length);
System.out.println(Arrays.toString(ret3));
// 輸出結果：[1, 2, 3]

示例4：

//呼叫物件的 clone() 方法
int[] array = {1, 2, 3};
int[] ret4 = array.clone();
System.out.println(Arrays.toString(ret4));
// 輸出結果：[1, 2, 3]

對于拷貝有深淺之分：

深拷貝：拷貝陣列的資料（基本資料型別），修改拷貝陣列不改變原陣列資料

淺拷貝：拷貝陣列的地址（參考型別），修改拷貝陣列改變原陣列資料

例題3：找陣列中的最大元素

示例：

public static void main(String[] args){
    int[] array = {1,4,5,9,2};
    System.out.println(maxNum(array));
}
public static int maxNum(int[] array){
    int max = array[0];
    for(int i = 1; i < array.length; i++){
        if(array[i] > max){
            max = array[i];
        }
    }
    return max;
}

例題4：查找陣列中指定元素（順序查找）

示例：

public static int findNum(int[] array, int x){
    for(int i = 0; i < array.length; i++){
        if(array[i] == x){
            return i;
        }
    }
    return -1;
}

例題5：檢查陣列的有序性（升序陣列）

示例：

public static boolean isSorted(int[] array){
    for(int i = 0; i < array.length - 1; i++){
        if(array[i] > array[i+1]){
            return false;
        }
    }
    return true;
}

例題6：陣列排序（冒泡排序）

示例：

public static void dubbleSort(int[] array){
    for(int i = 0; i < array.length - 1; i++){
        boolean flg = false;
        for(int j = 0; j < array.length - i - 1; j++){
            if(array[j] > array[j + 1]){
                int tmp = array[j];
                array[j] = array[ j + 1];
                array[j  + 1] = tmp;
                flg = true;
            }
        }
        if(flg == true){
            break;
        }
    }
}

例題7：陣列數字排序（偶數放在陣列前半部分，將所有的奇數放在后半部分）

示例：

public static void sort(int[] array){
    int left = 0;
    int right = array.length - 1;
    while(left < right){
        while(left < right && array[left] % 2 == 0){
            left++;
        }
        while(left < right && array[right] % 2 != 0){
            right--;
        }
        if(left < right){
            int tmp =array[left];
            array[left] = array[right];
            array[right] =tmp;   
        }
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/299177.html

標籤：java

上一篇：【Java實作鏈表操作】萬字肝爆！鏈表的圖文決議

下一篇：資料結構之Java實作兩個隨機陣列合并進行排序

【 JavaSE 】 深入陣列

前言

一維陣列

創建一維陣列

一維陣列的使用

陣列作引數

認識 JVM 記憶體區域劃分

陣列做引數基本用法

理解參考型別

認識 null

陣列作為方法的回傳值

二維陣列

二維陣列的長度

二維陣列的遍歷

陣列練習

【 JavaSE 】深入陣列