数组是多个相同类型的数据按一定顺序排列的集合。

说明：

• 数组是引用数据类型，数组的元素是同一类型的任何数据类型，包括基本数据类型和引用数据类型。
• 数组的长度一旦确定，就不可变。
• 可以通过下标或索引的方式获取指定位置的元素（数组的下表是从0开始）。
• 创建数组对象会在内存开辟一整块连续的空间，而数组名中引用的是这块连续空间的地址。

一维数组

声明

• 格式一

数据类型 数组名[];

• 格式二（推荐）

数据类型[] 数组名;

初始化与赋值

• 动态初始化：数组声明且为数组元素分配空间（未赋值，即默认值）

//声明并分配空间大小
int[] val = new int[3]; //未赋值的时候默认值为0
//赋值，通过指定数组下标赋值
val[0] = "10"; //下标从0开始
val[1] = "20";
val[2] = "30";

• 静态初始化：在定义数组的同时给数组元素分配空间并赋值

//方式一
int[] temp = {15, 21}; //数组长度为2

//=============================================

//方式二
int[] temp = new int[]{3, 5, 7}; //数组长度为3

数组是引用类型，只要一经分配空间，其中的每个元素也被隐式初始化。对于基本数据类型数组，默认初始化值各不同（int默认为0），引用数据类型而言，默认初始化值为null。

示例：

//声明并初始化
int[] arr = new int[3];
//赋值
arr[0] = 3;
arr[1] = 5;
arr[2] = 9;
//打印输出
System.out.println(arr); //[I@4554617c 一维数组地址

如上代码所示，因为数组是引用数据类型，直接打印 arr 的结果是内存地址。

地址解析：[I@4554617c （[表示一维数组，I表示int类型，@后面是地址值）。

图示：

若此时使用arr[3]=10;进行赋值，会发现数组分配空间不够，没有3下标的空间，就会出现ArrayIndexOutOfBoundsException异常。

注意：数组的大小一旦定义则不可变，则赋值和获取的数组下标不能超过或等于（因为从0下标开始）声明定义的数组大小，否则会出现ArrayIndexOutOfBoundsException异常。

若要获取数组元素的值，需要遍历该数组，通过数组下标获取。

for (int i = 0; i < arr.length; i++) {
     System.out.println(arr[i]);
}
//输出：3、5、9

内存图解

二维数组

二维数组可以看成是一个一维数组作为另一个一维数组的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。像数组的元素是数组，我们暂且称为元素数组。

个人理解：

注意：数组不止二维，还可以是三维、四维……类似无限套娃。

声明

• 格式一（推荐）

数据类型[][] 数组名;

• 格式二

数据类型 数组名[][];

• 格式三（不推荐）

数据类型[] 数组名[];

初始化与赋值

• 动态初始化

//方式一
int[][] arr = new int[3][2]; //该二维数组中有3个一维数组，且每个一维数组中有2个元素数组（开头有约定名称），默认值为0
//打印输出
System.out.println(arr[0][0]); //输出：0
//赋值
arr[0][0] = 1;
//打印输出
System.out.println(arr[0][0]); //输出：1

//===================================================

//方式二
int[][] arr = new int[3][]; //该二维数组有3个一维数组，每个一维数组中的元素数组都是默认初始化值null
//初始化并赋值
arr[0] = new int[]{2, 4, 6};
//先初始化再赋值
arr[1] = new int[2];
arr[1][0] = 13;
//打印输出
System.out.println(arr[0][0]); //输出：2
System.out.println(arr[1][0]); //输出：13

注意：int[][] arr = new int[][3]; 非法。

• 静态初始化

//方式一
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

//================================================

//方式二
int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}}; //定义一个名称为arr的二维数组，二维数组中有三个一维数组
//获取元素值
System.out.println(arr[0]); //{3,8,2}

注意：静态初始化中每个一维数组中具体元素数组都已初始化并赋值。

示例：

//动态初始化方式一，数组长度为3，元素数组长度为1
int[][] arr = new int[3][1];
System.out.println(arr); //[[I@4554617c 二维数组地址
//赋值
arr[0][0] = 1;
arr[1][0] = 3;
arr[2][0] = 2;
System.out.println(arr[2][0]); //输出：2
System.out.println(arr[2]); //[I@74a14482 一维数组地址
arr[2][1] = 5; //ArrayIndexOutOfBoundsException指针越界异常，因为数组声明时定义了元素数组长度为1，上面arr[2]已经赋值0下标

地址解析：[[I@4554617c（[[表示二维数组，I表示int类型，@后面是地址值）

注意：当引用的数组下标大于等于定义的数组长度，会出现ArrayIndexOutOfBoundsException指针越界异常。

图示：

//动态初始化方式二
int[][] temp = new int[3][];
System.out.println(temp); //[[I@4554617c 二维数组地址
System.out.println(temp[0]); //null
System.out.println(temp[0][0]); //NullPointerException空指针异常，因为元素temp[0]为null,而temp[0][0]是获取temp[0]数组下标为0的值
//元素初始化
temp[0] = new int[1]; //数组长度为1
temp[1] = new int[]{12, 4, 3}; //数组长度为3
//元素数组赋值
temp[0][0] = 10;
System.out.println(temp[0]); //[I@74a14482 一维数组地址
System.out.println(temp[0][0]); //输出：10
System.out.println(temp[1][0]); //输出：12

注意：当引用的数组元素是一个非基本数据类型且为null时，使用该元素引用会出现NullPointerException空指针异常。

图示：

动态初始化方式一和方式二的区别：

1. 方式一在使用的时候不需要初始化元素，方式二需要初始化元素后再使用，否则会出现NullPointerException异常。
2. 方式一元素数组的长度在声明初始化的时候就固定了，方式二元素数组在声明初始化的时候不固定。

若要获取数组元素的值，需要遍历该数组，通过数组下标获取。

int[][] arr = {{1, 2},{5, 9},{10, 11, 13}};
for (int i = 0; i < arr.length; i++) {
     int[] val = arr[i];
     for (int j = 0; j < val.length; j++) {
         System.out.println(val[j]);
     }
}

内存图解

数组练习

杨辉三角

冒泡排序

线性查找

二分法

数组反转