Java 基础之数组

数组就是存储数据长度固定的容器，元素类型必须一致，且长度一旦指定不可更改，数组是引用数据类型

1. 数组定义和访问

int[] arr = new int[3];	// 定义长度为 3可以存放整数的数组
int[] arr = new int[]{1, 2, 3, 4, 5, 6};	// 指定初始值
int[] arr = {1, 2, 3, 4, 5};

数组访问

// 使用索引即可访问，从 0 开始
int[] arr = {1, 2, 3, 4, 5};
arr[0]
arr[arr.length - 1] // 最后一个元素
arr[1] = 6  // 赋值

数组复制

数组在内存中存储是一块连续内存的空间，如果将一个数组的引用赋值给另一个数组，那么修改复制数组，被复制数组值也会改变：

int[] arr1 = {1, 2, 3};

int[] arr4 = arr1;
arr4[1] = 6;
System.out.println(arr1[1]);	// 6

2. 数组操作

2.1 数组越界及空指针异常

int[] arr1 = {1, 2, 3};	
arr1[3]		// 超出数组索引长度将引发数组越界，报 ArrayIndexOutOfBoundsException 错误

arr1 = null
System.out.println(arr1[1]);	// 空指针异常

2.2 数组遍历

• for 循环：可以获取数组索引
• for each ：无法获取数组索引
• Arrays.toString() 方法

// for 循环
int[] arr1 = {90, 92, 95, 97, 99};
for (int i = 0; i < arr1.length; i++) {
    System.out.println(arr1[i]);
}

// for each
for (int n : arr1) {
    System.out.println(n);
}

// Arrays.toString() 方法
System.out.println(Arrays.toString(arr1));	// [90, 92, 95, 97, 99]

3. 数组排序

冒泡排序

特点：每一轮循环后，最大的一个数被交换到末尾（升序排序）：

import java.util.Arrays;

public class ArrayTest {
    public static void main(String[] args) {
        // 冒泡排序
        int[] ns = {28, 12, 89, 73, 65, 18, 96, 50, 8, 36};
        System.out.println(Arrays.toString(ns));
		
        for (int i = 0; i < ns.length; i++) {
            for (int j = 0; j < ns.length - i - 1; j++) {
                // 如果前一个数比后一个数大，两者则进行交换
                if (ns[j] > ns[j + 1]) {
                    
                    // 借助（临时）变量进行交换，Java string 为引用类型，不能直接进行交换
                    int temp = ns[j];
                    ns[j] = ns[j + 1];
                    ns[j + 1] = temp;
                }
            }
        }

        System.out.println(Arrays.toString(ns));    // [8, 12, 18, 28, 36, 50, 65, 73, 89, 96]
    }
}

---

Java 内置排序方法

• JDK Arrays.sort() 方法
• 对数组排序实际上修改了数组本身

// Arrays.sort(ns) 排序
int[] ns = {28, 12, 89, 73, 65, 18, 96, 50, 8, 36};
Arrays.sort(ns);
System.out.println(Arrays.toString(ns));    // 默认升序排序

---

冒泡排序降序排序

// 冒泡排序（降序排序）
int[] ns = {28, 12, 89, 73, 65, 18, 96, 50, 8, 36};
System.out.println(Arrays.toString(ns));
for (int i = 0; i < ns.length; i++) {
    for (int j = 0; j < ns.length - i - 1; j++) {
        if (ns[j + 1] > ns[j]) {
            int temp = ns[j + 1];
            ns[j + 1] = ns[j];
            ns[j] = temp;
        }
    }
}
System.out.println(Arrays.toString(ns));

4. 多维数组

4.1 二维数组

二维数组在内存中的结构：

                   ┌───┬───┬───┬───┐
         ┌───┐  ┌──>│ 1 │ 2 │ 3 │ 4 │
ns ─────>│░░░│──┘   └───┴───┴───┴───┘
         ├───┤      ┌───┬───┬───┬───┐
         │░░░│─────>│ 5 │ 6 │ 7 │ 8 │
         ├───┤      └───┴───┴───┴───┘
         │░░░│──┐   ┌───┬───┬───┬───┐
         └───┘  └──>│ 9 │10 │11 │12 │
                    └───┴───┴───┴───┘

二维数组操作：

// 二维数组
int[][] ns = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};
int[] n1 = ns[0];
System.out.println(Arrays.toString(n1));    // [1, 2, 3, 4]
System.out.println(ns.length);      // 3
System.out.println(ns[1][1]);   // 访问二维数组   6

二维数组打印：

• 两层 for 循环
• Arrays.deepToString() 方法

// 遍历循环
for (int[] n : ns) {
    for (int m : n) {
        System.out.println(m);
    }
}

// Arrays.deepToString()
System.out.println(Arrays.deepToString(ns));	// [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

4.2 三维数组

一般而已用的比较多的就是二维数组，三维数组及以上就用的比较少了：

// 三维数组
int[][][] ns = {
    {
        {1, 2, 3},
        {4, 5, 6}
    },
    {
        {1, 2},
        {2, 5}
    },
    {
        {3, 4},
        {6, 8}
    }
};

//[[[1, 2, 3], [4, 5, 6]], [[1, 2], [2, 5]], [[3, 4], [6, 8]]]
System.out.println(Arrays.deepToString(ns));
System.out.println(ns[0][1][1]);    // 访问 5

5. 数组作为参数和返回值

与基本数据类型一直，数组也可以作为参数传递给函数使用或者作为返回值返回：

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    printArr(arr);
    
    int[] arr1 = getArr();
}
public static void printArr(int[] arr) {
    for (int n: arr) {
        System.out.println(n);
    }
}

public static int[] getArr() {
    int[] arr = {1, 2, 3};
    return arr;
}

6. 命令行参数

Java main() 方法可以接收一个 String [] 数组命令行参数：

public class CmdArgTest {
    public static void main(String[] args) {
        for (String arg: args) {
            System.out.println(arg);
			
            // 当输入的是 -version 参数时，输出当前 java 版本号
            if ("-version".equals(arg)) {
                System.out.println("java v1.0");
                break;
            }
        }
    }
}

编译传入参数：

F:\JavaStudy\Source\Hello World>javac CmdArgTest.java

F:\JavaStudy\Source\Hello World>java CmdArgTest -version
-version
java v1.0