亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

ColorfulC · 更新于 2020-09-21

Java 數組

數組在編程語言中是非常重要的數據結構。本小節我們來一起學習 Java 數組，通過本小節的學習，你將了解到數組的基本概念，如何聲明數組以及數組的聲明有哪些方式，如何初始化數組以及數組初始化有哪些方式，數組的常用操作有哪些，多維數組的聲明、創建、初始化以及迭代等等。多維數組部分將以二維數組進行為例講解，理解了二維數組，再去理解多維數組就相對容易了。

1. 什么是數組

數組是相同類型的數據按照順序組成的一種引用數據類型。

Java 中有基本數據類型和引用數據類型兩種數據類型。數組就是引用數據類型。

2. 數組聲明

在Java語言中，數組聲明有兩種語法：

  • 中括號跟在數據類型后：DataType[] arrayName;

  • 中括號跟在數組名稱后：DataType arrayName[];

其中DataType是數組中要存放元素的數據類型，例如int、String等，arrayName是數組名稱，遵守變量的命名規范。

在實際的編碼中，我們更常用的是第一種語法。實例如下：

// 聲明一個int類型的數組，名稱為 firstIntArray:
int[] firstIntArray;  // 推薦寫法
int firstIntArray[];

也可以修改數據類型，以生成其他類型的數組。實例如下：

// 聲明一個float類型的數組：
float[] firstFloatArray;
// 聲明一個字符串類型的數組：
String[] firstStringArray;

3. 數組創建

3.1 先聲明再創建

先聲明再創建，需要編寫兩條語句：

DataType[] arrayName;
arrayName = new DataType[數組長度];

數組的創建使用new關鍵字，后面跟上一個空格+數據類型+中括號[]，中括號中間是數組的長度，這里是必須指定的，它是一個整型的數字。實例如下：

// 聲明一個整型的數組：
int[] intArray;
// 創建數組，長度為10
intArray = new int[10];

3.2 聲明時同時創建

聲明時同時創建，需要編寫一條語句：

DataType[] arrayName = new DataType[數組長度];

實例如下：

// 聲明時同時創建
int[] intArray = new int[10];

數組聲明用到的中括號，也可以放到數組名稱的后面，實例如下：

int intArray[] = new int[10];

所創建的數組數據類型必須與其聲明的數據類型相同。對于其他類型數組的創建，實例如下：

// 創建一個數據類型為字符串、長度為5的數組：
String[] stringArray = new String[5];

// 創建一個數據類型為雙精度浮點型、長度為10的數組：
double[] floatArray = new double[10];

// 創建一個數據類型為字符型、長度為10的數組：
char[] charArray;
charArray = new char[10];

4. 數組初始化

數組創建后，所有元素都初始化為默認值，整型數組的元素都為 0，浮點型都為 0. 0 ，布爾型都為 false。例如 int[] arr = new int[5];語句創建了一個數組，它在結構可參考下圖：

除了數組的默認初始化，還有另外兩種常見形式：

  1. 靜態初始化
  2. 動態初始化

下面我們將分別介紹兩種數組的初始化形式。

4.1 靜態初始化

靜態初始化數組，就是聲明的同時，給數組賦值。其語法為：

DataType[] arrayName = {元素1, 元素2, 元素3, 元素n};

賦值符號右邊為用中括號所包圍的 n 個元素，實例如下：

int[] arr = {1, 2, 3, 4, 5};

上面數組arr存放的元素為從 1 到 5 這幾個整型。其的長度為 5 。 數組的長度就是初始化時所給數組元素的個數。

4.2 動態初始化

動態初始化數組，即數組的聲明以及創建是與數組的賦值操作分開進行的。實例如下：

// 聲明并創建數組，長度為3
int[] arr = new int[3];
// 給下標位置0賦值為1
arr[0] = 1;
// 給下標位置1賦值為2
arr[1] = 2;
// 給下標位置2賦值為3
arr[2] = 3;

數組是有下標的，下標從0開始，因此長度為 3 的數組，最大下標為 2 。下圖展示了上述代碼的執行流程：

5. 數組的操作

5.1 數組元素的引用

語法：數組名[下標]，下標從0開始。有一個整型數組，引用其第一個元素，實例如下：

實例演示
預覽 復制
復制成功！
public class ArrayDemo {
    public static void main(String[] args) {
        // 初始化整型數組arr：
        int[] arr = {1, 2, 3};
        // 引用arr的第一個元素：
        int element1 = arr[0];
        System.out.println("數組arr中，第一個元素為：" + element1);
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果

運行結果：

數組arr中，第一個元素為：1

注意，上面的數組下標最大為 2，也就是說，引用元素時，不能超過其下標最大值。下面是一個反例：

public class OutOfIndexDemo {
  	public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        // 引用arr的第四個元素：
        int element4 = arr[3];
    }
}

由于數組中只有三個元素，但引用了索引為3的第四個元素，編譯執行代碼，會拋出如下異常：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at OutOfIndexDemo.main(OutOfIndexDemo.java:5)

5.2 數組元素的修改

既然可以引用數組元素，就可以修改元素，實例如下：

實例演示
預覽 復制
復制成功！
public class ArrayDemo1 {
    public static void main(String[] args) {
        // 初始化整型數組arr：
        int [] arr = {1, 2, 3};
        // 修改下標為1的元素為4
        arr[1] = 4;
        System.out.println("數組arr中，第二個元素為：" + arr[1]);
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果

運行結果：

數組arr中，第二個元素為：4

5.3 獲取數組長度

我們可以使用數組的內置屬性length來獲取數組的長度，使用點操作符調用其內置屬性：arrayName.length。實例如下：

實例演示
預覽 復制
復制成功！
public class ArrayDemo2 {
    public static void main(String[] args) {
        // 初始化整型數組arr：
        int[] arr = {1, 2, 3};
        // 打印數組arr的長度：
        System.out.println("數組arr的長度為：" + arr.length);
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果
數組arr的長度為：3

有時我們想引用數組中最后一個元素，由于數組下標從0開始，所以最后一個元素的下標為數組的長度減去1，這時可以結合length屬性來進行引用。實例如下：

實例演示
預覽 復制
復制成功！
public class ArrayDemo3 {
    public static void main(String[] args) {
        // 初始化一個char類型的數組：
        char[] charArr = {'I', 'm', 'o', 'o', 'c'};
        // 引用最后一個元素：
        char lastElement = charArr[charArr.length-1];
        System.out.println("charArr數組的最后一個元素為：" + lastElement);
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果
charArr數組的最后一個元素為：c

5.4 數組的迭代

5.4.1 循環賦值

我們知道了數組如何賦值，在實際的編碼中，對整型數組循環賦值是很常用的。

實例：

運行結果：

實例演示
預覽 復制
復制成功！
public class ArrayDemo4 {
    public static void main(String[] args) {
        // 聲明一個整型數組
        int[] arr = new int[10];
        // 使用for循環對數組arr進行遍歷，將數字1到10賦值給數組arr
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }
        // 循環賦值完成，此時 arr = {1,2,3,4,5,6,7,8,9,10}
        // 遍歷數組，打印數組中每一個元素
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果
1	2	3	4	5	6	7	8	9	10

5.4.2 循環引用

我們可以使用循環引用依次打印數組中的每個元素。

實例如下：

實例演示
預覽 復制
復制成功！
public class ArrayDemo5 {
    public static void main(String[] args) {
        // 初始化一個整型數組
        int[] arr = {1,2,3,4,5};
        // 使用for循環遍歷數組arr
        for (int i = 0; i < arr.length; i++) {
            // 打印位置i的元素
            System.out.println("索引位置" + i + "的元素為：" + arr[i]);
        }
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果

運行結果：

索引位置0的元素為：1
索引位置1的元素為：2
索引位置2的元素為：3
索引位置3的元素為：4
索引位置4的元素為：5

5.4.3 增強 for 循環

上一小節我們提到for each循環可以更簡單地對數組進行迭代。以下是for each循環的語法結構：

for(變量聲明: 數組或列表) {
    // 循環體
}

我們來看一個實例：

實例演示
預覽 復制
復制成功！
public class ForEachLoop {
    public static void main(String[] args) {
        // 初始化字符串數組 words
        String[] words = {"Welcome ", "to ", "imooc"};
        for(String word: words) {
            System.out.print(word);
        }
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果

運行結果：

Welcome to imooc

實例中遍歷了一個單詞數組，并且將它們打印成了一個句子。for each循環對words數組進行了遍歷，并依次將每個索引的值賦值給了word變量，然后再執行循環體中的語句。顯然 for each循環的代碼看起來更加清晰。但增強for循環無法指定遍歷順序，也無法獲取數組的索引。

5.4.4 更多實例

對于數組的循環還有很多案例，下面我們一起來學習幾個。

實例1，求整型數組中，偶數元素的累加和：

實例演示
預覽 復制
復制成功！
public class ArraySumDemo {
    public static void main(String[] args) {
        // 初始化變量sum，用于存放累加和
        int sum = 0;
        // 創建一個包含100個元素的整型數組
        int[] arr = new int[100];
        // 對arr進行循環賦值，將整數1~100賦值到數組中
        for(int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }
        // 遍歷賦值好的數組
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] % 2 == 0) {
                // 如果當前元素對二取余等于0，則為偶數，執行累加計算
                sum += arr[i];
            }
        }
        // 數組循環計算結束，輸出最終結果
        System.out.println("數組arr中偶數元素的累加和為：" + sum);
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果

運行結果：

數組arr中偶數元素的累加和為：2550

實例2，求數組中最大值：

實例演示
預覽 復制
復制成功！
public class ArrayGetMaxDemo {
    public static void main(String[] args) {
        int[] arr = {20, 30, 15, 70, 92, 11};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println("最大值為：" + max);
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果

運行結果：

最大值為：92

實例3，使用for each循環遍歷整型數組，獲取數組中的最小值：

實例演示
預覽 復制
復制成功！
public class ArrayGetMinDemo {
    public static void main(String[] args) {
        int[] arr = {20, 30, 15, 70, 92, 11};
        int min = arr[0];
        for(int n: arr) {
            if(n < min) {
                min = n;
            }
        }
        System.out.println("最小值為：" + min);
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果

運行結果：

最小值為：11

6. 多維數組

在Java中，多維數組也是非常常用的數據結構，下面以二維數組為例，介紹二維數組的聲明、創建、初始化和引用。

6.1 聲明

二維數組有 3 種聲明方式：

  • 中括號跟在數據類型后：DataType[][] arrayName;（最推薦寫法）
  • 中括號跟在數組名后：DataType arrayName[][];
  • 中括號一個在前，一個在后：DataType[] arranName[];

實例：

// 聲明一個整型的二維數組
int[][] intArray;
// 聲明一個單精度浮點型的二維數組
float floatArray[][];
// 聲明一個char類型的二維數組
char[] charArray[];

6.2創建

二維數組可以想象成一個存放數據的表格，二維數組的創建和一維數組相似。可以聲明數組的同時創建：

javaDataType[][] arrayName = new int[行數][列數];

也可以先聲明再創建：

DataType[][] arrayName;
arrayName = new DataType[行數][列數];

實例：

// 聲明并創建一個2行3列的數組
int[][] intArray = new int[2][3];
// 聲明一個單精度浮點型的二維數組
float floatArray[][];
// 創建一個3行3列的二維數組
floatArray = new float[3][3];

在創建數組的時候，我們也可以先不指定列的數量，再在后面進行逐行創建。

實例：

// 創建一個3行的二維數組
int intArray[][] = new int[3][];
// 第一行3列
intArray[0] = new int[3];
// 第二行2列
intArray[1] = new int[2];
// 第三行1列
intArray[2] = new int[1];

6.3 初始化

多維數組也有靜態初始化和動態初始化之分，對于靜態初始化，一維數組使用一對大括號{}包含其元素，而二維數組的初始化可以使用兩對大括號包含行數和列數。實例如下：

// 創建一個3行2列的二維數組
int[][] intArray = {{1,2}, {3,4}, {5,6}};

動態初始化實例如下：

// 聲明并創建一個數組
int intArray[][] = new int[2][3];
// 為第1行第1列的元素賦值：
intArray[0][0] = 10;

Tips：為數組賦值時，要注意數組的下標索引是從0開始的。

一維數組可以通過length屬性獲取元素個數，同樣二維數組的行數和列數也可以使用length屬性獲取。實例如下：

實例演示
預覽 復制
復制成功！
public class ArrayDemo6 {
    public static void main(String[] args) {
        // 初始化一個3行2列的二維數組
        int[][] intArray = {{1,2,7}, {3,4}, {5,6}};
        // 獲取intArray的行數
        System.out.println("intArray的行數為：" + intArray.length);
        // 獲取intArray第1行的列數
        System.out.println("intArray第一行的列數為：" + intArray[0].length);
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果

運行結果：

intArray的行數為：3
intArray第一行的列數為：3

6.4 二維數組的迭代

一維數組使用單層for循環就可以遍歷，二維數組的遍歷需要使用雙層嵌套for循環。

實例：

實例演示
預覽 復制
復制成功！
public class ArrayDemo7 {
    public static void main(String[] args) {
        // 初始化一個3行2列的二維數組
        int[][] intArray = {{1,2,7}, {3,4}, {5,6}};
        // 遍歷intArray
        for(int i = 0; i < intArray.length; i++) {
            for(int j = 0; j <intArray[i].length; j++) {
                // 打印索引位置[i][j]的元素:
                System.out.println((i+1) + "行" + (j+1) + "列的元素為：" + intArray[i][j]);
            }
            // 打印一個空行
            System.out.println();
        }
    }
}
運行案例 點擊 "運行案例" 可查看在線運行效果

運行結果：

1行1列的元素為：1
1行2列的元素為：2
1行3列的元素為：7

2行1列的元素為：3
2行2列的元素為：4

3行1列的元素為：5
3行2列的元素為：6

7. 小結

本小節我們學習了 Java 數組，知道了數組是引用數據類型。它在創建時，會在內存中開辟一個連續的空間；數組是同一數據類型的集合?？梢允褂脭到M下標來引用數組元素，數組元素的下標都是從0開始，使用下標不要超出范圍，否則會拋出異常。可以使用length屬性獲取數組的長度。對于多維數組，實際開發中建議不要使用超過三維的數組，否則會讓你的程序難以理解和維護。