Java数组

数组在每个编程语言中都是非常重要的数据结构，当然，每个编程语言实现的方式有可能不一样。

Java 语言中，数组是用来存储固定大小的相同类型的一组元素。

Java 语言中，数据类型分为基本数据类型和引用数据类型。

数组属于引用类型

本小节会为大家介绍 数组的概念，数组的声明和创建，数组的初始化等。

1 什么是数组

数组就是相同的数据类型的元素连续存放在一起组成的一块区域

如下图：数组存储了 5 个 int 类型的数，并且都是连续的

2 如何声明数组

在Java语言中，声明数组的方式有 2 种

• 中括号跟在数据类型后: DataType[] arrayName; 如：int[] arr;
• 中括号跟在数组名称后：DataType arrayName[]; 如：int arr[]

这 2 种方式都是可以的，但是最常用的是第 1 种写法，即将 数据类型和 [] 放在一起

如下：

copy
public class HelloWorld {
    public static void main(String[] args) {
        int[] arr;
        String[] names;
    }
}

注意: 建议使用 DataType[] arrayName 的声明风格声明数组变量。

DataType arrayName[] 风格是来自 C/C++ 语言 , 在Java中采用是为了让 C/C++ 程序员能够快速理解Java语言。

声明了数组，但是还没有给数组实际分配内存和大小，下面来看如何创建一个数组。

3 创建数组

Java 中使用 new 关键字来创建一个数组， 语法如下：

copy
DataType[] arrName = new DataType[ size ];

上面的语法做了 3 件事：

• 声明了一个数组， arrName
• 创建了一个数组，大小为 size
• 将创建的数组的引用赋值给了变量 arrName

也可以省略 size ，使用下面的方式创建数组

copy
DataType[] arrName = new DataType[]{e0, e1, e2, .... eN};

4 数组元素的访问

数组的元素是通过索引访问的。数组索引从 0 开始，所以一个长度是 n 的数组，它的索引范围是 [ 0 , n - 1 ]

实例：

copy
public class HelloWorld {
    public static void main(String[] args) {

        //声明并定义了一个有 5 个元素大小的数组
        int size = 5;
        int[] arr = new int[size];

        // 分别给每个元素赋值
        // 这里一定要注意，索引从 0 开始，所以最后一个索引是 4
        arr[0] = 3;
        arr[1] = 5;
        arr[2] = 1;
        arr[3] = 7;
        arr[4] = 6;

        //遍历数组，并打印
        for ( int i = 0; i < size; i++) {
            System.out.println( arr[i] );
        }
    }
}

//输出如下：

3
5
1
7
6

下图提示了数组 arr , arr 数组里有 5 个 int 元素，它的下标从 0 到 4

5 数组元素的修改

可以直接通过索引的方式，直接对某个元素赋值修改

copy
public class HelloWorld {
    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

6 获取数组的长度

可以使用数组提供的内置属性来获取数组的长度： arr.length

实例：

copy
public class HelloWorld {
    public static void main(String[] args) {

        // 初始化整型数组arr：
        int [] arr = {1, 2, 3};

        System.out.println("数组的长度是 " + arr.length );
    }
}

//输出： 数组的长度是  3

7 遍历数组

遍历数组，就是依次对数组中的每个元素进行访问

可以通过 for 或者增加版本的 for-each 进行循环遍历

7.1 实例如下：使用 for 循环遍历

copy
public class HelloWorld {
    public static void main(String[] args) {
        
        int [] arr = {3, 1, 8};
        for (int i = 0;i < arr.length; i++) {
            System.out.println( arr[i] );
        }
    }
}

//输出如下：
3
1
8

7.2 使用 for-each 遍历

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

语法格式如下：

copy
for(type element: array){
    System.out.println(element);
}

实例如下：

copy
public class HelloWorld {
    public static void main(String[] args) {

        int [] arr = {3, 1, 8};
        for ( int e : arr) {
            System.out.println( e );
        }
    }
}

//输出如下：
3
1
8

8 多维数组

先看一维数组，上面介绍的就是一维的数组 ，比如下面代码定义一个维数组

int[] arr = new int[3];

可以看出：

1. arr 是一个一维数组
2. arr中的每一个元素都是 int 类型

8.1 二维数组

从上面的 arr 一维数组知道，arr 中的每个元素都是一个 int 类型

那么二维数组，里面的每个元素，也是一个数组，所以

二维数组就是数组的数组，有点绕，简单来说：二维数组，就是一个维数组，这个一维数组里面的每一个元素，还是一个一维数组

8.2 多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

数学里面经常用用已知数求解未知数：今天我们就来用一维数组来解释多维数组，如下：

8.2.1 定义一维数组

如下示例：

copy
int[] arr = new int[2];

定义了一个一维数组，数组大小是 2，里面的每个元素都是 int 类型。 如下图

8.2.2 定义二维数组

如下示例：

copy
int[][] arr2 = new int[2][3];

定义了一个二维数组 arr ,

可以这样理解，定义了一个一维的数组，数组里面每个元素也是一个数组（大小为 3 ，元素类型是 int ）

如下图：

8.2.3 定义三维数组

如下示例：

copy
int[][] arr3 = new int[2][3][4];

上面代码定义了一个三维数组，可以理解为：

• 定义了一个一维数组，假如是 arr1 ，这个 arr1 大小为 2 ，里面的每个元素都是一个二维数组（大小为 3 ，里面有4个元素，每个元素还是一个数组）
• 假如第一个元素的二维数组是 arr2，这个 arr2 的大小为3 ， 里面的每个元素都是一个一维数组（大小为 4 ，里面每个元素是个 int 值 ）
• 假如这个二维数组的第一个元素是 arr3 , 这个 arr3 的大小为 4，里面的每一个元素都是一个 int 类型的值

下面用图解释的更清楚一点：

8.2.4 多维数组

通过上面的介绍，我们知道：

一维数组里面，每个元素是个一个具体的数据类型

二维数组其实就是一个一维数组，只不过这个一维数组里面第一个元素也是一个一维的数组（有大小）

三维数组里面就是一个二维数组，只不过最里面的一个一维数组的每个元素还是一个数组（有大小）

多维数组就是数组的数组。每个元素还是一个数组，直到最后一个数组里面是具体的类型

8.2.5 二维数组的遍历

copy
public class HelloWorld {

    public static void main(String[] args) {
        //创建了一个二维数组，大小为 2 ，里面的每个元素也是一个数组
        //里面的每个数组的大小为 3 ，类型为 int 
        int [][] arr = new int[2][3];

        // 给数组的第一个元素（也是个数组）赋值
        // 假如把 arr[0] 看作一个整体，比如叫 cc
        // 那么下面的赋值就变成了
        // cc[0] = 1;
        // cc[1] = 2;
        // cc[2] = 3;
        // 这样就方便理解多了
        arr[0][0] = 1;
        arr[0][1] = 2;
        arr[0][2] = 3;

        arr[1][0] = 4;
        arr[1][1] = 5;
        arr[1][2] = 6;

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

//输出如下：
    1
    2
    3
    4
    5
    6

小结

通过上面的学习，了解到，数组是一块连续的内存空间，通过索引访问数组中的每个元素

现在总结如下：

• 数组是引用类型

• 数组在内存中是一块连续的空间

• 定义数组的方式，要指定类型和大小，比如 int[] arr = new int[2]

• 也可以省略大小，不过要在后面直接赋值，比如 int[] arr = new int[]{1,2}

• 数组的索引从 0 开始，所以大小为 n 的数组，索引的范围是 [ 0 , n - 1 ] ,即最后一个元素的索引是 n - 1

• 数组的长度通过数组的内置属性 length 获取 , 比如 arr.length

• 修改数组的值，可以使用索引，比如 arr[3] = 10

• 可以使用 for循环 遍历数组 ， 也可以使用 增加版的 for-each 来遍历数组

• 二维数组是数组的数组，比如 int arr[2][3] , 数组有 2 个元素，每个元素里面也是一个数组，里面的每个数组的大小为 3

• 多维数组的理解，和二维数组的类似，都是数组的数组