数组是引用数据类型

一维数组

声明和初始化：

声明：

int[] a; //推荐使用
int b[]; //不推荐，不符合语法规范

初始化

public static void main(String[] args) {
	int[] a = new int[]{1, 2, 3}; //类似构造函数的声明和初始化
	double[] b = {1.1, 2, 4, 3, 5}; //直接初始化
	int[] c = new int[3]; //声明和初始化分开进行
	c[0] = 1;
	c[1] = 2;
	c[2] = 3;
}

使用

数组长度：

初始化结束后长度就确定了，调用length属性查看数组长度

System.out.println(c.length);

遍历数组

可以使用普通循环

for-Each

java中的特有数组遍历方法：for-Each循环，可以不用下标遍历
语法：

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

element可以视为形参，代表数组中的每个元素
例：

for (int el:c) {
	System.out.println(el);
}

数组元素默认初始化值

二维数组

初始化

二维数组本质是一个元素为数组的数组

静态初始化

即预先确定数组每行每列的元素

int[][] a = new int[][]{{1,2},{3,4},{5,6}};

并且每行为一个单独的一维数组
可以创建不规则数组：

int[][] b = new int[][]{{1, 2, 4}, {3, 4}, {5, 6, 7, 8, 9}};

因为也是一个数组，所以可以如下初始化

int[] y[];

动态初始化

1. 指定行列数，但不指定元素

int[][] a = new int[3][4];

2. 只指定行数，可以创建不规则数组

public static void main(String[] args) {
	int[][] a = new int[5][];
	for (int i = 0; i < 5; i++) {
		a[i] = new int[i + 1];
		for (int j = 0; j < i + 1; j++) {
			a[i][j] = i + 1;
		}
	}
	for (int[] n : a) {
		for (int x : n) {
			System.out.print(x + " ");
		}
		System.out.println();
	}
}

注意每行都要单独创建新数组

使用

长度

二维数组本质是一个元素为数组的数组，长度为数组个数，即行数

int[][] b = new int[][]{{1, 2, 4}, {3, 4}, {5, 6, 7, 8, 9}};
System.out.println(b.length); // 结果为3

默认初始化值

外层默认为地址，内层和一维数组相同，Java/Java基础/数组#数组元素默认初始化值
注意不指定列数的动态数组外层为空指针，无法访问

数组赋值

int[][] c = b;

java中数组可以通过名字赋值，已经初始化的数组也可以直接赋值，但是会覆盖原有数据，不是复制一份新的数组

int[][] b = new int[][]{{1, 2, 4}, {3, 4}, {5, 6, 7, 8, 9}};
int[][] c = new int[][]{{1, 2}, {3}, {5, 6, 7}};
b = c;

数组复制

一定要和上面的赋值区分，数组的复制只能采用逐个元素赋值的方法，内层元素也要逐个赋值，如下语句本质上还是数组赋值：

public static void main(String[] args) {
	int[][] b = {{1, 2, 4}, {3, 4}, {5, 6, 7, 8, 9}};
	int[][] c = new int[b.length][];
	for (int i = 0; i < b.length; i++) {
		c[i] = b[i];
		System.out.print(c[i]);
		System.out.print(b[i]);
		System.out.println();
	}
	System.out.print(c);
	System.out.print(b);
}

输出为：

[I@1b6d3586[I@1b6d3586
[I@4554617c[I@4554617c
[I@74a14482[I@74a14482
[[I@1540e19d[[I@677327b6124

发现内层地址还是一致，无法实现复制

数组常用算法