1. 一维数组

1.1 声明及创建

1
2
3
4
5
6
7
8
9
10
11
12
//一维数组的声明
double[] array;

//一维数组的创建
double[] array = new double[10];


//一维数组初始化
int[] array = {2, 3, 5, 7, 11, 13};
//初始化匿名数组
new int[] {17, 19, 23, 29};
//使用这种方式进行初始化时，数组的大小就是初始值的个数

1.2 数组的遍历

1
2
3
4
5
6
7
8
9
//for循环
for (int i = 0; i < array.length(); i++) {
    System.out.println(array[i]);
}

//增强for循环(for-each循环)
for (int i: array) {
    System.out.println(i);
}

1.3 数组常用方法(Arrays类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Arrays;

//1.打印数组时使用，返回String类型
Arrays.toString(array);

//2.从小到大排序
Arrays.sort(array);

//3.二分法查找元素
Arrays.binarySearch(array, 11);

//4.判断数组是否相等
Arrays.equals(array1, array2);

//5.填充元素
Arrays.fill(array, 11);

//6.数组元素的复制
Integer[] newArray = Arrays.copyOf(array, array.length);

//7.将一组值转化为list
List<Integer> asList = Arrays.asList(1, 2, 3, 4, 5);

2. 多维数组

1.1 声明及创建

1
2
3
4
5
6
7
8
//声明
int[][] array;

//创建
int[][] array = new int[10][10];

//初始化
int[][] array = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

1.2 遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
//普通for循环
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        System.out.println(array[i][j]);
    }
}

//增强型for循环（for-each）
for (int[] interval : array) {
    for (int i : interval) {
        System.out.println(i);
    }
}

若要快速打印二维数组的所有元素，也可以使用Arrays类中的deepToString方法（返回String类型元素）：

1
Arrays.deepToString(array);

1.3 不规则数组

Java其实没有多维数组，只有一维数组，多维数组其实就是数组的数组。例如 int[][] array = new int[10][10]; 既不同于 C 中 int array[10][10]; 也不同于 int (*array)[6] = new int[10][10]; 这正是 Java 的优势所在。

基于这个优势，Java 可以很方便的对两行进行交换：

1
2
3
int[] temp = array[i];
array[i] = array[j];
array[j] = temp;

在构造数组时，也可以给数组每行不同的空间大小：

1
2
3
4
5
int[][] array = new int[4][];
array[0] = new int[4];
array[1] = new int[3];
array[2] = new int[2];
array[3] = new int[1];