【java学习-2】数组操作 / String / 数组 / 遍历数组 / 多维数组 / 打印数组

0 前序需要理解的知识

0.1 String的不可变性

Java的字符串除了是一个引用类型外，还有个重要特点，就是字符串不可变。考察以下代码：

public class Main {
    public static void main(String[] args) {
        String s = "hello";
        System.out.println(s); // 显示 hello
        s = "world";
        System.out.println(s); // 显示 world
    }
}

0.2 数组 / 整数数组 / 字符串数组

定义一个数组类型的变量，使用数组类型“类型[]”，例如，int[]。和单个基本类型变量不同，数组变量初始化必须使用new int[5]表示创建一个可容纳5个int元素的数组。

Java的数组有几个特点：
▲数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；
▲数组一旦创建后，大小就不可改变。
▲数组是引用类型

public class Main {
    public static void main(String[] args) {
        // 5位同学的成绩:
        int[] ns = new int[5];
        ns[0] = 68;
        ns[1] = 79;
        ns[2] = 91;
        ns[3] = 85;
        ns[4] = 62;
        //法2：
        int[] ns = new int[] { 68, 79, 91, 85, 62 };
        //法3：
        int[] ns = { 68, 79, 91, 85, 62 };

    }
}

---

数组是引用类型：
注意数组是引用类型，并且数组大小不可变。我们观察下面的代码：

public class Main {
    public static void main(String[] args) {
        // 5位同学的成绩:
        int[] ns;
        ns = new int[] { 68, 79, 91, 85, 62 };
        System.out.println(ns.length); // 5
        ns = new int[] { 1, 2, 3 };
        System.out.println(ns.length); // 3
    }
}

数组大小变了吗？看上去好像是变了，但其实根本没变。

对于数组ns来说，执行ns = new int[] { 68, 79, 91, 85, 62 };时，它指向一个5个元素的数组：

执行ns = new int[] { 1, 2, 3 };时，它指向一个新的3个元素的数组：

但是，原有的5个元素的数组并没有改变，只是无法通过变量ns引用到它们而已。

---

字符串数组
如果数组元素不是基本类型，而是一个引用类型，那么，修改数组元素会有哪些不同？

字符串是引用类型，因此我们先定义一个字符串数组：

String[] names = {
    "ABC", "XYZ", "zoo"
};

对于String[]类型的数组变量names，它实际上包含3个元素，但每个元素都指向某个字符串对象：

对names[1]进行赋值，例如names[1] = “cat”;，效果如下：

这里注意到原来names[1]指向的字符串"XYZ"并没有改变，仅仅是将names[1]的引用从指向"XYZ"改成了指向"cat"，其结果是字符串"XYZ"再也无法通过names[1]访问到了。

---

public class Main {
    public static void main(String[] args) {
        String[] names = {"ABC", "XYZ", "zoo"};
        String s = names[1];
        names[1] = "cat";
        System.out.println(s); // s是"XYZ"
    }
}

public class Main {
    public static void main(String[] args) {
        String[] names = {"ABC", "XYZ", "zoo"};
        String[] s = names;
        names[1] = "cat";
        System.out.println(s[1]); // s是"cat"
    }
}

1 遍历数组

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        //法1： for each遍历
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
        //法2：Arrays.toString()
        int[] ns = { 1, 1, 2, 3, 5, 8 };
        System.out.println(Arrays.toString(ns));
    }
}

2 数组排序

Java的标准库已经内置了排序功能，我们只需要调用JDK提供的Arrays.sort()就可以排序。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        Arrays.sort(ns);
        System.out.println(Arrays.toString(ns));
    }
}

对整数进行排序：
必须注意，对数组排序实际上修改了数组本身。例如，排序前的数组是：
int[] ns = { 9, 3, 6, 5 };
在内存中，这个整型数组表示如下：

当我们调用Arrays.sort(ns);后，这个整型数组在内存中变为：

即变量ns指向的数组内容已经被改变了。
对字符串数组进行排序：
String[] ns = { “banana”, “apple”, “pear” };
排序前，这个数组在内存中表示如下：

调用Arrays.sort(ns);排序后，这个数组在内存中表示如下：

原来的3个字符串在内存中均没有任何变化，但是ns数组的每个元素指向变化了。

3 多维数组

3.1 二维数组

public class Main {
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        System.out.println(ns.length); // 3
        
		int[] arr0 = ns[0];
        System.out.println(arr0.length); // 4

		//二维数组的每个数组元素的长度并不要求相同
		int[][] another = {
            { 1, 2, 3, 4 },
            { 5, 6 },
            { 7, 8, 9 }
        };
    }
}

ns:
上述代码中，ns包含3个数组，因此，ns.length为3。实际上ns在内存中的结构如下：

arr0：
实际上arr0就获取了ns数组的第0个元素。因为ns数组的每个元素也是一个数组，因此，arr0指向的数组就是{ 1, 2, 3, 4 }。在内存中，结构如下：

another：
二维数组的每个数组元素的长度并不要求相同，这个二维数组在内存中的结构如下：

3.2 打印二维数组

法1：

for (int[] arr : ns) {
    for (int n : arr) {
        System.out.print(n);
        System.out.print(', ');
    }
    System.out.println();
}

法2:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        System.out.println(Arrays.deepToString(ns));
    }
}

3.3 三维数组

三维数组就是二维数组的数组。可以这么定义一个三维数组：

int[][][] ns = {
    {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    },
    {
        {10, 11},
        {12, 13}
    },
    {
        {14, 15, 16},
        {17, 18}
    }
};

它在内存中的结构如下：