黄阶低级 - 《 Java 核心》- 3.10 数组 - 修改0次

数组

• 一旦创建了数组，就不能改变大小；为了扩展数组的大小，应使用另一种数据结构——数组列表 （ array list ）。
• foreach 循环可以依次处理元素集合的每个元素而不用为下标担心，尤其在需要处理集合中的所有元素时更加方便。

int[] a = { 1, 3, 5, 7, 9 };
for (int i : a) {
    System.out.print(i + " ");
}
//输出 1 3 5 7 9

• 有个更简单的打印数组中的所有的值，即利用 Array 类的 toString 方法：

int[] a = { 1, 2, 3, 4, 5 };
System.out.println(Arrays.toString(a));
/*
 * 输出 [1, 2, 3, 4, 5] 
 * 注意是Arrays.toString(a),而不是a.toString!!!
*/

• Java 中的 [ ] 运算符被预定义为检查数组边界，而且没有指针运算，即不能通过 a 加 1 得到数组的下一个元素。
• Java 数组与 C++ 的数组有很大不同，但基本和 C++ 的指针数组一样。

1、数组拷贝

• 在 Java 中，将一个数组变量拷贝给另一个数组变量，这时两个变量将引用同一个数组！

int[] a = { 1, 2, 3, 4, 5 };
int[] b = a;
b[3] = 12;
System.out.println(a[3]);
// 输出 12 ，说明此时两变量指向同一个数组！

• 数组值的完全拷贝和扩展数组，可以使用 Arrays 类的 copyOf 方法：

int[] a = { 1, 2, 3, 4, 5 };
int[] b = Arrays.copyOf(a, 2 * a.length);
System.out.println(Arrays.toString(b));
// 输出 [1, 2, 3, 4, 5, 0, 0, 0, 0, 0] 

2、有意思的命令行参数

• 每一个 Java 程序都有一个带 String arg[]参数的 main 方法。这个参数表明 main 方法将接受一个字符串数组，也就是命令行参数。
• 在 main 方法中，程序名并没有存储在 args 数组中。

public class Message {
    public static void main(String[] args) {
        if (args[0].equals("-h"))// 字符串比较不用 ==
            System.out.println("hello:");
        for (String i : args)
            System.out.println(i);
        for (int i = 0;i < args.length; i++)
            System.out.println(args[i]);
    }
}

3、数组排序

• 对数值型数组进行排序，可以使用 Arrays 类的 sort 方法：

int[] a = { 1, 9, 5, 7, 2, 4, 10 };
Arrays.sort(a);
for (int i : a) {
    System.out.print(i + " ");
}//输出 1 2 4 5 7 9 10 

4、多维数组

• 要想快速打印一个二维数组的数据元素列表，可以使用 Arrays 类的 deepToString 方法：

int[][] a = { { 1, 9, 5 }, { 7, 2, 4 }, { 10, 34, 45 }, };
System.out.println(Arrays.deepToString(a));
//输出 [[1, 9, 5], [7, 2, 4], [10, 34, 45]]

• for each 循环语句不能自动处理二维数组的每一个元素，需要使用两个嵌套的循环：

int[][] a = { { 1, 9, 5 }, { 7, 2, 4 }, { 10, 34, 45 } };
for (int[] row : a)
    for (int i : row)
        System.out.print(i + " ");
// 输出 1 9 5 7 2 4 10 34 45 

5、不规则数组

Java 的优势： java 实际上没有多维数组，只有一维数组，多维数组被解释成“数组的数组”

• 由于可以单独的存取数据的某一行，所以可以让两行交换：

int[][] a = { { 1, 9, 5 }, { 7, 2, 4 }, { 10, 34, 45 } };
int[] temp = a[1];
a[1] = a[2];
a[2] = temp;
System.out.println(Arrays.deepToString(a));
//输出 [[1, 9, 5], [10, 34, 45], [7, 2, 4]]

• 还可以方便的构造一个“不规则”的数组，即数组的每一行有不同的长度：

public class LotteryArray {
    public static void main(String[] args) {
        final int NMAX = 4;

        // 分配不规则数组，独立分配行数组
        int[][] odds = new int[NMAX + 1][];
        for (int n = 0; n <= NMAX; n++)
            odds[n] = new int[n + 1];

        // 填充不规则数组
        for (int n = 0; n < odds.length; n++)
            for (int k = 0; k < odds[n].length; k++) {
                for (int i = 1; i <= k; i++)
                    odds[n][k] = k;
            }

        // 打印不规则数组
        for (int[] row : odds) {
            for (int odd : row)
                System.out.printf("%4d", odd);
            System.out.println();
        }
    }
}

输出：
0
0 1
0 1 2
0 1 2 3
0 1 2 3 4