当前位置： Java > Java 数组

admin · 更新于 2021-08-06

Java 数组

数组在编程语言中是非常重要的数据结构。本小节我们来一起学习 Java 数组，通过本小节的学习，你将了解到数组的基本概念，如何声明数组以及数组的声明有哪些方式，如何初始化数组以及数组初始化有哪些方式，数组的常用操作有哪些，多维数组的声明、创建、初始化以及迭代等等。多维数组部分将以二维数组进行为例讲解，理解了二维数组，再去理解多维数组就相对容易了。

1. 什么是数组

数组是相同类型的数据按照顺序组成的一种引用数据类型。

Java 中有基本数据类型和引用数据类型两种数据类型。数组就是引用数据类型。

2. 数组声明

在Java语言中，数组声明有两种语法：

中括号跟在数据类型后：DataType[] arrayName;
中括号跟在数组名称后：DataType arrayName[];

其中DataType是数组中要存放元素的数据类型，例如int、String等，arrayName是数组名称，遵守变量的命名规范。

在实际的编码中，我们更常用的是第一种语法。实例如下：

// 声明一个int类型的数组，名称为 firstIntArray:int[] firstIntArray;  // 推荐写法int firstIntArray[];代码块
1
2
3

也可以修改数据类型，以生成其他类型的数组。实例如下：

// 声明一个float类型的数组：float[] firstFloatArray;// 声明一个字符串类型的数组：String[] firstStringArray;代码块
1
2
3
4

3. 数组创建

3.1 先声明再创建

先声明再创建，需要编写两条语句：

DataType[] arrayName;arrayName = new DataType[数组长度];代码块
1
2

数组的创建使用new关键字，后面跟上一个空格+数据类型+中括号[]，中括号中间是数组的长度，这里是必须指定的，它是一个整型的数字。实例如下：

// 声明一个整型的数组：int[] intArray;// 创建数组，长度为10intArray = new int[10];代码块
1
2
3
4

3.2 声明时同时创建

声明时同时创建，需要编写一条语句：

DataType[] arrayName = new DataType[数组长度];代码块
1

实例如下：

// 声明时同时创建int[] intArray = new int[10];代码块
1
2

数组声明用到的中括号，也可以放到数组名称的后面，实例如下：

int intArray[] = new int[10];代码块
1

所创建的数组数据类型必须与其声明的数据类型相同。对于其他类型数组的创建，实例如下：

// 创建一个数据类型为字符串、长度为5的数组：String[] stringArray = new String[5];// 创建一个数据类型为双精度浮点型、长度为10的数组：double[] floatArray = new double[10];// 创建一个数据类型为字符型、长度为10的数组：char[] charArray;charArray = new char[10];代码块
1
2
3
4
5
6
7
8
9

4. 数组初始化

数组创建后，所有元素都初始化为默认值，整型数组的元素都为 0，浮点型都为 0. 0 ，布尔型都为 false。例如 int[] arr = new int[5];语句创建了一个数组

除了数组的默认初始化，还有另外两种常见形式：

静态初始化
动态初始化

下面我们将分别介绍两种数组的初始化形式。

4.1 静态初始化

静态初始化数组，就是声明的同时，给数组赋值。其语法为：

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

赋值符号右边为用中括号所包围的 n 个元素，实例如下：

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

上面数组arr存放的元素为从 1 到 5 这几个整型。其的长度为 5 。数组的长度就是初始化时所给数组元素的个数。

4.2 动态初始化

动态初始化数组，即数组的声明以及创建是与数组的赋值操作分开进行的。实例如下：

// 声明并创建数组，长度为3int[] arr = new int[3];// 给下标位置0赋值为1arr[0] = 1;// 给下标位置1赋值为2arr[1] = 2;// 给下标位置2赋值为3arr[2] = 3;代码块
1
2
3
4
5
6
7
8

数组是有下标的，下标从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);
    }}1
2
3
4
5
6
7
8
9

运行案例点击 "运行案例" 可查看在线运行效果

运行结果：

数组arr中，第一个元素为：1代码块
1

注意，上面的数组下标最大为 2，也就是说，引用元素时，不能超过其下标最大值。下面是一个反例：

public class OutOfIndexDemo {
  	public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        // 引用arr的第四个元素：
        int element4 = arr[3];
    }}代码块
1
2
3
4
5
6
7

由于数组中只有三个元素，但引用了索引为3的第四个元素，编译执行代码，会抛出如下异常：

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

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]);
    }}1
2
3
4
5
6
7
8
9

运行案例点击 "运行案例" 可查看在线运行效果

运行结果：

数组arr中，第二个元素为：4代码块
1

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);
    }}1
2
3
4
5
6
7
8

运行案例点击 "运行案例" 可查看在线运行效果

数组arr的长度为：3代码块
1

有时我们想引用数组中最后一个元素，由于数组下标从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);
    }}1
2
3
4
5
6
7
8
9

运行案例点击 "运行案例" 可查看在线运行效果

charArr数组的最后一个元素为：c代码块
1

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
11
12
13
14
15

运行案例点击 "运行案例" 可查看在线运行效果

1	2	3	4	5	6	7	8	9	10代码块
1

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]);
        }
    }}1
2
3
4
5
6
7
8
9
10
11

运行案例点击 "运行案例" 可查看在线运行效果

运行结果：

索引位置0的元素为：1
索引位置1的元素为：2
索引位置2的元素为：3
索引位置3的元素为：4
索引位置4的元素为：5代码块
1
2
3
4
5

5.4.3 增强 for 循环

上一小节我们提到for each循环可以更简单地对数组进行迭代。以下是for each循环的语法结构：

for(变量声明: 数组或列表) {
    // 循环体}代码块
1
2
3

我们来看一个实例：

实例演示

public class ForEachLoop {
    public static void main(String[] args) {
        // 初始化字符串数组 words
        String[] words = {"Welcome ", "to ", "hanma"};
        for(String word: words) {
            System.out.print(word);
        }
    }}1
2
3
4
5
6
7
8
9

运行案例点击 "运行案例" 可查看在线运行效果

运行结果：

Welcome to hanma代码块
1

实例中遍历了一个单词数组，并且将它们打印成了一个句子。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);
    }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行案例点击 "运行案例" 可查看在线运行效果

运行结果：

数组arr中偶数元素的累加和为：2550代码块
1

实例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);
    }}1
2
3
4
5
6
7
8
9
10
11
12

运行案例点击 "运行案例" 可查看在线运行效果

运行结果：

最大值为：92代码块
1

实例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);
    }}1
2
3
4
5
6
7
8
9
10
11
12

运行案例点击 "运行案例" 可查看在线运行效果

运行结果：

最小值为：11代码块
1

6. 多维数组

在Java中，多维数组也是非常常用的数据结构，下面以二维数组为例，介绍二维数组的声明、创建、初始化和引用。

6.1 声明

二维数组有 3 种声明方式：

中括号跟在数据类型后：DataType[][] arrayName;（最推荐写法）
中括号跟在数组名后：DataType arrayName[][];
中括号一个在前，一个在后：DataType[] arranName[];

实例：

// 声明一个整型的二维数组int[][] intArray;// 声明一个单精度浮点型的二维数组float floatArray[][];// 声明一个char类型的二维数组char[] charArray[];代码块
1
2
3
4
5
6

6.2创建

二维数组可以想象成一个存放数据的表格，二维数组的创建和一维数组相似。可以声明数组的同时创建：

javaDataType[][] arrayName = new int[行数][列数];代码块
1

也可以先声明再创建：

DataType[][] arrayName;arrayName = new DataType[行数][列数];代码块
1
2

实例：

// 声明并创建一个2行3列的数组int[][] intArray = new int[2][3];// 声明一个单精度浮点型的二维数组float floatArray[][];// 创建一个3行3列的二维数组floatArray = new float[3][3];代码块
1
2
3
4
5
6

在创建数组的时候，我们也可以先不指定列的数量，再在后面进行逐行创建。

实例：

// 创建一个3行的二维数组int intArray[][] = new int[3][];// 第一行3列intArray[0] = new int[3];// 第二行2列intArray[1] = new int[2];// 第三行1列intArray[2] = new int[1];代码块
1
2
3
4
5
6
7
8

6.3 初始化

多维数组也有静态初始化和动态初始化之分，对于静态初始化，一维数组使用一对大括号{}包含其元素，而二维数组的初始化可以使用两对大括号包含行数和列数。实例如下：

// 创建一个3行2列的二维数组int[][] intArray = {{1,2}, {3,4}, {5,6}};代码块
1
2

动态初始化实例如下：

// 声明并创建一个数组int intArray[][] = new int[2][3];// 为第1行第1列的元素赋值：intArray[0][0] = 10;代码块
1
2
3
4

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);
    }}1
2
3
4
5
6
7
8
9
10

运行案例点击 "运行案例" 可查看在线运行效果

运行结果：

intArray的行数为：3
intArray第一行的列数为：3代码块
1
2

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行案例点击 "运行案例" 可查看在线运行效果

运行结果：

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

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

3行1列的元素为：5
3行2列的元素为：6代码块
1
2
3
4
5
6
7
8
9

7. 小结

本小节我们学习了 Java 数组，知道了数组是引用数据类型。它在创建时，会在内存中开辟一个连续的空间；数组是同一数据类型的集合。可以使用数组下标来引用数组元素，数组元素的下标都是从0开始，使用下标不要超出范围，否则会抛出异常。可以使用length属性获取数组的长度。对于多维数组，实际开发中建议不要使用超过三维的数组，否则会让你的程序难以理解和维护。

汉码未来

Java 入门教程

Java 数组

1. 什么是数组

2. 数组声明

3. 数组创建

3.1 先声明再创建

3.2 声明时同时创建

4. 数组初始化

4.1 静态初始化

4.2 动态初始化

5. 数组的操作

5.1 数组元素的引用

5.2 数组元素的修改

5.3 获取数组长度

5.4 数组的迭代

5.4.1 循环赋值

5.4.2 循环引用

5.4.3 增强 for 循环

5.4.4 更多实例

6. 多维数组

6.1 声明

6.2创建

6.3 初始化

6.4 二维数组的迭代

7. 小结

为什么选择汉码未来

线下面授

五人小班

技术强大

内推就业