Java 笔记 14：Java 数组内容，数组的基本特点、数组边界，以及一些数组使用案例

一、前言

记录时间 [2024-05-04]

系列文章简摘：
Java 笔记 01：Java 概述，MarkDown 常用语法整理
Java 笔记 02：Java 开发环境的搭建，IDEA / Notepad++ / JDK 安装及环境配置，编写第一个 Java 程序
Java 笔记 11：Java 方法相关内容，方法的设计原则，以及方法的定义和调用
Java 笔记 13：Java 数组内容，数组的声明、创建、初始化、赋值等，以及内存分析

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

本文讲述 Java 数组相关知识，包括数组的基本特点、数组边界，以及一些数组使用案例。

二、数组的基本特点

数组是一种常见的数据结构，具有以下基本特点：

• 有序性 ：数组中的元素是有序排列的，每个元素在数组中都有一个唯一的索引 index，可以通过索引来访问和修改数组中的元素。
• 同质性 ：数组中的元素类型通常是相同的，即数组中的元素具有相同的数据类型。这意味着数组中的元素占用的内存大小是相同的。
• 固定长度 ：数组的长度通常在创建时就确定，并且在整个数组的生命周期中保持不变。这意味着无法动态地增加或减少数组的长度。
• 随机访问： 由于数组中的元素是通过索引来访问的，因此可以在常量时间（O(1) 时间复杂度）内获取数组中任意位置的元素。
• 连续的内存空间： 数组中的元素在内存中是连续存储的，这也是实现随机访问的关键。因此，数组的插入和删除操作可能会涉及大量的元素移动，尤其是在数组的中间或开头插入 / 删除元素时。
• 支持多维数组 ：数组可以是多维的，例如二维数组、三维数组等。多维数组的元素通过多个索引进行访问。
• 引用类型：数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。Java 中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

三、数组边界

数组边界指的是数组的有效索引范围，即可以用于访问数组元素的索引范围。

在 Java 中，数组的边界是从索引 0 开始的一系列整数，直到数组长度减去 1。这意味着对于长度为 n 的数组，有效的索引范围是从 0 到 n - 1。

例如，如果有一个长度为 5 的数组，有效的索引范围将是从 0 到 4，共有 5 个元素。试图访问索引为 5 或更大的索引将导致 ArrayIndexOutOfBoundsException 异常，这是 Java 中常见的数组越界错误。

Java 中的数组是固定长度的，一旦创建，其长度就不能再更改。因此，一旦确定了数组的长度，就可以根据该长度来确定数组的有效索引范围。

四、数组使用案例

1. 打印数组元素

在 Java 中，要打印数组的全部元素，可以使用循环遍历数组，并将每个元素打印出来。

这可以通过使用 for 循环或者增强型 for 循环来实现。这两种方法都会打印出数组的所有元素。

• 普通的 for 循环，通过索引来访问每个元素；
• 增强型 for 循环，直接遍历数组中的每个元素。

普通 For 循环

下面是使用 for 循环打印数组元素的示例代码：

public class Main {
    public static void main(String[] args) {
        
        int[] array = {1, 2, 3, 4, 5};

        System.out.println("数组元素如下：");
        
        // array.length 数组的长度，一个有几个元素
        for (int i = 0; i < array.length; i++) {
            System.out.println("索引 " + i + ": " + array[i]);
        }
    }
}

---

For-Each 循环

使用增强型 for 循环，即 For-Each 循环，来遍历数组：

public class Main {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};

        System.out.println("数组元素如下：");
        for (int element : array) {
            System.out.println(element);
        }
    }
}

2. 计算所有元素的和

要计算数组中所有元素的和，可以在循环中遍历数组，并将每个元素的值加总起来。

下面是一个示例代码，演示如何在 Java 中计算数组所有元素的和：

public class Main {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        int sum = 0;

        // 遍历数组，将每个元素的值加总起来
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }

        System.out.println("数组所有元素的和为：" + sum);
    }
}

在这个示例中：

• 首先声明了一个整型变量 sum 来保存数组元素的和，并初始化为 0。
• 然后，使用普通的 for 循环遍历数组，将每个元素的值加到 sum 中。
• 最后，打印出 sum 的值，即为数组所有元素的和。

3. 查找最大元素

要在 Java 中找到数组中的最大元素，可以遍历数组，并在遍历的过程中持续更新最大值。

下面是一个示例代码，演示如何找到数组中的最大元素：

public class Main {
    public static void main(String[] args) {
        int[] array = {10, 5, 20, 8, 15};
        
        // 假设数组的第一个元素是最大值
        int max = array[0];
        
        // 遍历数组，比较每个元素与当前最大值，更新最大值
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        
        System.out.println("数组中的最大元素为：" + max);
    }
}

在这个示例中：

• 我们假设数组的第一个元素是最大值，并将其赋给变量 max；
• 然后遍历数组，从第二个元素开始比较每个元素与当前的最大值 max；
• 如果找到比 max 更大的元素，则更新 max 的值为该元素；
• 最终，当遍历完成时，max 中存储的就是数组中的最大元素。

4. 作为方法入参

在 Java 中，可以将数组作为方法的参数传递。这样可以在方法内部访问和操作数组的元素。

以下是一个示例代码，演示如何将数组作为方法的参数传递：

public class Main {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        
        // 调用方法，并将数组作为参数传递
        printArray(array);
    }
    
    // 定义一个方法，接受一个整型数组作为参数，并打印数组的元素
    public static void printArray(int[] arr) {
        
        System.out.println("数组元素如下：");
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println("索引 " + i + ": " + arr[i]);
        }
        
    }
}

在这个示例中，我们定义了一个名为 printArray 的方法，它接受一个整型数组作为参数。

在 main 方法中，我们创建了一个整型数组 array，然后将它作为参数传递给 printArray 方法。

在 printArray 方法内部，我们使用了普通的 for 循环来遍历传入的数组 arr，并打印数组的每个元素及其索引。

这样，通过将数组作为方法的参数传递，我们可以在方法内部访问和操作数组的元素。

5. 充当返回值

在 Java 中，可以让方法返回一个数组作为其返回值。这允许在方法中创建、初始化和操作数组，然后将其返回给调用者。

以下是一个示例代码，演示如何编写一个方法来反转数组，并将反转后的数组作为返回值返回。

public class Main {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        
        // 调用反转数组方法并接收返回的数组
        int[] reversedArray = reverseArray(array);
        
        // 打印反转后的数组
        System.out.println("反转后的数组如下：");
        for (int i = 0; i < reversedArray.length; i++) {
            System.out.println("索引 " + i + ": " + reversedArray[i]);
        }
    }
    
    // 定义一个方法，用于反转数组，并将反转后的数组作为返回值返回
    public static int[] reverseArray(int[] arr) {
        
        // 定义一个和原数组一样长的新数组
        // 注意不能直接把原数组引用给它
        int[] reversedArray = new int[arr.length];
        
        // 将原数组元素反转到新数组中
        for (int i = 0; i < arr.length; i++) {
            reversedArray[i] = arr[arr.length - 1 - i];
        }
        
        return reversedArray; // 返回反转后的数组
    }
}

在这个示例中，我们定义了一个名为 reverseArray 的方法，它接受一个整型数组作为参数，并返回一个新的反转后的数组。

在方法内部，我们首先创建了一个与原数组长度相同的新数组 reversedArray。然后，我们使用循环将原数组的元素反转到新数组中。最后，我们返回新数组 reversedArray。

在 main 方法中，我们调用 reverseArray 方法，并将原数组作为参数传递给它。然后，我们接收并打印返回的反转后的数组。

五、总结

本文讲述 Java 数组相关知识，包括数组的基本特点、数组边界，以及一些数组使用案例。

一些参考资料

狂神说 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/