2. Java数组类型及其操作

1. 数组

定义一个数组类型的变量，使用数组类型“类型[]”，例如，int[]，String[]。
Java的数组有几个特点：

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

1.1 创建数组

• 方式1：

int[] arr = new int[5];

可以用数组变量.length获取数组大小

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[5];
        System.out.println(arr.length); // 5
    }
}

• 方式2：
  在定义数组时直接指定初始化的元素，这样就不必写出数组大小，而是由编译器自动推算数组大小。例如：

public class Main {
    public static void main(String[] args) {
       // int[] ns = new int[] { 68, 79, 91, 85, 62 };
        // 简写如下：
        int[] ns = { 68, 79, 91, 85, 62 };
        System.out.println(ns.length); // 编译器自动推算数组大小为5
    }
}

1.2 数组索引和赋值
要访问数组中的某一个元素，需要使用索引。数组索引从0开始，例如，5个元素的数组，索引范围是0~4。
可以修改数组中的某一个元素，使用赋值语句，例如，arr[1] = 5;
数组是引用类型，在使用索引访问数组元素时，如果索引超出范围，运行时将报错：

public class Main {
    public static void main(String[] args) {
        // 5位同学的成绩:
        int[] ns = new int[5];
        int n = 5;
        System.out.println(ns[n]); // 索引n不能超出范围
    }
}

报错：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5 at Main.main

1.3 注意事项

• 数组是同一数据类型的集合，数组一旦创建后，大小就不可变；
• 可以通过索引访问数组元素，但索引超出范围将报错；
• 数组元素可以是值类型（如int）或引用类型（如String），但数组本身是引用类型；

2. 数组操作

2.1 遍历数组
数组遍历一般有3种方法

• 方法1：for循环

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

• 方法2：foreach循环

public class Main {
    public static void main(String[] args) {
        int[] arr = { 1, 4, 9, 16, 25 };
        for (int n : arr) {
            System.out.println(n);
        }
    }
}

• 方法3. Arrays类种toString()方法

public class Main {
    public static void main(String[] args) {
        int[] arr = { 1, 4, 9, 16, 25 };
        System.out.println(Arrays.toString(arr)); // [1, 4, 9, 16, 25] 
    }
}

2.2 数组排序
对数组进行排序是程序中非常基本的需求。常用的排序算法有冒泡排序、插入排序和快速排序等。
冒泡排序：

public class Main {
    public static void main(String[] args) {
        int[] arr = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j+1]) {
                    // 交换arr[j]和arr[j+1]:
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        // 排序后:
        System.out.println(Arrays.toString(arr));
    }
}

算法特点：

• 用双重循环语句，外层i控制循环多少趟，内层j控制每一趟的排序比较次数
• 若N个数字要排序完成，总共进行N-1趟排序，第i趟的排序比较次数为(N-i)次

实际上，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));
    }
}

3. 二维数组

二维数组就是数组的数组。定义一个二维数组如下：

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

二维数组的每个数组元素的长度并不要求相同，例如，可以这么定义arr数组

int[][] ns = {
    { 1, 2, 3, 4 },
    { 5, 6 },
    { 7, 8, 9 }
};

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

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

Java标准库的Arrays.deepToString()也可以

import java.util.Arrays;

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