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页