1. 数组类型

1.1 创建数组

方法一

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

int[] ns = new int[5];
// 数组元素赋值
ns[0] = 68;
ns[1] = 79;
ns[2] = 91;
...

Java的数组有几个特点：

  • 数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；
  • 数组一旦创建后，大小就不可改变。

方法二

定义数组时直接指定初始化的元素，这样就不必写出数组大小，而是由编译器自动推算数组大小

int[] ns = new int[] { 68, 79, 91, 85, 62 };
// 进一步可简写
int[] ns = { 68, 79, 91, 85, 62 };

获取数组的长度

使用.length获取数组大小：

System.out.println(ns.length); // 编译器自动推算数组大小为5

1.2 数组引用

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被重新赋值了，但是原来长度为5的数组并没有被覆盖，它仍然占用内存。只是ns不再指向它了而已，而是指向了长度为3的新数组。

字符串数组

如果数组元素不是基本类型，而是一个引用类型。

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

对names[1]进行赋值，例如names[1] = "cat";

  • 赋值之前，names[1] = "XYZ"；
  • 重新赋值之后，实际上XYZ并没有被cat覆盖，它同样占用内存，只是没有name[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(names[1]);
        System.out.println(s);
    }
}

// 输出
cat
XYZ

2. 数组操作

2.1 遍历数组

方法一

通过for循环，可以遍历数组元素：

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int i=0; i<ns.length; i++) {
            int n = ns[i];
            System.out.println(n);
        }
    }
}

方法二

使用for eaca来遍历：

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
    }
}
  • 在for (int n : ns)循环中，变量n直接拿到ns数组的元素，而不是索引。for each循环更加简洁，但是，for each循环无法拿到数组的索引。

打印数组内容

如果我们直接打印数组的名字，类似于：

System.out.println(ns)

// 输出：[Ljava.lang.String;@5acf9800

得到的是数组在JVM中的引用地址。当然可以通过for each来进行打印，但是仍然很复杂。

Arrays.toString()

Java标准库提供了Arrays.toString()，可以快速打印数组内容：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 1, 2, 3, 5, 8 };
        System.out.println(Arrays.toString(ns));
    }
}

// 输出：[1, 1, 2, 3, 5, 8]

2.2 数组排序

利用util.Arrays对数组进行排序：

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));
    }
}

// 输出
// [8, 12, 18, 28, 36, 50, 65, 73, 89, 96]
  • 如果是对整数数组进行排序，相应位置对应的内存发生了变换；（内存内容交换）
  • 而对字符数组（引用类型）进行排序时，原来的字符串在内存中均没有任何变化，但是数组中每个元素指向都发生了变化；（内存内容不变，引用发生交换）

2.3 多维数组

定义二维数组：

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
    }
}

打印一个二维数组，可以使用两层嵌套的for循环：

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

for (int i=0; i<ns.length; i++) {
		for (int j=0; j<ns[i].length; j++) {
    		System.out.print(ns[i][j]);
    		System.out.print(", ");
  	}
  	System.out.println();
}

或者使用Java标准库的Arrays.deepToString()：

System.out.println(Arrays.deepToString(ns));

2.4 命令行参数

Java程序的入口是main方法，而main方法可以接受一个命令行参数，它是一个String[]数组。