Java数组
1、数组特殊性
①数组是一种效率最高的存储和随机访问对象引用序列的方式
②数组对象的大小固定，在其生命周期中不可改变
③可以创建一个数组去持有某种具体的类型，可以持有基本类型
2、数组初始化
对象数组保存的是引用，基本类型数组直接保存基本类型的值。
1 class BerylliumSphere{}
2 //1、通过new初始化
3 BerylliumSphere[] a = new BerylliumSphere[6];
4 //2、普通的聚集初始化
5 BerylliumSphere[] b = { new BerylliumSphere(),
6 new BerylliumSphere() };
7 //3、动态聚集初始化
8 BerylliumSphere[] c;
9 c = new BerylliumSphere[]{
10 new BerylliumSphere(),new BerylliumSphere()
11 }
3、多维数组
（1）初始化
1 //1、通过new创建
2 int[][] a = new int[2][3];
3 //2、通过花括号创建
4 int[][] b = {
5 {1,2,3},
6 {4,5,6}
7 };
（2）Arrays.deepToString()
该方法可以将多维数组根据层次输出为字符串。
1 int[][] b = { {1,2,3},{4,5,6} };
2 System.out.println(Arrays.deepToString(b));
3 /*Output：
4 [[1, 2, 3], [4, 5, 6]]*/
（3）粗糙数组
数组中构成矩阵的每个向量都可以具有任意的长度，这称为粗糙数组。
1 int[][] a = new int[3][];
2 int n=1;
3 for(int i=0;i<3;i++){
4 a[i] = new int[n++];
5 for(int j=0;j<n-1;j++){
6 a[i][j] = j;
7 }
8 }
9 System.out.println(Arrays.deepToString(a));
10 /*Output：
11 [[0], [0, 1], [0, 1, 2]]*/
4、数组与泛型
无法实例化具有参数化类型的数组。擦除会移除参数类型信息，而数组必须知道它们所持有的确切类型。
1 Peel<Banana>[] a = new Peel<Banana>[10];//Illegal
5、创建测试数据
（1）Arrays.fill()
1 public class Test {
2 public static void main(String[] args) {
3 int[] a = new int[3];
4 String[] b = new String[3];
5 Arrays.fill(a,6);
6 System.out.println(Arrays.toString(a));
7 Arrays.fill(b,"Hello");
8 System.out.println(Arrays.toString(b));
9 Arrays.fill(b,1,3,"World");//指定序号为1到3的位置填充“World”,不包括3
10 System.out.println(Arrays.toString(b));
11 }
12 }
13
14 /*Output：
15 [6, 6, 6]
16 [Hello, Hello, Hello]
17 [Hello, World, World]
18 */
（2）数据生成器
通过Generator来创建任何类型的数据。
6、Arrays实用功能
（1）复制数组
System.arraycopy()方法用于复制数组。需要的参数有：源数组，表示从源数组中的什么位置开始复制的偏移量，目标数组，表示从目标数组的什么位置开始复制的偏移量，以及需要复制的元素个数。
1 public class Test {
2 public static void main(String[] args) {
3 int[] a = new int[3];
4 Arrays.fill(a,3);
5 int[] b = new int[6];
6 Arrays.fill(b,6);
7 System.out.println("a：" + Arrays.toString(a));
8 System.out.println("b：" + Arrays.toString(b));
9 System.arraycopy(a,0,b,2,3);
10 System.out.println("b：" + Arrays.toString(b));
11 }
12 }
13
14 /*Output：
15 a：[3, 3, 3]
16 b：[6, 6, 6, 6, 6, 6]
17 b：[6, 6, 3, 3, 3, 6]
18 */
（2）数组的比较
Arrays.equals()方法用于数组比较。数组相等的条件是元素个数必须相等，并且对应位置的元素也相等。Arrays.deepEquals()方法用于比较两个多维数组。
1 public class Test {
2 public static void main(String[] args) {
3 String[] s1 = new String[3];
4 Arrays.fill(s1,"Hi");
5 String[] s2 = { new String("Hi"),new String("Hi"),new String("Hi")};
6 System.out.println(Arrays.equals(s1,s2));
7 }
8 }
9
10 /*Output：
11 true
12 */
（3）数组元素的比较
通过实现java.lang.Comparable接口，使类具有“天生”的比较能力。该接口只有一个compareTo()方法，此方法接收另一个Object为参数，如果当前对象小于参数则返回负值，如果相等则返回零，如果当前对象大于参数则返回正值。
1 public class Test {
2 public static void main(String[] args) {
3 Cat[] cats = new Cat[6];
4 Random rand = new Random();
5 for(int i=0;i<6;i++){
6 cats[i] = new Cat();
7 }
8 Collections.shuffle(Arrays.asList(cats),rand);
9 System.out.println("Before sort：" + Arrays.toString(cats));
10 Arrays.sort(cats,Collections.reverseOrder());
11 System.out.println("Reverse sort：" + Arrays.toString(cats));
12 }
13 }
14
15 class Cat implements Comparable<Cat>{
16 static int count = 0;
17 private final int id = count++;
18 public int getId(){ return id; }
19
20 @Override
21 public int compareTo(Cat o) {
22 int oid = o.getId();
23 return id<oid ? -1 : (id==oid ? 0 : 1);
24 }
25
26 @Override
27 public String toString() {
28 return "Cat " + id ;
29 }
30 }
31
32 /*Output：
33 Before sort：[Cat 4, Cat 2, Cat 0, Cat 3, Cat 5, Cat 1]
34 Reverse sort：[Cat 5, Cat 4, Cat 3, Cat 2, Cat 1, Cat 0]
35 */
（4）在已排序的数组中查找
如果数组已经排序好了，就可以使用Arrays.binarySearch()执行快速查找。
如果找到了目标，Arrays.binarySearch()产生的返回值等于或大于0。否则，它产生负返回值，该值表示若要保持数组的排序状态此目标元素所应该插入的位置，计算方式是：-（插入点）-1。插入点指第一个大于查找对象的元素在数组中的位置。
1 public class Test {
2 public static void main(String[] args) {
3 int[] a = {6,5,23,56,63,21,75,2,1,66};
4 System.out.println("Before sort：" + Arrays.toString(a));
5 Arrays.sort(a);
6 System.out.println("After sort：" + Arrays.toString(a));
7 int location = Arrays.binarySearch(a,a[3]);
8 System.out.print("Location of " + a[3] + " is " + location);
9 if(location >= 0)
10 System.out.print(", a[" + location + "] = " + a[location]);
11 }
12 }
13 /*Output：
14 Before sort：[6, 5, 23, 56, 63, 21, 75, 2, 1, 66]
15 After sort：[1, 2, 5, 6, 21, 23, 56, 63, 66, 75]
16 Location of 6 is 3, a[3] = 6
17 */
参考于《Java编程思想》，第433~458页
