数组存储相同类型的序列。
数组声明
数组是一种数据结构, 用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。
在声明数组变量时,需要指出数组类型 (数据元素类型紧跟 [] ) 和数组变量的名字。 下面声明了整型数组 a:
int[] a;
这条语句只声明了变量 a,并没有将 a 初始化为一个真正的数组。应该使用 new 运算符创建数组。
int[] a = new int[100];
这条语句声明并初始化了一个可以存储 100 个整数的数组。
Java 还提供了一种创建数组对象并同时提供初始值的简写形式:
int[] arr = {1, 2, 3, 4, 5, 6, 7};
这个语法不需要使用 new,不需要指定长度。
数组长度不要求是常量:new int[n] 会创建一个长度为 n 的数组。
一旦创建了数据,就不能再改变它的长度,可以改变单个的数组元素。如果程序运行中需要经常扩展数组的大小,就应该使用另一种数据结构——数组列表(array list)。
可以使用下面两种形式声明数组
int[] a;
或
int a[];
大多数 Java 应用程序员喜欢使用第一种风格, 因为它将类型 int[] (整型数组)与变量名清晰的分开了。
匿名数组
可以声明一个匿名数组:
new int[] {7, 8, 9};
会分配一个新数组并填入大括号中提供的值。它会统计初始值得个数,并相应的设置数组大小。
使用匿名数组重新初始化一个数组而无需创建新变量:
int[] arr = {1, 2, 3, 4, 5, 6, 7};
arr = new int[] {7, 8, 9};
是下列语句的简写:
int[] arr = {1, 2, 3, 4, 5, 6, 7};
int[] arr2 = {7, 8, 9};
arr = arr2;
创建长度为 0 的数组:
new elementType[0];
或
new elementTyp[]{}
注意,数组长度为 0 与 null 不同。
访问数组
int[] arr = new int[100];
数组 arr 的数组元素的下标为从 0~99(不是 1~100)。一旦创建了数组,就可以在数组中填入元素。例如,使用一个循环:
int[] arr = new int[100];
for(int i = 0; i < 100; i++) {
arr[i] = i;
}
创建一个数字数组时,所有元素都初始化为0。boolean 数组的元素会初始化为 false。 对象数组的元素则初始化为一个特殊值 null, 这表示这些元素(还)未存放任何对象。
如果创建了一个 100 个元素的数组,并且试图访问元素 arr[100] (或在 0 ~ 99 之外的任何下标) 程序就会引发 “array index out of bounds” 异常而终止执行。
要想获得数组中的元素个数,可以使用 array.length:
int[] arr = new int[7];
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
数组拷贝
在 Java 中,允许将一个数组变量拷贝给另一个数组变量。这时,两个变量将引用同一个数组。
int[] arr1 = new int[] {1, 2, 3, 4, 5, 6, 7};
int[] arr2 = arr1;
arr1[0] = 2;
System.out.println("arr1: " + Arrays.toString(arr1));
System.out.println("arr2: " + Arrays.toString(arr2));
输出结果:
arr1: [2, 2, 3, 4, 5, 6, 7]
arr2: [2, 2, 3, 4, 5, 6, 7]
如果希望将一个数组的所有值拷贝到一个新的数组中去,就要使用 Arrays 类的 copyOf 方法。如果数组元素是数值型,那么多余的元素将被赋值为 0;如果数组元素是布尔型,则将赋值为 false。相反,如果长度小于原始数组的长度,则只拷贝最前面的数据元素。
int[] arr1 = new int[] {1, 2, 3, 4, 5, 6, 7};
int[] arr2 = Arrays.copyOf(arr1, arr1.length);
int[] arr3 = Arrays.copyOf(arr1, 2 * arr1.length);
arr1[0] = 2;
System.out.println("arr1: " + Arrays.toString(arr1));
System.out.println("arr2: " + Arrays.toString(arr2));
System.out.println("arr3: " + Arrays.toString(arr3));
输入结果:
arr1: [2, 2, 3, 4, 5, 6, 7]
arr2: [1, 2, 3, 4, 5, 6, 7]
arr3: [1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0]
命令行参数
每一个 Java 应用程序都有一个带 String arg[] 参数的 main 方法。这个参数表明 main 方法将接收一个字符串数组(程序名没有存储在 args 数组中),这就是命令行上指定的参数。来看下面的例子:
public class Message {
public static void main(String[] args) {
if(args.length == 0) {
System.out.println("没有命令行参数!");
} else {
for(int i = 0; i < args.length; i++) {
System.out.println("第 " + (i + 1) + " 参数: " + args[i]);
}
}
}
}
使用下面的命令:
java Message Hello Xiang017 !
此时 args 数组将包含下列内容:
args[0]: "Hello"
args[1]: "Xiang017"
args[2]: "!"
这个程序将输出:
第 1 参数: Hello
第 2 参数: Xiang017
第 3 参数: !
数组排序
在 Java 中,可以实用 Arrays 类中的 sort 方法对数组进行排序。这个方法使用了优化的快速排序(QuickSort)方法。快速排序算法对于大多数数据集合来说都是效率比较高的。
int[] arr = {3, 1, 7, 5, 2, 4, 6};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
// 打印 [1, 2, 3, 4, 5, 6, 7]
java.util.Arrays 1.2
static String toString(type[] a) 5
返回包含 a 中数据元素的字符串,这些数据元素被放在括号内,并用逗号分隔。
* 参数 a 类型为 int、long、short、char、byte、boolean、float 和 double 的数组。
static type copyOf(type[] a, int length) 6
static type copyOfRange(type[] a, int start, int end)
返回与 a 类型相同的一个数组,其长度为 length 或者 end-start,数组元素为 a 的值。如果 end 大于 a.length,结果会填充 0、false 或 null 值。
* 参数 start: 起始下标(包含这个值)
* 参数 end: 终止下标(不包含这个值)。这个值可能大于 a.length 。在这种情况下,结果为 0 或 false。
* 参数 length: 拷贝的数组长度。如果 length 值大于 a.length,结果为 0、false 或 null 值;否则,数组中只有前面 length 个数据元素的拷贝值。
static void sort(type[] a)
采用优化的快速排序算法对数组进行排序。
static int binarySearch(type[] a, type v)
static int binarySearch(type[] a, int stat, int end, type v)
采用二分搜索算法查找值 v。如果查找成功,则返回相应的下标值;否则,返回一个负数值 r。 -r-1 是为保持 a 有序 v 应插入的位置。
* 参数 start: 起始下标(包含这个值)
* 参数 end: 终止下标(不包含这个值)
* 参数 v 同 a 的数据元素类型相同的值
static void fill(type[] a, type v)
将数组的所有数据元素设置为 v。
* 参数 v 与 a 数据元素类型相同的一个值。
static boolean equals(type[] a, type[] b)
如果两个数组大小相同,并且下标相同的元素都对应相等,返回true。
多维数组
多维数组将使用多个下标访问数组元素,它适用用于表示表格或更加复杂的排列方式。
在 Java 中,声明一个二维数组:
double[][] balances;
对数组初始化前是不能使用的。下面是完成初始化的代码:
balances = new double[NYEARS][NARTES];
如果事先知道数组的元素,可以不调用 new,直接使用简写形式对多维数据进行初始化:
int[][] a = {
{16, 3, 2, 13},
{5, 10, 11, 8},
{9, 6, 7, 12},
{4, 15, 14, 1}
};
初始化后,就可以使用两个中括号访问各个元素。
for each 循环语句不能自动处理二维数组的每一个元素。它是按照行,也就是一维数组处理的。要访问二维数组 a 的所有元素,需要使用两个嵌套的循环:
for (double[] row : a)
for(double value : row)
do something with value
要想快速打印一个二维数组元素列表,可以调用:
System.out.println(Arrays.deepToString(a));
输出格式为:
[[16, 3, 2, 13], [5, 10, 11, 8], [9, 6, 7, 12], [4, 15, 14, 1]]
不规则数组
Java 实际上没有多维数组,只有一维数组。多维数组被被解释为“数组的数组”。
可以方便地构造一个“不规则”数组,即数组的每一行有不同的长度。要想创建一个不规则数组,首先需要分配一个具有所含行数的数组。当需要不规则数组时,只能单独地创建行数组。
int[][] odds = new int[SIZE][];
接下来,分配这些行。
for(int n = 0; n < SIZE; n++) {
odds[n] = new int[n + 1];
}
下面利用不规则数组打印 99 乘法表:
int size = 9;
String[][] arr = new String[size][];
for(int i = 0; i < size; i++) {
arr[i] = new String[i + 1];
for(int j = 0; j < arr[i].length; j++) {
arr[i][j] = String.format("%d * %d = %d", j + 1, i + 1, (i+ 1) * (j + 1));
}
}
for(String[] row : arr) {
for(String value : row) {
System.out.printf("%-12s", value);
}
System.out.println();
}
打印结果:
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81