数组存储相同类型的序列。
1. 数组声明
数组是一种数据结构，用来存储同一类型值的集合。通过一个整型下标（index，或称索引）可以访问数组中的每一个值。
在声明数组变量时，需要指出数组类型（数据元素类型紧跟 []）和数组变量的名字。
一旦创建了数组，就不能再改变它的长度，可以改变单个的数组元素。如果程序运行中需要经常扩展数组的长度，就应该使用另一种数据结构——数组列表（array list）。
下面声明了整型数组 a:
int[] a;
这条语句只声明了变量 a，并没有将 a 初始化为一个真正的数组。
使用 new 运算符创建数组:
int[] a = new int[100];
这条语句声明并初始化了一个可以存储 100 个整数的数组。
数组长度不要求是常量：new int[n] 会创建一个长度为 n 的数组。
可以使用下面两种形式声明数组
int[] a;
或
int a[];
大多数 Java 应用程序员喜欢使用第一种风格，因为它将类型int[](整型数组)与变量名清晰的分开了。
Java 还提供了一种创建数组对象并同时提供初始值的简写形式：
int[] arr = {1, 2, 3, 4, 5, 6, 7};
这个语法中不需要使用 new，甚至不需要指定长度。
最后一个值后面允许有逗号，如果你要不断为数组增加值，这会很方便：
String[] authors = {
"James Gosling",
"Bill Joy",
"Guy Steele",
// add more names here and put a comma after each name
};
声明一个匿名数组：
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;
注释：在 Java 中，允许有长度为 0 的数组。在编写一个结果为数组的方法时，如果碰巧结果为空，这样一个长度为 0 的数组就很有用。
创建长度为 0 的数组：
new elementType[0];
或
new elementTyp[]{}
注意，长度为 0 的数组与 null 并不不同。
2. 访问数组
int[] arr = new int[100];
数组 arr 的数组元素的下标为从 0~99（不是 1~100）。
各类型数组创建后的初始值：
- 创建一个数字数组时，所有元素都初始化为 0。
- 创建一个 boolean 数组的元素会初始化为 false。
- 创建一个对象数组的元素则初始化为一个特殊值 null, 表示这些元素(还)未存放任何对象。
一旦创建了数组，就可以在数组中填入元素。例如，使用一个循环：
int[] arr = new int[100];
for(int i = 0; i < 100; i++) {
arr[i] = i;
}
要想获得数组中的元素个数，可以使用 array.length:
int[] arr = new int[7];
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
如果创建了一个 100 个元素的数组，并且试图访问元素 arr[100] (或在 0 ~ 99 之外的任何下标)，就会引发 “array index out of bounds” 异常。
3. for each 循环
Java 有一种功能很强的循环结构，可以用来依次处理数组（或者其他元素集合）中的每个元素，而不必考虑指定下标值。
这种增强的 for 循环的语句格式为：
for (variable : collection) statement
它定义一个变量用于暂存集合中的每一个元素，并执行相应的语句（当然，也可以是语句块）。collection 这一集合表达式必须是一个数组或者是一个实现了 Iterable 接口的类对象（例如 ArrayList）。例如：
int [] a = {1, 2, 3};
for (int element : a) {
System.out.println(element);
}
这个循环应该读作“循环 a 中的每一个元素”（for each element in a）。Java 语言的设计者认为应该使用诸如 foreach、in 这样的关键字，但这种循环语句并不是最初就包含在 Java 语言中的，而是后面添加进去的，而且没有人希望破坏已经包含同名（例如 System.in）方法或变量的旧代码。
当然，使用传统的 for 循环也可以获得同样的效果：
int [] a = {1, 2, 3};
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
但是，for each 循环语句显得更加简洁、更不易出错，因为你不必为下标的起始值和终止值而操心。
注释，
for each循环语句的循环变量将会遍历数组中的每个元素，而不是下标值。
如果需要处理一个集合中的所有元素，for each 循环语句相对于传统循环语句所做的改进让人欣喜。然而，在很多情况下还是需要使用传统的 for 循环。例如，如果不希望遍历整个集合，或者在循环内部需要使用下标值。
提示：有一个更加简单的方式可以打印数组中的所有值，即利用 Arrays 类的 toString 方法。调用
Arrays.toString(a)，返回一个包含数组元素的字符串，这些元素包围在中括号内，并用逗号分隔，例如，“[2, 3, 5, 7, 11, 13]”。要想打印数组，只需要调用
System.out.println(Arrays.toString(a));
4. 数组拷贝
在 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]
5. 命令行参数
每一个 Java 应用程序都有一个带 String arg[] 参数的 main 方法。这个参数表明 main 方法将接收一个字符串数组，也就是命令行上指定的参数。
来看下面的例子：
public class Message {
public static void main(String[] args) {
if(args.length == 0 || args[0].equals("-h")) {
System.out.print("Hello,");
} else if(args[0].equals("-g")){
System.out.print("Goodbye,");
}
for(int i = 1; i < args.length; i++) {
System.out.print(" " + args[i]);
}
System.out.println("!");
}
}
使用下面的命令：
java Message -g cruel world
此时 args 数组将包含下列内容：
args[0]: "-g"
args[1]: "cruel"
args[2]: "world"
这个程序会显示下面这个消息：
Goodbye, cruel world!
在 Java 应用程序的 main 方法中，程序名并没有存储在 args 数组中。例如，当从命令行使用以下命令运行程序时
java Message -h world
args[0] 是 “-h”，而不是 “Message” 或 “java”。
6. 数组排序
可以使用 Arrays 类中的 sort 方法对数组进行排序。这个方法使用了优化的快速排序（QuickSort）方法。快速排序算法对于大多数数据集合来说都是效率比较高的。Arrays 还提供了另外一些很便捷的方法。
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(xxx[] a) 5
返回包含 a 中元素的一个字符串，这些元素用中括号包围，并用逗号分隔。
数组元素类型 xxx 可以是任何类型。
- static type copyOf(xxx[] a, int length) 6
- static type copyOfRange(xxx[] a, int start, int end)
返回与 a 类型相同的一个数组，其长度为 length 或者 end-start，数组元素为 a 的值。如果 end 大于 a.length，结果会填充 0、false 或 null。
数组元素类型 xxx 可以是任何类型。
* 参数 start: 起始下标（包含这个值）
* 参数 end: 终止下标（不包含这个值）。这个值可能大于 a.length 。在这种情况下，结果为 0、false 或 null。
* 参数 length: 拷贝的数组长度。如果 length 值大于 a.length，结果为 0、false 或 null 值；否则，数组中只有前面 length 个数据元素的拷贝值。 - static void sort(xxx[] a)
使用优化的快速排序算法对数组进行排序。
数组元素类型 xxx 可以是任何类型。
- static int binarySearch(xxx[] a, xxx v)
- static int binarySearch(xxx[] a, int stat, int end, xxx v)
使用二分搜索算法在有序数组 a 中查找值 v。如果找到 v，则返回相应的下标值；否则，返回一个负数值 r。-r-1 是 v 应插入的位置（为保持 a 有序）。
数组元素类型 xxx 可以是任何类型。
* 参数 start: 起始下标（包含这个值）
* 参数 end: 终止下标（不包含这个值）
* 参数 v 同 a 的元素类型相同的值 - static void fill(xxx[] a, xxx v)
将数组的所有数据元素设置为 v。
数组元素类型 xxx 可以是任何类型。
* 参数 v 与 a 数据元素类型相同的一个值。 - static boolean equals(xxx[] a, xxx[] b)
如果两个数组大小相同，并且下标相同的元素都对应相等，返回true。
数组元素类型 xxx 可以是任何类型。
7. 多维数组
多维数组将使用多个下标访问数组元素，它适用于表示表格或更加复杂的排列方式。
在 Java 中，声明一个二维数组：
double[][] balances;
对数组初始化前是不能使用的。下面是完成初始化的代码：
balances = new double[10][10];
一旦数组初始化，就可以利用两个中括号访问各个元素，例如，balances[i][j]。
如果事先知道数组的元素，可以不调用 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]]
8. 不规则数组
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("%-8s", 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
