Java数组(1)：数组与多维数组

我们对数组的基本看法是，你可以创建它们，通过使用整型索引值访问它们的元素，并且他们的尺寸不能改变。

但是有时候我们需要评估，到底是使用数组还是更加灵活的工具。数组是一个简单的线性序列，这使得元素访问非常快速。但是为这种速度所付出的代价是数组大小被固定，并且在其生命周期中不可改变。

无论使用哪种类型的数组,数组标识符只是一个引用。基本类型数组直接保存基本类型的值，对象数组保存一个指向其他对象的引用。

 class Apple {
     private static int count = 1;

     public Apple() {
         System.out.println("Apple" + count++);
     }
 }

 public class ArrayOptions {
     public static void main(String[] args) {
         Apple[] a; // 创建一个Apple类型的数组引用
         Apple[] b = new Apple[5]; // 创建一个Apple类型的数组对象，但是都指向null
         System.out.println("b: " + Arrays.toString(b)); // b: [null, null, null, null, null]
         Apple[] c = new Apple[4];
         for (int i = 0; i < c.length; i++)
             c[i] = new Apple(); // Apple1 Apple2 Apple3 Apple4
         // Aggregate initialization:
         Apple[] d = {new Apple(), new Apple(), new Apple()}; // Apple5 Apple6 Apple7
         // Dynamic aggregate initialization:
         a = new Apple[]{new Apple(), new Apple()}; // Apple8 Apple9
         System.out.println("a.length = " + a.length); // a.length = 2
         System.out.println("b.length = " + b.length); // b.length = 5
         System.out.println("c.length = " + c.length); // c.length = 4
         System.out.println("d.length = " + d.length); // d.length = 3
         a = d;
         System.out.println("a.length = " + a.length); // a.length = 3

         int[] e; // 创建一个基本类型的数组引用
         int[] f = new int[5]; // 创建一个Apple基本数组对象，初始化值都为0
         System.out.println("f: " + Arrays.toString(f)); // f: [0, 0, 0, 0, 0]
         int[] g = new int[4];
         for (int i = 0; i < g.length; i++)
             g[i] = i * i;
         int[] h = {11, 47, 93};
         System.out.println("f.length = " + f.length); // f.length = 5
         System.out.println("g.length = " + g.length); // g.length = 4
         System.out.println("h.length = " + h.length); // h.length = 3
         e = h;
         System.out.println("e.length = " + e.length); // e.length = 3
         e = new int[]{1, 2};
         System.out.println("e.length = " + e.length); // e.length = 2
     }
 }

多维数组

 import java.util.Arrays;

 class Apple {
     private static int count = 1;

     public String toString() {
         return "Apple" + count++;
     }
 }

 public class MutiArray {
     public static void main(String[] args) {
         // (1) 使用Arrays.deepToString()可以打印多维数组
         int[][] a = {{1, 2, 3}, {4, 5, 6}};
         long[][][] b = new long[2][2][3];
         System.out.println(Arrays.deepToString(a)); // [[1, 2, 3], [4, 5, 6]]
         System.out.println(Arrays.deepToString(b)); // [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]

         // (2) 多维数组值的设定可以用下面方法，并且数组中构成矩阵的每个向量都可具有任意长度（粗糙数组）
         int[][] c = new int[3][];
         for (int i = 0; i < c.length; i++) {
             c[i] = new int[i + 1];
             for (int j = 0; j < c[i].length; j++) {
                 c[i][j] = j + 1;
             }
         }
         System.out.println(Arrays.deepToString(c)); // [[1], [1, 2], [1, 2, 3]]

         // (3) 用类似方式还可以处理非基本类型的（包装类和对象类）数组
         Apple[][] d = {{new Apple(), new Apple()}, {new Apple(), new Apple(), new Apple()}};
         Integer[][] e = {{1, 2}, {3, 4, 5}, {6, 7}};
         System.out.println(Arrays.deepToString(d)); // [[Apple1, Apple2], [Apple3, Apple4, Apple5]]
         System.out.println(Arrays.deepToString(e)); // [[1, 2], [3, 4, 5], [6, 7]]
     }
 }