Java 笔记 15：Java 数组相关内容补充，多维数组，Arrays 类的常见用法，以及冒泡排序

一、前言

记录时间 [2024-05-05]

系列文章简摘：
Java 笔记 01：Java 概述，MarkDown 常用语法整理
Java 笔记 02：Java 开发环境的搭建，IDEA / Notepad++ / JDK 安装及环境配置，编写第一个 Java 程序
Java 笔记 13：Java 数组内容，数组的声明、创建、初始化、赋值等，以及内存分析
Java 笔记 14：Java 数组内容，数组的基本特点、数组边界，以及一些数组使用案例

更多 Java 相关文章，请参考上面专栏哦。

本文是对 Java 数组相关内容的补充，主要为多维数组概述，以及 Arrays 类的常见用法。同时，文章详细介绍了冒泡排序的相关使用，并进行简单的算法优化。

二、多维数组

1. 概述

在 Java 中，可以创建多维数组来表示多维数据结构，比如矩阵、立方体等。

多维数组是数组的数组，也就是说，数组的元素也可以是数组。

例如，二维数组是一个特殊的一维数组，它的每一个元素都是一个一维数组。

我们对不同维度的数组进行类比：

// 创建一个包含 3 个元素的一维数组
int[] array = {1,2,3};

// 创建一个 3x3 的二维数组
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 创建一个 3x3x2 的三维数组
int[][][] array3D = {
    { {1, 2}, {3, 4}, {5, 6} },
    { {7, 8}, {9, 10}, {11, 12} },
    { {13, 14}, {15, 16}, {17, 18} }
};

简而言之，就是数组多一个维度，就是在原来单纯放元素的地方，放一个数组。

2. 定义

在之后 Java 编程中，比较常用的也是二维数组，这里以二维数组举例。

如图所示，我们定义了一个二维数组 arr[3][2]，它是 3 行 2 列的。其中，第一个维度控制行数为 3 行，第二个维度控制列数为 2 列。

两个维度的下标索引都是从 0 开始的。可以根据下标确定每个元素的位置。比如，arr[0][1] 表示第 1 行第 2 个数据元素。

3. 使用

打印二维数组元素

要打印 Java 中的二维数组元素，可以使用嵌套的循环来遍历数组，并逐个打印每个元素。

以下是一个简单的示例代码：

public class Main {
    public static void main(String[] args) {
        
        // 定义一个 3 行 3 列的二维数组
        int[][] array = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        
        // 遍历行 array.length 确定行数
        for (int i = 0; i < array.length; i++) {
            
            // 遍历列 array[i].length 确定列数
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            // 换行
            System.out.println();
        }
    }
}

这段代码将打印出以下内容：

1 2 3 
4 5 6 
7 8 9 

三、Arrays 类

1. 概述

数学工具类 java.util.Arrays 提供了许多有用的方法来处理数组。这些方法包括排序、搜索、比较等等。具体可以查看官方文档。

如图所示，Arrays 类中的方法都是静态方法，可以直接使用类名调用这些方法，而不需要创建 Arrays 类的实例。

例如，可以直接通过 Arrays.sort(array) 调用 sort 方法来对数组进行排序，而不需要先创建一个 Arrays 对象。这样的语法简洁明了，适合处理数组的情况。

2. 常用方法

java.util.Arrays 类提供了许多有用的方法来处理数组，以下是一些常用的方法：

• toString(array)：将数组转换为字符串形式。
• sort(array)：对数组进行排序。
• binarySearch(array, key)：在排序后的数组中使用二分搜索来查找指定的元素。
• equals(array1, array2)：比较两个数组是否相等。
• fill(array, value)：将数组的所有元素设置为指定的值。
• copyOf(array, length)：复制数组的一部分到一个新数组。
• asList(array)：将数组转换为列表。

打印数组元素

可以使用 Arrays.toString() 方法将数组转换为字符串，然后打印这个字符串。

这个方法非常适合于快速查看数组的内容。

import java.util.Arrays;

int[] array = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(array));

// 这样会输出
[1, 2, 3, 4, 5]

---

查看一些 toString 方法都干了写什么。

看看它是怎么实现打印数组这个功能的。

public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
}

数组排序

要对数组进行排序，可以使用 Arrays 类中的 sort() 方法。

以下是一个简单的示例，演示了如何使用 Arrays.sort() 方法对整型数组进行排序：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] array = {5, 2, 9, 1, 7};
        
        // 对数组进行排序
        Arrays.sort(array);
        
        // 打印排序后的数组
        System.out.println("Sorted array: " + Arrays.toString(array));
    }
}

这段代码会输出：

Sorted array: [1, 2, 5, 7, 9]

Arrays.sort() 方法会按照升序对数组进行排序。

如果需要按照降序排序，可以先使用 Arrays.sort() 方法排序数组，然后反转数组中的元素，或者自定义一个 Comparator 对象来实现降序排序。

填充数组

要将数组的所有元素设置为指定的值，可以使用 Arrays 类中的 fill() 方法。

这个方法会将指定数组的所有元素都设置为指定的值。

以下是一个示例代码，演示了如何使用 Arrays.fill() 方法将数组的所有元素设置为指定的值：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        
        // 创建一个长度为 5 的整型数组
        int[] array = new int[5]; 
        
        // 将数组的所有元素设置为指定值
        int value = 10;
        Arrays.fill(array, value);
        
        // 打印数组的内容
        System.out.println("Array after filling: " + Arrays.toString(array));
    }
}

这段代码会输出：

Array after filling: [10, 10, 10, 10, 10]

在这个例子中，我们创建了一个长度为 5 的整型数组，并将数组的所有元素都设置为值为 10。

---

如果想要设置数组中的特定范围为指定值，可以直接调用 Arrays.fill() 方法并传入相应的参数。

以下是使用 Arrays.fill() 方法来实现的示例：

将数组的索引 2（包括）到索引 4（不包括）之间的元素设置为 1。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 创建一个长度为 5 的整型数组
        int[] array = new int[5]; 
        
        // 将索引为 2（包括）到索引为 4（不包括）之间的元素设置为 1
        Arrays.fill(array, 2, 4, 1);
        
        // 打印数组的内容
        System.out.println("Array after setting values: " + Arrays.toString(array));
    }
}

这段代码会输出：

# 将索引为 2（包括）到索引为 4（不包括）之间的元素设置为 1
Array after setting values: [0, 0, 1, 1, 0]

四、冒泡排序

冒泡排序是一种简单的排序算法：

• 比较数组中，两个相邻的元素，如果第 1 个数比第 2 个数大，就交换它们的位置；
• 每一次比较，都会产生出一个最大，或者最小的数字；
• 下一轮可以少一次排序；
• 依次循环，直到结束。

1. 交换数组元素位置

要交换数组中的两个元素的位置，可以使用一个临时变量来暂存一个元素的值，然后将其中一个元素的值赋给另一个元素，最后将暂存的值赋给另一个元素。

就好比有两杯水，想要交换它们的位置，需要借助第三个杯子来临时存放其中一杯水，然后将另一杯水倒入第一个杯子，再将第三个杯子中的水倒入第二个杯子。这样就完成了两杯水的位置交换。

以下是一个模拟这个过程的示例：

public class Main {
    public static void main(String[] args) {
        // 假设有两杯水，分别用整数表示
        int cup1 = 1;
        int cup2 = 2;
        
        System.out.println("交换前: Cup 1: " + cup1 + ", Cup 2: " + cup2);
        
        // 交换水杯位置
        int temp = cup1; 	// 临时变量用于存放 cup1 的内容
        cup1 = cup2; 		// 将 cup2 的内容倒入 cup1
        cup2 = temp; 		// 将临时变量中的内容倒入 cup2
        
        System.out.println("交换后: Cup 1: " + cup1 + ", Cup 2: " + cup2);
    }
}

2. 实现冒泡排序

以下是冒泡排序的实现示例：

首先定义了一个 bubbleSort 方法来执行冒泡排序。然后创建一个示例数组，调用 bubbleSort 方法对其进行排序，并输出排序后的数组。

public class BubbleSort {
    
    // 冒泡排序方法体
    public static void bubbleSort(int[] array) {
        
        // 确定数组长度
        int n = array.length;
        
        // 外层循环，判断一共要比较 n-1 轮
        for (int i = 0; i < n - 1; i++) {
            
            // 内层循环，比较判断两个数，如果第 1 个数比第 2 个数大，则交换位置
            for (int j = 0; j < n - i - 1; j++) {
                
                if (array[j] > array[j + 1]) {
                    // 交换 array[j] 和 array[j+1]
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("Original array: " + Arrays.toString(array));

        bubbleSort(array);

        System.out.println("Sorted array: " + Arrays.toString(array));
    }
}

3. 算法优化

冒泡排序的平均时间复杂度为：
$$O(n^2)$$
可见，冒泡排序虽然简单易懂，但效率较低，尤其是在处理大规模数据集时。

如何优化：加入标志位

在每次遍历过程中，如果某一次遍历没有发生元素交换，说明数组已经有序，可以提前结束排序过程。

以下是一个优化后的冒泡排序的示例代码：

public class BubbleSort {
    public static void bubbleSort(int[] array) {
        int n = array.length;
        
        // 标志位，表示是否进行了元素交换
        boolean swapped; 
        
        for (int i = 0; i < n - 1; i++) {
            
            swapped = false;
            
            for (int j = 0; j < n - i - 1; j++) {
                
                if (array[j] > array[j + 1]) {
                    // 交换 array[j] 和 array[j+1]
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    
                    // 标志位设为 true，表示进行了元素交换
                    swapped = true; 
                }
            }
            
            // 如果本次遍历没有进行元素交换，说明数组已经有序，提前结束排序
            if (!swapped) {
                break;
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("Original array: " + Arrays.toString(array));

        bubbleSort(array);

        System.out.println("Sorted array: " + Arrays.toString(array));
    }
}

五、总结

本文是对 Java 数组相关内容的补充，主要为多维数组概述，以及 Arrays 类的常见用法。同时，文章详细介绍了冒泡排序的相关使用，并进行简单的算法优化。

一些参考资料

狂神说 Java 零基础：https://www.bilibili.com/video/BV12J41137hu/
TIOBE 编程语言走势： https://www.tiobe.com/tiobe-index/
Typora 官网：https://www.typoraio.cn/
Oracle 官网：https://www.oracle.com/
Notepad++ 下载地址：https://notepad-plus.en.softonic.com/
IDEA 官网：https://www.jetbrains.com.cn/idea/
Java 开发手册：https://developer.aliyun.com/ebook/394
Java 8 帮助文档：https://docs.oracle.com/javase/8/docs/api/