thinking-in-java(16) 数组

【16.1】数组有什么特殊
1）数组与其他类型容器的区别：效率，类型和保持基本类型的能力；
数组是效率最高的存储和随机访问对象引用序列的方式；
数组大小固定，容器大小可以不固定，所以这增加了弹性开销，使得ArrayList的效率比数组低很多；

【荔枝-数组与泛型容器的比较】

class BerylliumSphere {private static long counter;private final long id = counter++;public String toString() { return "Sphere " + id; }
}
// 数组和容器比较的荔枝
public class ContainerComparison {public static void main(String[] args) {// 数组BerylliumSphere[] spheres = new BerylliumSphere[10];for(int i = 0; i < 5; i++)spheres[i] = new BerylliumSphere();// Arrays.toString() 打印数组各个元素的toString()print("Arrays.toString(spheres) = " + Arrays.toString(spheres)); print("spheres[4] = " + spheres[4]);// 容器List<BerylliumSphere> sphereList = new ArrayList<BerylliumSphere>();for(int i = 0; i < 5; i++)sphereList.add(new BerylliumSphere());print("sphereList = " + sphereList);print("sphereList.get(4) = " + sphereList.get(4));int[] integers = { 0, 1, 2, 3, 4, 5 };print("Arrays.toString(integers) = " + Arrays.toString(integers));print("integers[4] = " + integers[4]);// 用一个List A存放另外一个List B的元素（另外一个List B的大小是不可变的，但一个List A， 即intList的大小是可变的 ）List<Integer> intList = new ArrayList<Integer>(Arrays.asList(0, 1, 2, 3, 4, 5));intList.add(97);print("intList = " + intList);print("intList.get(4) = " + intList.get(4));}
}
/*
Arrays.toString(spheres) = [Sphere 0, Sphere 1, Sphere 2, Sphere 3, Sphere 4, null, null, null, null, null]
spheres[4] = Sphere 4
sphereList = [Sphere 5, Sphere 6, Sphere 7, Sphere 8, Sphere 9]
sphereList.get(4) = Sphere 9
Arrays.toString(integers) = [0, 1, 2, 3, 4, 5]
integers[4] = 4
intList = [0, 1, 2, 3, 4, 5, 97]
intList.get(4) = 4
*/

2）随着自动包装机制的出现，容器可以和数组一样存储基本数据类型；数组的优点仅仅是效率；

【16.2】数组是第一级对象
1）只读成员length：数组对象的一部分，表示数组对象可以存储多少元素（length 是数组唯一可访问的字段）；
2）[]语法：是访问数组对象唯一的方式；
3）唯一区别：对象数组保存的是引用，基本类型数组保存基本类型的值；

【荔枝-初始化数组的方式】

// 对象数组和基本类型数组的比较荔枝
public class ArrayOptions {public static void main(String[] args) {// 对象数组BerylliumSphere[] a; // 本地未初始化BerylliumSphere[] b = new BerylliumSphere[5];// 数组中的引用自动初始化为 nullprint("BerylliumSphere[] b = new BerylliumSphere[5]; Arrays.toString(b) = " + Arrays.toString(b));BerylliumSphere[] c = new BerylliumSphere[4];for(int i = 0; i < c.length; i++) // length 是数组唯一可访问的字段if(c[i] == null) c[i] = new BerylliumSphere();// 聚集初始化（在两种情况下，尾随逗号都是可选的）BerylliumSphere[] d = { new BerylliumSphere(),new BerylliumSphere(), new BerylliumSphere(),};// 动态聚集初始化（在两种情况下，尾随逗号都是可选的）a = new BerylliumSphere[]{new BerylliumSphere(), new BerylliumSphere(),};// (Trailing comma is optional in both cases) = 在两种情况下，尾随逗号都是可选的print("a.length = " + a.length);print("b.length = " + b.length);print("c.length = " + c.length);print("d.length = " + d.length);a = d;print("a = d; a.length = " + a.length);// 基本类型数组int[] e; // 空引用 //!print("e.length = " + e.length); // 编译报错：参数e 未初始化int[] f = new int[5];// 基本类型数组中的基本类型值自动初始化为 0 print("int[] f = new int[5]; Arrays.toString(f) = " + Arrays.toString(f));int[] g = new int[4];for(int i = 0; i < g.length; i++)g[i] = i*i;int[] h = { 11, 47, 93 };print("g.length = " + g.length);print("int[] h = { 11, 47, 93 }; h.length = " + h.length);e = h;print("e = h; e.length = " + e.length);e = new int[]{ 1, 2 };print("e = new int[]{ 1, 2 }; e.length = " + e.length);}
}
/*
BerylliumSphere[] b = new BerylliumSphere[5]; Arrays.toString(b) = [null, null, null, null, null]
a.length = 2
b.length = 5
c.length = 4
d.length = 3
a = d; a.length = 3
int[] f = new int[5]; Arrays.toString(f) = [0, 0, 0, 0, 0]
g.length = 4
int[] h = { 11, 47, 93 }; h.length = 3
e = h; e.length = 3
e = new int[]{ 1, 2 }; e.length = 2
*/

4）数组的小缺点： 无法知道数组中确切有多少元素，因为length是数组的大小，并不是实际保存的元素个数；
5）数组初始化策略： 初始化引用类型为null，基本类型数值型为0，字符型为 '\0'（转换为int类型时，值等于0）；布尔型为false；
6）聚集初始化： 隐式地使用 new 在堆中创建，就像数组一样；
7）聚集初始化和动态聚集初始化的区别： 聚集初始化必须在定义数组的位置调用，而动态聚集初始化可以在任意位置创建和初始化对象；

【16.3】返回一个数组
【荔枝-直接返回一个数组】

// 方法返回一个数组的荔枝（C+ 和 C++的方法不能返回一个数组而返回一个指针）
public class IceCream {private static Random rand = new Random(47);static final String[] FLAVORS = {"Chocolate", "Strawberry", "Vanilla Fudge Swirl","Mint Chip", "Mocha Almond Fudge", "Rum Raisin","Praline Cream", "Mud Pie"};public static String[] flavorSet(int n) {if(n > FLAVORS.length)throw new IllegalArgumentException("Set too big");String[] results = new String[n];boolean[] picked = new boolean[FLAVORS.length]; // 默认falsefor(int i = 0; i < n; i++) {int t;do {t = rand.nextInt(FLAVORS.length); // 产生小于 FLAVORS.length 的随机数} while(picked[t]);results[i] = FLAVORS[t]; picked[t] = true;// while(picked[t]) 和 picked[t] = true; 的写法非常经典 以确保不会重复选择！！}return results; // 返回一个 String[] 数组}public static void main(String[] args) {for(int i = 0; i < 7; i++)System.out.println(Arrays.toString(flavorSet(3)));}
}
/*
[Rum Raisin, Mint Chip, Mocha Almond Fudge]
[Chocolate, Strawberry, Mocha Almond Fudge]
[Strawberry, Mint Chip, Mocha Almond Fudge]
[Rum Raisin, Vanilla Fudge Swirl, Mud Pie]
[Vanilla Fudge Swirl, Chocolate, Mocha Almond Fudge]
[Praline Cream, Strawberry, Mocha Almond Fudge]
[Mocha Almond Fudge, Strawberry, Mint Chip]
*/

【16.4】多维数组
1）创建多维数组：对于基本类型的多维数组，可以通过使用花括号把每个向量分隔开；

【荔枝-创建多维基本类型数组】

// 荔枝-创建多维基本类型数组
public class MultidimensionalPrimitiveArray {public static void main(String[] args) {// 基本类型的多维数组 int[][] a = { { 1, 2, 3, },{ 4, 5, 6, },};// Arrays.deepToString(a), Arrays.deepToString(Array array) 可以把多维数组转换为多个 String；System.out.println(Arrays.deepToString(a));}
}
// [[1, 2, 3], [4, 5, 6]]【荔枝-使用 new关键字创建数组】
// 【荔枝-使用 new关键字创建数组】
public class ThreeDWithNew {public static void main(String[] args) {// 采用new 关键字创建 长度固定的3维基本类型数组， 默认为0 int[][][] a = new int[2][2][4];// Arrays.deepToString(Array array) 可以把多维数组转换为多个 String；System.out.println(Arrays.deepToString(a));  }
}
// [[[0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0]]]

【注意-Arrays.toString(array)是把一维数组转换为多个String；Arrays.deepToString()把多维数组转换为多个String】

2）Arrays.toString(array)与Arrays.deepToString(array)区别：
区别1：toString的输入参数既可以是基本数据类型也可以是引用类型；而deepToString的输入参数只能是引用类型（Object[]）；
区别2：toString 仅能够把一维数组转换为多个String，不能把2维度或以上维度的数组转换为多个String，对于大于等于2维以上的数组，toString只能返回其内存地址的hashcode；
相反deepToString 可以转换所有维度的数组为多个String，非常棒；

【荔枝-使用 new关键字创建数组（Arrays.toString(array)与Arrays.deepToString(array)区别）】

public class ThreeDWithNew {public static void main(String[] args) {// 采用new 关键字创建 长度固定的3维基本类型数组， 默认为0 Integer[][][] a = new Integer[2][2][4];// 1.转换3维数组：// Arrays.deepToString(Array array) 可以把多维数组转换为多个 String；System.out.println("Arrays.deepToString(a)) = " + Arrays.deepToString(a));// 注意Arrays.deepToString() 和 Arrays.toString()方法的区别System.out.println("Arrays.deepToString(a)) = " + Arrays.toString(a));// 2.转换2维数组：System.out.println("Arrays.deepToString(a[0]) = " + Arrays.deepToString(a[0]));System.out.println("Arrays.toString(a[0]) = " + Arrays.toString(a[0]));// 3.转换1维数组：System.out.println("Arrays.deepToString(a)) = " + Arrays.deepToString(a[0][0]));System.out.println("Arrays.deepToString(a)) = " + Arrays.toString(a[0][0]));}
}
/*
Arrays.deepToString(a)) = [[[null, null, null, null], [null, null, null, null]], [[null, null, null, null], [null, null, null, null]]]
Arrays.deepToString(a)) = [[[Ljava.lang.Integer;@6d06d69c, [[Ljava.lang.Integer;@70dea4e]
Arrays.deepToString(a[0]) = [[null, null, null, null], [null, null, null, null]]
Arrays.toString(a[0]) = [[Ljava.lang.Integer;@7852e922, [Ljava.lang.Integer;@4e25154f]
Arrays.deepToString(a)) = [null, null, null, null]
Arrays.deepToString(a)) = [null, null, null, null]
*/

3）粗糙数组或不规则数组：每个数组向量的长度不相同；

【荔枝-创建粗糙数组或不规则数组】

// 创建基本类型的粗糙数组，即每个数组向量的长度不相同；（也叫不规整数组）
public class RaggedArray {public static void main(String[] args) {Random rand = new Random(47);// 边长向量的3维int[][][] a = new int[rand.nextInt(7)][][];for(int i = 0; i < a.length; i++) {a[i] = new int[rand.nextInt(5)][];for(int j = 0; j < a[i].length; j++)a[i][j] = new int[rand.nextInt(5)]; // 这里的数组长度是随机的 }// Arrays.deepToString(Array array) 可以把多维数组转换为多个 String；System.out.println(Arrays.deepToString(a));}
}
// [[], [[0], [0], [0, 0, 0, 0]], [[], [0, 0], [0, 0]], [[0, 0, 0], [0], [0, 0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0], []], [[0], [], [0]]]

【荔枝-创建引用类型的粗糙数组】

// 创建引用类型的粗糙数组
public class MultidimensionalObjectArrays {public static void main(String[] args) {BerylliumSphere[][] spheres = {{ new BerylliumSphere(), new BerylliumSphere() }, // 长度为2{ new BerylliumSphere(), new BerylliumSphere(),new BerylliumSphere(), new BerylliumSphere() }, // 长度为4{ new BerylliumSphere(), new BerylliumSphere(),new BerylliumSphere(), new BerylliumSphere(),new BerylliumSphere(), new BerylliumSphere(),new BerylliumSphere(), new BerylliumSphere() }, // 长度为8};// Arrays.deepToString(Array array) 可以把多维数组转换为多个 String；System.out.println(Arrays.deepToString(spheres));}
}
/*
[[Sphere 0, Sphere 1], [Sphere 2, Sphere 3, Sphere 4, Sphere 5], -
[Sphere 6, Sphere 7, Sphere 8, Sphere 9, Sphere 10, Sphere 11, Sphere 12, Sphere 13]]
*/

【荔枝- 数组元素自动装箱】

// 数组元素自动装箱的荔枝（基本数据类型 转换为 Integer 引用类型）
public class AutoboxingArrays {public static void main(String[] args) {// 自动装箱： int 基本数据类型 转换为 Integer 引用类型// 基本类型数组 转换为 引用类型数组 或 对象数组Integer[][] a = { { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 },{ 21, 22, 23, 24, 25, 26, 27, 28, 29},{ 51, 52, 53, 54, 55, 56, 57, 58},{ 71, 72, 73, 74, 75, 76, 77, }, // 最后的逗号 可加 也可以不加};// Arrays.deepToString(Array array) 可以把多维数组转换为多个 String；System.out.println(Arrays.deepToString(a));}
}
/*
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[21, 22, 23, 24, 25, 26, 27, 28, 29],
[51, 52, 53, 54, 55, 56, 57, 58],
[71, 72, 73, 74, 75, 76, 77]]
*/

【荔枝-运用自动装箱机制对非基本类型的对象数组进行赋值】

// 运用自动装箱机制对非基本类型的对象数组进行赋值的荔枝
public class AssemblingMultidimensionalArrays {public static void main(String[] args) {Integer[][] a;a = new Integer[3][];for(int i = 0; i < a.length; i++) {a[i] = new Integer[3];for(int j = 0; j < a[i].length; j++)a[i][j] = i * j; // 自动装箱机制}// Arrays.deepToString(Array array) 可以把多维数组转换为多个 String；System.out.println(Arrays.deepToString(a));}
}
/*
[[0, 0, 0], [0, 1, 2], [0, 2, 4]]
*/

【荔枝-Arrays.deepToString() 只能接受Object[] 类型数组，而不是接受基本类型，但基本类型的包装器类型是可以的；】

// Arrays.deepToString() 方法对基本类型数组和对象数组都起作用；
public class MultiDimWrapperArray {public static void main(String[] args) {Integer[][] a1 = { // Autoboxing， 自动装箱（基本类型 转换到 包装器对象）{ 1, 2, 3, },{ 4, 5, 6, },};Double[][][] a2 = { // Autoboxing， 自动装箱（基本类型 转换到 包装器对象）{ { 1.1, 2.2 }, { 3.3, 4.4 } },{ { 5.5, 6.6 }, { 7.7, 8.8 } },{ { 9.9, 1.2 }, { 2.3, 3.4 } },};String[][] a3 = {{ "The", "Quick", "Sly", "Fox" },{ "Jumped", "Over" },{ "The", "Lazy", "Brown", "Dog", "and", "friend" },};// Arrays.deepToString(Array array) 可以把多维数组转换为多个 String；System.out.println("a1 = " + Arrays.deepToString(a1));System.out.println("a2 = " + Arrays.deepToString(a2));System.out.println("a3 = " + Arrays.deepToString(a3));}
}
/* Arrays.deepToString() 源码： 只能接受Object[] 类型数组，而不是接受基本类型，但基本类型的包装器类型是可以的；public static String deepToString(Object[] a) {if (a == null)return "null";int bufLen = 20 * a.length;if (a.length != 0 && bufLen <= 0)bufLen = Integer.MAX_VALUE;StringBuilder buf = new StringBuilder(bufLen);deepToString(a, buf, new HashSet<Object[]>());return buf.toString();}
*/
/*
a1 = [[1, 2, 3], [4, 5, 6]]
a2 = [[[1.1, 2.2], [3.3, 4.4]], [[5.5, 6.6], [7.7, 8.8]], [[9.9, 1.2], [2.3, 3.4]]]
a3 = [[The, Quick, Sly, Fox], [Jumped, Over], [The, Lazy, Brown, Dog, and, friend]]
*/

【16.5】数组与泛型
1）数组和泛型无法很好结合：无法实例化具有参数化类型的数组；
Animal<Yaan>[] animals = new Animal<Yaan>[10]; // 这是非法的；

2）泛型擦除：会移除参数类型参数，而数组必须知道存储元素的确切类型，这就矛盾了；

3）可以参数化数组本身的类型：

class ClassParameter<T> {// 参数化方法public T[] f(T[] arg) { return arg; }
}
class MethodParameter {// 参数化方法public static <T> T[] f(T[] arg) { return arg; }
}// 荔枝-参数化数组本身的类型
public class ParameterizedArrayType {public static void main(String[] args) {Integer[] ints = { 1, 2, 3, 4, 5 };Double[] doubles = { 1.1, 2.2, 3.3, 4.4, 5.5 };Integer[] ints2 = new ClassParameter<Integer>().f(ints);Double[] doubles2 = new ClassParameter<Double>().f(doubles);ints2 = MethodParameter.f(ints);doubles2 = MethodParameter.f(doubles);}
}

注意：使用参数化方法而不使用参数化类的方便：你不必为需要应用的每种不同类型都使用一个参数去实例化这个类，并且你可以将其定义为静态的；

4）如何间接创建泛型数组：先创建非泛型数组，然后将其转换为泛型数组；

【荔枝-间接实现泛型数组的荔枝（非常经典）】

// 间接实现泛型数组的荔枝-创建非泛型数组，然后将其转型 为泛型容器类型
public class ArrayOfGenerics {@SuppressWarnings("unchecked")public static void main(String[] args) {List<String>[] ls;List[] la = new List[10];ls = (List<String>[])la; // 强制类型转换，ls[0] = new ArrayList<String>(Arrays.asList("str1, str2, str3"));// 编译时检查 报错：//! ls[1] = new ArrayList<Integer>(); // 这个的泛型是Integer，而ls被赋值为 String泛型，肯定报错啊；// The problem: List<String> is a subtype of Object// List<String> 是 Object 的子类型 ，所以赋值是可以的；Object[] objects = ls; // 编译和运行无误objects[1] = new ArrayList<Integer>(Arrays.asList(new Integer[]{1, 2, 3})); // 注意：这里居然编译和运行通过；for (int i = 0; i < objects.length; i++) {System.out.println("objects[" + i +"] = " + objects[i]);}// However, if your needs are straightforward it is// possible to create an array of generics, albeit// with an "unchecked" warning:// 但是，如果您的需求很简单，可以创建一个泛型数组，虽然有一个“未经检查”的警告：List<BerylliumSphere>[] spheres = (List<BerylliumSphere>[])new List[10];for(int i = 0; i < spheres.length; i++)spheres[i] = new ArrayList<BerylliumSphere>();}
}
/*
objects[0] = [str1, str2, str3]
objects[1] = [1, 2, 3]
objects[2] = null
objects[3] = null
objects[4] = null
objects[5] = null
objects[6] = null
objects[7] = null
objects[8] = null
objects[9] = null
*/

【荔枝-如何创建泛型数组（先创建Object[]数组，然后将其转型为泛型数组）】

// 荔枝-如何创建泛型数组（先创建Object[] 数组，然后将其转型为泛型数组）
public class ArrayOfGenericType<T> {T[] array; // OK@SuppressWarnings("unchecked") // 阻止弹出 "不受检查" 的警告信息public ArrayOfGenericType(int size) {//! array = new T[size]; // 非法， 不能创建泛型数组；// 阻止弹出 "不受检查" 的警告信息  // 但是可以创建非泛型数组Object[]，然后通过强制类型转换，转换为泛型数组；（间接创建泛型数组）array = (T[])new Object[size]; }//非法， 不能创建泛型数组；//! public <U> U[] makeArray() { return new U[10]; }
}

【16.6】创建测试数据：使用对象或数值来填充数组

【16.6.1】Arrays.fill() 方法

// 荔枝-Arrays.fill() 填充数组
public class FillingArrays {public static void main(String[] args) {int size = 6;boolean[] a1 = new boolean[size]; // boolean 布尔数组byte[] a2 = new byte[size]; // byte 字节数组 char[] a3 = new char[size]; // char 字符数组short[] a4 = new short[size]; // short 短整型数组int[] a5 = new int[size]; // int 整型数组 long[] a6 = new long[size]; // long 长整型数组float[] a7 = new float[size]; // float 浮点型数组double[] a8 = new double[size]; // double 双浮点型数组String[] a9 = new String[size]; // String 字符串数组Arrays.fill(a1, true); // 填充boolean 布尔数组print("Arrays.fill(a1, true); a1 = " + Arrays.toString(a1));Arrays.fill(a2, (byte)11); // 填充 byte 字节数组 print("Arrays.fill(a2, (byte)11); a2 = " + Arrays.toString(a2));Arrays.fill(a3, 'x'); // 填充 char 字符数组print("Arrays.fill(a3, 'x'); a3 = " + Arrays.toString(a3));Arrays.fill(a4, (short)17);  // 填充 short 短整型数组print("Arrays.fill(a4, (short)17); a4 = " + Arrays.toString(a4));Arrays.fill(a5, 19); // 填充 int 整型数组 print("Arrays.fill(a5, 19); a5 = " + Arrays.toString(a5));Arrays.fill(a6, 23); // 填充 long 长整型数组print("Arrays.fill(a6, 23); a6 = " + Arrays.toString(a6));Arrays.fill(a7, 29); // 填充 float 浮点型数组print("Arrays.fill(a7, 29); a7 = " + Arrays.toString(a7));Arrays.fill(a8, 47); // 填充 double 双浮点型数组print("Arrays.fill(a8, 47); a8 = " + Arrays.toString(a8));Arrays.fill(a9, "Hello"); // 填充 String 字符串数组print("Arrays.fill(a9, \"Hello\"); a9 = " + Arrays.toString(a9));// 这里是填充数组的某个区域Arrays.fill(a9, 3, 5, "World"); // 填充 String 字符串数组（下标3 到下标5，不包括下标5，从0开始计数）print("Arrays.fill(a9, 3, 5, \"World\"); a9 = " + Arrays.toString(a9));}
}
/*
Arrays.fill(a1, true); a1 = [true, true, true, true, true, true]
Arrays.fill(a2, (byte)11); a2 = [11, 11, 11, 11, 11, 11]
Arrays.fill(a3, 'x'); a3 = [x, x, x, x, x, x]
Arrays.fill(a4, (short)17); a4 = [17, 17, 17, 17, 17, 17]
Arrays.fill(a5, 19); a5 = [19, 19, 19, 19, 19, 19]
Arrays.fill(a6, 23); a6 = [23, 23, 23, 23, 23, 23]
Arrays.fill(a7, 29); a7 = [29.0, 29.0, 29.0, 29.0, 29.0, 29.0]
Arrays.fill(a8, 47); a8 = [47.0, 47.0, 47.0, 47.0, 47.0, 47.0]
Arrays.fill(a9, "Hello"); a9 = [Hello, Hello, Hello, Hello, Hello, Hello]
Arrays.fill(a9, 3, 5, "World"); a9 = [Hello, Hello, Hello, World, World, Hello]
*/

【16.6.2】数据生成器
1）策略模式来填充数组：通过选择Generator的类型来创建任何类型的数据，每个不同Generator都表示不同的策略；

【荔枝-通过静态内部类实现数据生成器】

// 通过静态内部类实现 数据生成器
public class CountingGenerator {// 通过静态内部类实现public static class Boolean implements Generator<java.lang.Boolean> {private boolean value = false;public java.lang.Boolean next() {value = !value; // Just flips back and forthreturn value;}}public static class Byte implements Generator<java.lang.Byte> {private byte value = 0;public java.lang.Byte next() {return value++;}}static char[] chars = ("abcdefghijklmnopqrstuvwxyz"+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();public static class Character implements Generator<java.lang.Character> {int index = -1;public java.lang.Character next() {index = (index + 1) % chars.length;return chars[index];}}public static class String implements Generator<java.lang.String> {private int length = 7;Generator<java.lang.Character> cg = new Character();public String() {}public String(int length) {this.length = length;}public java.lang.String next() {char[] buf = new char[length];for (int i = 0; i < length; i++)buf[i] = cg.next(); // 通过字符生成字符串return new java.lang.String(buf);}}public static class Short implements Generator<java.lang.Short> {private short value = 0;public java.lang.Short next() {return value++;}}public static class Integer implements Generator<java.lang.Integer> {private int value = 0;public java.lang.Integer next() {return value++;}}public static class Long implements Generator<java.lang.Long> {private long value = 0;public java.lang.Long next() {return value++;}}public static class Float implements Generator<java.lang.Float> {private float value = 0;public java.lang.Float next() {float result = value;value += 1.0;return result;}}public static class Double implements Generator<java.lang.Double> {private double value = 0.0;public java.lang.Double next() {double result = value;value += 1.0;return result;}}
}

【数据生成器的测试荔枝-通过策略模式来填充数组】

// 数据生成器的测试荔枝-策略模式来填充数组，其中利用反射机制来获取 Class类实例数组
public class GeneratorsTest {public static int size = 10;public static void test(Class<?> surroundingClass) {// surroundingClass.getClasses() 获取 Class类对应的内部类的Class类实例数组for(Class<?> type : surroundingClass.getClasses()) {System.out.print(type.getSimpleName() + ": ");try {// 传入Class类信息，利用反射机制创建数据生成器Generator<?> g = (Generator<?>)type.newInstance(); for(int i = 0; i < size; i++)System.out.printf(g.next() + " ");System.out.println();} catch(Exception e) {throw new RuntimeException(e);}}}public static void main(String[] args) {test(CountingGenerator.class);}
}
/* Output:
Double: 0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
Float: 0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
Long: 0 1 2 3 4 5 6 7 8 9
Integer: 0 1 2 3 4 5 6 7 8 9
Short: 0 1 2 3 4 5 6 7 8 9
String: abcdefg hijklmn opqrstu vwxyzAB CDEFGHI JKLMNOP QRSTUVW XYZabcd efghijk lmnopqr
Character: a b c d e f g h i j
Byte: 0 1 2 3 4 5 6 7 8 9
Boolean: true false true false true false true false true false
*/

【荔枝-利用Random 创建随机数据生成器的荔枝】

// 利用Random 创建随机数据生成器的荔枝
public class RandomGenerator {private static Random r = new Random(47);public static class Boolean implements Generator<java.lang.Boolean> {public java.lang.Boolean next() {return r.nextBoolean();}}public static class Byte implements Generator<java.lang.Byte> {public java.lang.Byte next() {return (byte)r.nextInt(); // 调用的是 Random.nextInt()}}public static class Character implements Generator<java.lang.Character> {public java.lang.Character next() {// // 调用的是 Random.nextInt()return CountingGenerator.chars[r.nextInt(CountingGenerator.chars.length)];}}// 该 RandomGenerator.String 继承自 CountingGenerator.String 类 （内部类继承机制）public static class String extends CountingGenerator.String {// Plug in the random Character generator:{ cg = new Character(); } // Instance initializerpublic String() {}public String(int length) { super(length); }}public static class Short implements Generator<java.lang.Short> {public java.lang.Short next() {return (short)r.nextInt(); // 调用的是 Random.nextInt()}}public static class Integer implements Generator<java.lang.Integer> {private int mod = 10000;public Integer() {}public Integer(int modulo) { mod = modulo; }public java.lang.Integer next() {return r.nextInt(mod); // 调用的是 Random.nextInt()}}public static class Long implements Generator<java.lang.Long> {private int mod = 10000;public Long() {}public Long(int modulo) { mod = modulo; }public java.lang.Long next() {return new java.lang.Long(r.nextInt(mod)); // 调用的是 Random.nextInt()}}public static class Float implements Generator<java.lang.Float> {public java.lang.Float next() {// Trim all but the first two decimal places:int trimmed = Math.round(r.nextFloat() * 100); // 调用的是 Random.nextFloat()return ((float)trimmed) / 100;}}public static class Double implements Generator<java.lang.Double> {public java.lang.Double next() {long trimmed = Math.round(r.nextDouble() * 100); // 调用的是 Random.nextFloat()return ((double)trimmed) / 100;}}
}
/* Random.next*() 方法列表有：
protected int next(int bits) {
public void nextBytes(byte[] bytes) {
final long internalNextLong(long origin, long bound) {public int nextInt() {return next(32); // next(bits=32)
}public long nextLong() {
public boolean nextBoolean() {
public float nextFloat() {
public double nextDouble() {
*/

【随机数据生成器的测试荔枝-】

// 测试荔枝-利用随机数据生成器填充数组
public class RandomGeneratorsTest {public static void main(String[] args) {GeneratorsTest.test(RandomGenerator.class);}
}
/*
Double: 0.73 0.53 0.16 0.19 0.52 0.27 0.26 0.05 0.8 0.76
Float: 0.53 0.16 0.53 0.4 0.49 0.25 0.8 0.11 0.02 0.8
Long: 7674 8804 8950 7826 4322 896 8033 2984 2344 5810
Integer: 8303 3141 7138 6012 9966 8689 7185 6992 5746 3976
Short: 3358 20592 284 26791 12834 -8092 13656 29324 -1423 5327
String: bkInaMe sbtWHkj UrUkZPg wsqPzDy CyRFJQA HxxHvHq XumcXZJ oogoYWM NvqeuTp nXsgqia
Character: x x E A J J m z M s
Byte: -60 -17 55 -14 -5 115 39 -37 79 115
Boolean: false true false false true true true true true true
*/

【16.6.3】从Generator中创建数组

1）为了接受Generator 作为输入参数并产生数组，需要两个转换工具：
工具1）填充已有数组：接受一个已有数组a，并使用Generator 来填充该数组（填充已有数组）
工具2）创建新数组并填充：接受一个 Class对象和数组大小来创建一个新数组，并用 Generator来填充该数组（创建新数组并填充）

// 荔枝-从Generator中创建数组
public class Generated {// 方法1：接受一个已有数组a，并使用Generator 来填充该数组（填充已有数组）public static <T> T[] array(T[] a, Generator<T> gen) {return new CollectionData<T>(gen, a.length).toArray(a);}@SuppressWarnings("unchecked")// 方法2：接受一个 Class对象 和 数组大小 来创建一个新数组，并用 Generator来填充该数组（创建新数组并填充）public static <T> T[] array(Class<T> type, Generator<T> gen, int size) {// 利用反射创建对象数组，全部赋值为 nullT[] a = (T[])java.lang.reflect.Array.newInstance(type, size);for ( T t : a ) {System.out.println("t = " + t);}return new CollectionData<T>(gen, size).toArray(a);}public static void main(String[] args) {Integer[] array = array(Integer.class, new RandomGenerator.Integer(), 5);System.out.println("after filling by generator, Arrays.toString(array) = " + Arrays.toString(array));}
}
/*
t = null
t = null
t = null
t = null
t = null
after filling by generator, Arrays.toString(array) = [9258, 555, 6693, 1861, 961]
*/

【测试荔枝-从Generator中创建数组的两个转换工具】

// 测试荔枝-从Generator中创建数组的两个转换工具
public class TestGenerated {public static void main(String[] args) {Integer[] a = { 9, 8, 7, 6 };System.out.println(Arrays.toString(a));a = Generated.array(a,new CountingGenerator.Integer());System.out.println("a = " + Arrays.toString(a));  Integer[] b = Generated.array(Integer.class, new CountingGenerator.Integer(), 15);System.out.println("b = " + Arrays.toString(b));  }
}
/*
[9, 8, 7, 6]
a = [0, 1, 2, 3]
t = null
t = null
t = null
t = null
t = null
t = null
t = null
t = null
t = null
t = null
t = null
t = null
t = null
t = null
t = null
b = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
*/

2）数组类型转换器：该转换器可以接收任意的包装器对象数组，并将其转换为相应的基本类型数组；

【荔枝-为基本类型创建生成器】

// 荔枝-为基本类型创建生成器
public class ConvertTo {// Boolean 类型转基本类型 booleanpublic static boolean[] primitive(Boolean[] in) {boolean[] result = new boolean[in.length];for(int i = 0; i < in.length; i++)result[i] = in[i]; // 自动拆箱return result;}// Character 类型转基本类型 charpublic static char[] primitive(Character[] in) {char[] result = new char[in.length];for(int i = 0; i < in.length; i++)result[i] = in[i]; // 自动拆箱return result;}//Byte 类型转基本类型 bytepublic static byte[] primitive(Byte[] in) {byte[] result = new byte[in.length];for(int i = 0; i < in.length; i++)result[i] = in[i]; // 自动拆箱return result;}//Short 类型转基本类型 shortpublic static short[] primitive(Short[] in) {short[] result = new short[in.length];for(int i = 0; i < in.length; i++)result[i] = in[i]; // 自动拆箱return result;}//Integer 类型转基本类型 intpublic static int[] primitive(Integer[] in) {int[] result = new int[in.length];for(int i = 0; i < in.length; i++)result[i] = in[i]; // 自动拆箱return result;}//Long 类型转基本类型 longpublic static long[] primitive(Long[] in) {long[] result = new long[in.length];for(int i = 0; i < in.length; i++)result[i] = in[i]; // 自动拆箱return result;}// Float 类型转基本类型 floatpublic static float[] primitive(Float[] in) {float[] result = new float[in.length];for(int i = 0; i < in.length; i++)result[i] = in[i]; // 自动拆箱return result;}//Double 类型转基本类型 doublepublic static double[] primitive(Double[] in) {double[] result = new double[in.length];for(int i = 0; i < in.length; i++)result[i] = in[i]; // 自动拆箱return result;}
}

【ConvertTo()的测试荔枝1-如何把 ConvertTo（为基本类型创建生成器）应用于 array(Class<T> type, Generator<T> gen, int size) 方法上】

// 荔枝-如何把 ConvertTo（为基本类型创建生成器） 应用于 array(Class<T> type, Generator<T> gen, int size)  方法上
public class PrimitiveConversionDemonstration {public static void main(String[] args) {Integer[] a = Generated.array(Integer.class, new CountingGenerator.Integer(), 15);int[] b = ConvertTo.primitive(a);System.out.println("int[] b = ConvertTo.primitive(a); b = " + Arrays.toString(b));boolean[] c = ConvertTo.primitive(Generated.array(Boolean.class, new CountingGenerator.Boolean(), 7));System.out.println("boolean[] c = ConvertTo.primitive(Generated.array(Boolean.class, new CountingGenerator.Boolean(), 7)); \n c = " + Arrays.toString(c));}
}
/*
int[] b = ConvertTo.primitive(a); b = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
boolean[] c = ConvertTo.primitive(Generated.array(Boolean.class, new CountingGenerator.Boolean(), 7)); c = [true, false, true, false, true, false, true]
*/

【ConvertTo()的测试荔枝2-如何把 ConvertTo（为基本类型创建生成器）应用于 array(Class<T> type, Generator<T> gen, int size) 方法上】

//荔枝-如何把 ConvertTo（为基本类型创建生成器） 应用于 array(Class<T> type, Generator<T> gen, int size) 方法上
public class TestArrayGeneration {public static void main(String[] args) {int size = 6;boolean[] a1 = ConvertTo.primitive(Generated.array(Boolean.class, new RandomGenerator.Boolean(), size));print("a1 = " + Arrays.toString(a1));byte[] a2 = ConvertTo.primitive(Generated.array(Byte.class, new RandomGenerator.Byte(), size));print("a2 = " + Arrays.toString(a2));char[] a3 = ConvertTo.primitive(Generated.array(Character.class, new RandomGenerator.Character(), size));print("a3 = " + Arrays.toString(a3));short[] a4 = ConvertTo.primitive(Generated.array(Short.class, new RandomGenerator.Short(), size));print("a4 = " + Arrays.toString(a4));int[] a5 = ConvertTo.primitive(Generated.array(Integer.class, new RandomGenerator.Integer(), size));print("a5 = " + Arrays.toString(a5));long[] a6 = ConvertTo.primitive(Generated.array(Long.class, new RandomGenerator.Long(), size));print("a6 = " + Arrays.toString(a6));float[] a7 = ConvertTo.primitive(Generated.array(Float.class, new RandomGenerator.Float(), size));print("a7 = " + Arrays.toString(a7));double[] a8 = ConvertTo.primitive(Generated.array(Double.class, new RandomGenerator.Double(), size));print("a8 = " + Arrays.toString(a8));}
}
/*
a1 = [true, false, true, false, false, true]
a2 = [104, -79, -76, 126, 33, -64]
a3 = [Z, n, T, c, Q, r]
a4 = [-13408, 22612, 15401, 15161, -28466, -12603]
a5 = [7704, 7383, 7706, 575, 8410, 6342]
a6 = [7674, 8804, 8950, 7826, 4322, 896]
a7 = [0.01, 0.2, 0.4, 0.79, 0.27, 0.45]
a8 = [0.16, 0.87, 0.7, 0.66, 0.87, 0.59]
*/

【16.7】Arrays实用功能

1）7个Arrays的基本方法：
equals()：用于比较两个数组是否相等；
deepEquals()：用于比较两个多维数组是否相等；
fill()：填充数组；
sort()：对数组排序；
binarySearch()：在有序的数组中查找元素；
toString()：产生数组的String表示；
hashCode()：产生数组的 hash code 散列码；

以上方法都对各种基本类型和Object类重载过；

Arrays.asList()：接受任意序列或数组作为其参数，并将其转变为 List 容器；

【16.7.1】复制数组（System.arraycopy()）
1）System.arraycopy()：用于复制数组，该方法对所有类型做了重载；

【荔枝-使用arraycopy() 复制数组】

// 荔枝-使用 System.arraycopy() 进行数组拷贝
public class CopyingArrays {public static void main(String[] args) {int[] i = new int[7];int[] j = new int[10];Arrays.fill(i, 47);Arrays.fill(j, 99);print("Arrays.fill(i, 47); i = " + Arrays.toString(i)); // i = [47, 47, 47, 47, 47, 47, 47]print("Arrays.fill(j, 99); j = " + Arrays.toString(j)); // j = [99, 99, 99, 99, 99, 99, 99, 99, 99, 99]// System.arraycopy(i, 0, j, 0, i.length); 复制数组i从0到i.length(不包括)的元素 到 数组j（j从位置0开始存储）System.arraycopy(i, 0, j, 0, i.length);// j = [47, 47, 47, 47, 47, 47, 47, 99, 99, 99]print("System.arraycopy(i, 0, j, 0, i.length); j = " + Arrays.toString(j)); int[] k = new int[5];Arrays.fill(k, 103);System.arraycopy(i, 0, k, 0, k.length);// k = [47, 47, 47, 47, 47]print("Arrays.fill(k, 103); System.arraycopy(i, 0, k, 0, k.length); k = " + Arrays.toString(k));Arrays.fill(k, 103);System.arraycopy(k, 0, i, 0, k.length); // 复制数组k[0,length-1] 到 数组i[0,length-]// i = [103, 103, 103, 103, 103, 47, 47]print("Arrays.fill(k, 103); System.arraycopy(k, 0, i, 0, k.length); i = " + Arrays.toString(i));// 对象数组Integer[] u = new Integer[10];Integer[] v = new Integer[5];Arrays.fill(u, new Integer(47));Arrays.fill(v, new Integer(99));// u = [47, 47, 47, 47, 47, 47, 47, 47, 47, 47]print("Arrays.fill(u, new Integer(47)); u = " + Arrays.toString(u));// v = [99, 99, 99, 99, 99]print("Arrays.fill(v, new Integer(99)); v = " + Arrays.toString(v));System.arraycopy(v, 0, u, u.length/2, v.length);// u = [47, 47, 47, 47, 47, 99, 99, 99, 99, 99]print("System.arraycopy(v, 0, u, u.length/2, v.length); u = " + Arrays.toString(u));}
}
/*
Arrays.fill(i, 47); i = [47, 47, 47, 47, 47, 47, 47]
Arrays.fill(j, 99); j = [99, 99, 99, 99, 99, 99, 99, 99, 99, 99]
System.arraycopy(i, 0, j, 0, i.length); j = [47, 47, 47, 47, 47, 47, 47, 99, 99, 99]
Arrays.fill(k, 103); System.arraycopy(i, 0, k, 0, k.length); k = [47, 47, 47, 47, 47]
Arrays.fill(k, 103); System.arraycopy(k, 0, i, 0, k.length); i = [103, 103, 103, 103, 103, 47, 47]
Arrays.fill(u, new Integer(47)); u = [47, 47, 47, 47, 47, 47, 47, 47, 47, 47]
Arrays.fill(v, new Integer(99)); v = [99, 99, 99, 99, 99]
System.arraycopy(v, 0, u, u.length/2, v.length); u = [47, 47, 47, 47, 47, 99, 99, 99, 99, 99]
*/

【注意】arraycopy()方法不会执行自动包装和自动拆包，两个数组必须具有相同的确切类型；

【16.7.2】数组比较（equals()方法）
1）数组相等的条件：数组元素个数必须相等，数组对应位置的元素也相等；
2）对于基本类型：需要使用基本类型的包装器类的 equals()方法，如对int类型使用 Integer.equals()做比较；

【荔枝-数组比较】

// 荔枝-数组比较
public class ComparingArrays {public static void main(String[] args) {int[] a1 = new int[10];int[] a2 = new int[10];Arrays.fill(a1, 47);Arrays.fill(a2, 47);print(Arrays.equals(a1, a2)); // true： a1 与 a2 相等a2[3] = 11; // 修改数组a2的某个元素print(Arrays.equals(a1, a2)); // false： a1 与 a2 不相等String[] s1 = new String[4];Arrays.fill(s1, "Hi"); String[] s2 = { new String("Hi"), new String("Hi"), new String("Hi"), new String("Hi") };print(Arrays.equals(s1, s2)); // true： s1 与 s2 相等// 其实从 Arrays.equals(s1, s2) = true，可以看出 Arrays.equals() 比较的是 值是否相等，而不是引用是否相等}
}
/* Arrays.equals(Object a, Object a2) 源码
public static boolean equals(Object[] a, Object[] a2) {if (a==a2)return true;if (a==null || a2==null)return false;int length = a.length;if (a2.length != length)return false;for (int i=0; i<length; i++) {Object o1 = a[i];Object o2 = a2[i];if (!(o1==null ? o2==null : o1.equals(o2)))return false;}return true;
}
*/

【16.7.3】数组元素比较
1）使用策略模式进行比较：把会发生变化的代码封装在单独的类中（比较策略），然后把策略模式对象传递给总是相同的代码，然后这些代码再使用策略模式对象来完成其比较；
2）java有两种方式提供比较功能：
方式1）实现 java.lang.Comparable 接口，实现类有比较能力；
方式2）创建一个Comparator接口的实现类来实现比较；

【方式1 荔枝-实现Comparable接口来比较】

// 使用策略模式，将策略对象传递给相同代码，这些代码使用策略来完成算法。
// 荔枝-java的两种比较方式，一是实现 Comparable接口
public class CompType implements Comparable<CompType> {int i;int j;private static int count = 1;public CompType(int n1, int n2) {i = n1;j = n2;}public String toString() {String result = "[i = " + i + ", j = " + j + "]";if(count++ % 3 == 0)result += "\n";return result;}// 这里的比较策略只用到了 属性i，没有属性jpublic int compareTo(CompType rv) {return (i < rv.i ? -1 : (i == rv.i ? 0 : 1));}private static Random r = new Random(47);public static Generator<CompType> generator() {return new Generator<CompType>() { // 匿名内部类public CompType next() {return new CompType(r.nextInt(100),r.nextInt(100));}};}public static void main(String[] args) {CompType[] a = Generated.array(new CompType[12], generator());print("Arrays.toString(a) = " + Arrays.toString(a));Arrays.sort(a);print("Arrays.sort(a); Arrays.toString(a) = " + Arrays.toString(a));}
}
/* Arrays.sort() 源码
public static void sort(Object[] a) {if (LegacyMergeSort.userRequested)legacyMergeSort(a);elseComparableTimSort.sort(a, 0, a.length, null, 0, 0);
}
*/
/* 打印结果
Arrays.toString(a) = [[i = 58, j = 55], [i = 93, j = 61], [i = 61, j = 29]
, [i = 68, j = 0], [i = 22, j = 7], [i = 88, j = 28]
, [i = 51, j = 89], [i = 9, j = 78], [i = 98, j = 61]
, [i = 20, j = 58], [i = 16, j = 40], [i = 11, j = 22]
]
Arrays.sort(a); Arrays.toString(a) = [[i = 9, j = 78], [i = 11, j = 22], [i = 16, j = 40]
, [i = 20, j = 58], [i = 22, j = 7], [i = 51, j = 89]
, [i = 58, j = 55], [i = 61, j = 29], [i = 68, j = 0]
, [i = 88, j = 28], [i = 93, j = 61], [i = 98, j = 61]
]
*/

【注意】如果没有实现 Comparable 接口，调用sort()方法的时候会抛出 ClassCastException 运行时异常。因为sort()方法需要把参数类型转变为 Comparable；

/* java.lang.Comparable接口源码
public interface Comparable<T> {public int compareTo(T o);
}
*/

3）Collections类包含一个 reverseOrder()方法，产生一个 Comparator实现类，以反转自然的排序顺序；

【方式2-荔枝-以反转自然的排序顺序对数组排序】

// 荔枝-以反转自然的排序顺序对数组排序
public class Reverse {public static void main(String[] args) {CompType[] a = Generated.array(new CompType[12], CompType.generator());print("Arrays.toString(a) = " + Arrays.toString(a));// CompType类的排序规则是 按照属性 i 升序排序的。Arrays.sort(a); // 第 1 次排序print("Arrays.sort(a); Arrays.toString(a) = " + Arrays.toString(a));// Collections.reverseOrder() 反转自然的排序顺序（ 按照属性 i 降序排序的。）Arrays.sort(a, Collections.reverseOrder()); // 第 2 次排序 print("Arrays.sort(a, Collections.reverseOrder()); Arrays.toString(a) = " + Arrays.toString(a));}
}
/* Arrays.sort(T[] a, Comparator<? super T> c) 源码public static <T> void sort(T[] a, Comparator<? super T> c) {if (c == null) {sort(a);} else {if (LegacyMergeSort.userRequested)legacyMergeSort(a, c);elseTimSort.sort(a, 0, a.length, c, null, 0, 0);}
}
*/
/* 打印结果
// 1.原始的数组是乱序的
Arrays.toString(a) = [[i = 58, j = 55], [i = 93, j = 61], [i = 61, j = 29]
, [i = 68, j = 0], [i = 22, j = 7], [i = 88, j = 28]
, [i = 51, j = 89], [i = 9, j = 78], [i = 98, j = 61]
, [i = 20, j = 58], [i = 16, j = 40], [i = 11, j = 22]
]
// 2.按照i 升序排序
Arrays.sort(a); Arrays.toString(a) = [[i = 9, j = 78], [i = 11, j = 22], [i = 16, j = 40]
, [i = 20, j = 58], [i = 22, j = 7], [i = 51, j = 89]
, [i = 58, j = 55], [i = 61, j = 29], [i = 68, j = 0]
, [i = 88, j = 28], [i = 93, j = 61], [i = 98, j = 61]
]
// 3.按照i 降序排序
Arrays.sort(a, Collections.reverseOrder()); Arrays.toString(a) = [[i = 98, j = 61], [i = 93, j = 61], [i = 88, j = 28]
, [i = 68, j = 0], [i = 61, j = 29], [i = 58, j = 55]
, [i = 51, j = 89], [i = 22, j = 7], [i = 20, j = 58]
, [i = 16, j = 40], [i = 11, j = 22], [i = 9, j = 78]
]
*/
/* Collections.reverseOrder() 源码：@SuppressWarnings("unchecked")
public static <T> Comparator<T> reverseOrder() {return (Comparator<T>) ReverseComparator.REVERSE_ORDER;
}
ReverseComparator 源码
private static class ReverseComparatorimplements Comparator<Comparable<Object>>, Serializable {private static final long serialVersionUID = 7207038068494060240L;static final ReverseComparator REVERSE_ORDER= new ReverseComparator();public int compare(Comparable<Object> c1, Comparable<Object> c2) {return c2.compareTo(c1);}private Object readResolve() { return Collections.reverseOrder(); }@Overridepublic Comparator<Comparable<Object>> reversed() {return Comparator.naturalOrder();}
}
*/
/*
*/

【方式2-荔枝-自定义 Comparator 对数组排序（通过实现 Comparator接口来实现）】

// 自定义排序规则的荔枝（通过实现 Comparator接口来实现）
class CompTypeComparator implements Comparator<CompType> {// 排序规则： 按照  j 进行升序排序public int compare(CompType o1, CompType o2) { return (o1.j < o2.j ? -1 : (o1.j == o2.j ? 0 : 1));}
}public class ComparatorTest {public static void main(String[] args) {CompType[] a = Generated.array(new CompType[12], CompType.generator());print("Arrays.toString(a) = " + Arrays.toString(a));Arrays.sort(a, new CompTypeComparator()); // 通过实现 Comparator接口来自定义排序规则对数组排序print("Arrays.sort(a, new CompTypeComparator()); Arrays.toString(a) = " + Arrays.toString(a));}
}
/*
// 1.数组乱序
Arrays.toString(a) = [[i = 58, j = 55], [i = 93, j = 61], [i = 61, j = 29]
, [i = 68, j = 0], [i = 22, j = 7], [i = 88, j = 28]
, [i = 51, j = 89], [i = 9, j = 78], [i = 98, j = 61]
, [i = 20, j = 58], [i = 16, j = 40], [i = 11, j = 22]
]
//  2.按照    j 进行升序排序
Arrays.sort(a, new CompTypeComparator()); Arrays.toString(a) = [[i = 68, j = 0], [i = 22, j = 7], [i = 11, j = 22]
, [i = 88, j = 28], [i = 61, j = 29], [i = 16, j = 40]
, [i = 58, j = 55], [i = 20, j = 58], [i = 93, j = 61]
, [i = 98, j = 61], [i = 9, j = 78], [i = 51, j = 89]
]
*/

【总结】Comparable 与 Comparator的区别：
区别1）重写的方法不同：

实现 Comparable接口：需要重写 public int compareTo(T o) 方法；需要比较的对象作为 Comparable实现类；
实现 Comparator接口：需要重写 int compare(T o1, T o2) 方法；需要比较的对象并不作为 Comparator实现类，而是其他的比较策略对象作为 Comparator实现类；

区别2）实现方式不同：

通过实现 Comparable 接口这种方式实现数组比较的特点： 将需要比较的对象与比较方法的实现代码揉在一起；

通过实现 Comparator 接口这种方式实现数组比较的优点： 将需要比较的对象与比较方法的实现代码分离开；

区别3）最大的区别：基本类型数组无法使用 Comparator 进行排序；

【16.7.4】数组排序
1）数组排序的前提条件：该对象实现了 Comparable 接口或有相关联的 Comparator ；

【荔枝-基于多种排序策略对数组排序】

// 荔枝-基于多种排序策略对数组排序
public class StringSorting {public static void main(String[] args) {String[] sa = Generated.array(new String[20], new RandomGenerator.String(5));print("\nArrays.toString(sa) = " + Arrays.toString(sa));Arrays.sort(sa); // 自然排序print("\nArrays.sort(sa); Arrays.toString(sa) = " + Arrays.toString(sa));Arrays.sort(sa, Collections.reverseOrder()); // 逆序print("\nArrays.sort(sa, Collections.reverseOrder());  Arrays.toString(sa) = " + Arrays.toString(sa));Arrays.sort(sa, String.CASE_INSENSITIVE_ORDER); // 忽略大小写敏感print("\nArrays.sort(sa, String.CASE_INSENSITIVE_ORDER); Arrays.toString(sa) = " + Arrays.toString(sa));}
}
/*
//1.原始数组
Arrays.toString(sa) = [YNzbr, nyGcF, OWZnT, cQrGs, eGZMm, JMRoE, suEcU, OneOE, dLsmw, HLGEa, hKcxr, EqUCB, bkIna, Mesbt, WHkjU, rUkZP, gwsqP, zDyCy, RFJQA, HxxHv]
//2.自然排序后的数组
Arrays.sort(sa); Arrays.toString(sa) = [EqUCB, HLGEa, HxxHv, JMRoE, Mesbt, OWZnT, OneOE, RFJQA, WHkjU, YNzbr, bkIna, cQrGs, dLsmw, eGZMm, gwsqP, hKcxr, nyGcF, rUkZP, suEcU, zDyCy]
//3.自然逆序排序后的数组
Arrays.sort(sa, Collections.reverseOrder());  Arrays.toString(sa) = [zDyCy, suEcU, rUkZP, nyGcF, hKcxr, gwsqP, eGZMm, dLsmw, cQrGs, bkIna, YNzbr, WHkjU, RFJQA, OneOE, OWZnT, Mesbt, JMRoE, HxxHv, HLGEa, EqUCB]
//4.大小写不敏感的自然排序后的数组
Arrays.sort(sa, String.CASE_INSENSITIVE_ORDER); Arrays.toString(sa) = [bkIna, cQrGs, dLsmw, eGZMm, EqUCB, gwsqP, hKcxr, HLGEa, HxxHv, JMRoE, Mesbt, nyGcF, OneOE, OWZnT, RFJQA, rUkZP, suEcU, WHkjU, YNzbr, zDyCy]
*/

【注意】 String 排序算法依据词典编排顺序排序，所以大写字母开头的词都排在前面，小写字母的词排在后面；（因为大写字母的ASCII码小于小写字母的 ASCII码）
【干货】java标准类库中的排序算法对正排序的特殊类型进行了优化：针对基本类型设计的快速排序或针对对象设计的稳定归并排序。不需要担心java对数组的排序性能；

【16.7.5】在已排序的数组中查找（Arrays.binarySearch() 二分查找）
【荔枝-Arrays.binarySearch() 对有序数组进行二分查找】

// 荔枝-Arrays.binarySearch() 对有序数组进行二分查找
public class ArraySearching {public static void main(String[] args) {Generator<Integer> gen = new RandomGenerator.Integer(1000);// 利用随机数据生成器 产生Integer包装器数组并 转换为 int基本类型数组int[] a = ConvertTo.primitive(Generated.array(new Integer[25], gen));Arrays.sort(a); // 自然排序print("Arrays.sort(a); Arrays.toString(a) = " + Arrays.toString(a));while(true) {int r = gen.next();// Arrays.binarySearch(a, r); 在有序数组a中二分查找 rint location = Arrays.binarySearch(a, r); if(location >= 0) {print("Location of " + r + " is " + location +", a[" + location + "] = " + a[location]);break; }}}
}
/*
Sorted array: [128, 140, 200, 207, 258, 258, 278, 288, 322, 429, 511, 520, 522, 551, 555, 589, 693, 704, 809, 861, 861, 868, 916, 961, 998]
Location of 322 is 8, a[8] = 322
*/

1）Arrays.binarySearch()： 如果找到了目标，Arrays.binarySearch()产生的返回值等于或大于0；否则，返回值为负值，表示若要保持数组有序，该目标元素应该插入的位置；
2）上述负值计算方式： - (插入点) - 1；插入点指的是，第一个大于查找对象的元素在数组中的位置，如果数组中的所有元素都小于目标元素，则插入点就是 a.size();

3）如果使用 Comparator 排序了某个对象数组（基本类型数组无法使用 Comparator 进行排序），在使用 binarySearch() 时也必须提供同样的 Comparator；

// 荔枝-为二分查找 Arrays.binarySearch 设置排序规则
public class AlphabeticSearch {public static void main(String[] args) {String[] sa = Generated.array(new String[30], new RandomGenerator.String(5));Arrays.sort(sa, String.CASE_INSENSITIVE_ORDER); // 大小写不敏感System.out.println("Arrays.sort(sa, String.CASE_INSENSITIVE_ORDER); \nArrays.toString(sa) = " + Arrays.toString(sa));System.out.println("sa[10] = " + sa[10]);// 通过二分查找 查找出 sa[10] 元素的位置，其中排序规则同 Arrays.sort(sa) 的排序规则 String.CASE_INSENSITIVE_ORDER，否则报错int index = Arrays.binarySearch(sa, sa[10], String.CASE_INSENSITIVE_ORDER);System.out.println("Index: "+ index + "\n"+ sa[index]);}
}
/*
Arrays.sort(sa, String.CASE_INSENSITIVE_ORDER);
Arrays.toString(sa) = [bkIna, cQrGs, cXZJo, dLsmw, eGZMm, EqUCB, gwsqP, hKcxr, HLGEa, HqXum, HxxHv, JMRoE, JmzMs, Mesbt, MNvqe, nyGcF, ogoYW, OneOE, OWZnT, RFJQA, rUkZP, sgqia, slJrL, suEcU, uTpnX, vpfFv, WHkjU, xxEAJ, YNzbr, zDyCy]
Index: 10
HxxHv
*/

【16.8】总结

1）使用容器来代替数组： 有了额外的自动包装机制和泛型，在容器中持有基本类型就很容易了。这也促使使用容器而不是数组。因为泛型可以产生类型安全的容器；

2）优先容器而不是数组：只有在已证明性能称为问题，并且切换到数组对性能有提高时，你才应该将程序重构为使用数组；

thinking-in-java(16) 数组相关推荐

java学习总结（16.06.03）java中数组的定义和初始化
刚开始接触java的数组时,我觉得java的数组和c++的数组虽然大致上差不多但细节上差很多,我也因此差点混乱了.后来自己仔细理了一下发现java和c++的数组只在定义和初始化上存在几点差异,而其他部 ...
紧随Java 16，Spring Framework 5.3.5 发布：涵盖JDK 16的支持！
昨天小编刚给大家介绍过最新的Spring Boot 2.4.4.Spring Cloud 2020.0.2 发布内容,还没看过的小伙伴点这里:Spring Boot 2.4.4.Spring Clou ...
Java RGB数组图像合成 ImageCombining (整理)
1 /** 2 * Java RGB数组图像合成 ImageCombinning (整理) 3 * 4 * 2016-1-2 深圳南山平山村曾剑锋 5 * 6 * 注意事项: 7 * 1.本程序为 ...
java集合——数组列表（ArrayList）+散列集（HashSet）
[0]README 0.1) 本文描述+源代码均转自 core java volume 1, 旨在理解 java集合--数组列表(ArrayList)+散列集(HashSet) 的相关知识: 0.2 ...
Java语言程序设计上机实验2 掌握Java的基本语言成分和流程控制语句。掌握Java中数组的使用，理解引用数据类型。掌握String类的使用。...
Java语言程序设计上机实验2 实验目的: 掌握Java的基本语言成分和流程控制语句. 掌握Java中数组的使用,理解引用数据类型. 掌握String类的使用. 实验内容: 注:标(*)为选做内 ...
java string 数组个数,Java - 定义一个接收String的方法，并返回一个整数数组，其中包含每个元音的数量...
(对不起提前q长 - 只是想详细说明!) 嗨,大家好, 我一直在努力让这段代码编译这么长时间,我已经到处研究过(包括在这里!)但似乎没有任何工作,我一直在收到错误.我不断调整我如何定义我的静态方法以及 ...
java byte数组与String互转
java byte数组与String互转 CreationTime--2018年7月6日14点53分 Author:Marydon 1.String-->byte[] 方法:使用String.g ...
java的数组与Arrays类源码详解
java的数组与Arrays类源码详解 java.util.Arrays 类是 JDK 提供的一个工具类,用来处理数组的各种方法,而且每个方法基本上都是静态方法,能直接通过类名Arrays调用. 类的 ...
java数组初始化_用Java初始化数组
java数组初始化具有使用C或FORTRAN等语言进行编程的经验的人熟悉数组的概念. 它们基本上是一个连续的内存块,每个位置都是某种类型:整数,浮点数或您所拥有的. Java中的情况与此类似,但有 ...

thinking-in-java(16) 数组

thinking-in-java(16) 数组相关推荐

最新文章

热门文章