Java零基础之数组篇(5):数组的高级操作！

我崽不熬夜
117 阅读10分钟

  《Java零基础教学》是一套深入浅出的 Java 编程入门教程。全套教程从Java基础语法开始，适合初学者快速入门，同时也从实例的角度进行了深入浅出的讲解，让初学者能够更好地理解Java编程思想和应用。

  本教程内容包括数据类型与运算、流程控制、数组、函数、面向对象基础、字符串、集合、异常处理、IO 流及多线程等 Java 编程基础知识，并提供丰富的实例和练习，帮助读者巩固所学知识。本教程不仅适合初学者学习，也适合已经掌握一定 Java 基础的读者进行查漏补缺。

在上一期内容Java零基础之数组篇(4):深入理解Java中的多维数组中，我们深入探讨了多维数组的基础知识及其实际应用。通过了解如何定义、初始化以及操作多维数组，我们掌握了如何在Java中处理复杂的数据结构，尤其是二维或三维数组。多维数组在一些特殊应用场景中非常有用，比如矩阵运算、图像处理和复杂数据建模等。

本期我们将继续深入探讨与数组相关的更多高级操作，包括数组在方法中的应用、数组的深浅拷贝，以及如何通过动态扩展提升数组的灵活性。理解这些操作，将帮助我们更加高效地处理数组，并在复杂的编程场景中更加自如地使用数组结构。

数组作为方法参数与返回值

1. 数组作为方法参数传递

在Java中，数组可以作为方法的参数进行传递。这意味着我们可以将数组对象传递给某个方法并对其进行操作。然而，数组作为参数传递时是引用传递，这意味着对数组的修改会影响到原数组。

示例：

public class ArrayExample {
    public static void modifyArray(int[] arr) {
        arr[0] = 99; // 修改数组第一个元素
    }
    
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        modifyArray(numbers);
        System.out.println(numbers[0]); // 输出99
    }
}

在这个示例中，modifyArray()方法对传入的数组进行了修改，且这种修改反映在原数组numbers中。这种传递方式节省了内存，但需要特别注意避免无意的修改。

代码解析：

这段Java代码定义了一个名为ArrayExample的类，其中包含一个名为modifyArray的静态方法和一个main方法。

  1. modifyArray方法：

    • 这是一个静态方法，接受一个整数数组作为参数。
    • 方法内部将传入数组的第一个元素（索引为0的元素）的值修改为99。

  2. main方法：

    • 这是程序的入口点。
    • 在main方法中，首先声明并初始化了一个名为numbers的整数数组，包含五个元素：{1, 2, 3, 4, 5}。
    • 接着，调用modifyArray方法，并将numbers数组作为参数传递。
    • modifyArray方法会修改传入数组的第一个元素的值为99。
    • 然后，main方法使用System.out.println语句打印numbers数组的第一个元素。由于该元素已经被modifyArray方法修改，所以输出的结果是99。
    • 程序结束。

代码的执行流程如下：

  1. main方法开始执行。
  2. 创建一个名为numbers的整数数组，并初始化为{1, 2, 3, 4, 5}。
  3. 调用modifyArray方法，并将numbers数组传递给它。
  4. modifyArray方法内部将numbers数组的第一个元素值改为99。
  5. main方法打印修改后的numbers数组的第一个元素，输出99。
  6. 程序结束。

2. 数组作为方法的返回值

同样，数组可以作为方法的返回值返回给调用者。需要注意的是，方法返回的是数组对象的引用，而不是数组的拷贝。因此，返回的数组在外部可以继续被修改。

示例：

public class ArrayReturnExample {
    public static int[] createArray() {
        int[] arr = {10, 20, 30};
        return arr;  // 返回数组
    }
    
    public static void main(String[] args) {
        int[] numbers = createArray();
        System.out.println(numbers[0]); // 输出10
    }
}

这个例子演示了如何将数组作为方法的返回值使用。理解数组的引用传递机制对于避免潜在的错误至关重要。

代码解析：

这段Java代码定义了一个名为ArrayReturnExample的类，其中包含一个静态方法createArray和一个main方法。

  1. createArray方法：

    • 这是一个静态方法，意味着它可以在不创建类实例的情况下被调用。
    • 方法的功能是创建一个包含三个整数（10, 20, 30）的数组，并将其返回。数组类型的声明为int[]，表示这是一个整数数组。

  2. main方法：

    • 这是程序的入口点，Java程序执行时从这里开始。
    • 在main方法中，首先调用了createArray方法，并将返回的数组赋值给名为numbers的数组变量。
    • 然后，通过System.out.println(numbers[0]);语句输出数组numbers的第一个元素，即索引为0的元素。由于数组是0索引的，所以numbers[0]指的是数组中的第一个元素，其值为10。
    • 因此，当程序运行时，控制台将打印出数字10。

代码的执行流程如下：

  1. main方法开始执行。
  2. 调用createArray方法，创建一个包含三个整数的数组并返回。
  3. 返回的数组被赋值给numbers变量。
  4. 打印numbers数组的第一个元素（值为10）到控制台。
  5. 程序结束。

深拷贝与浅拷贝

1. 直接赋值 vs 使用 Arrays.copyOf() 进行深拷贝

在Java中，数组赋值时，实际上是赋予了对同一数组的引用。即，修改任意一个引用的数组内容，另一个引用也会感受到变化。这种机制称为浅拷贝。

示例：浅拷贝

int[] original = {1, 2, 3};
int[] copy = original;  // 浅拷贝
copy[0] = 99;
System.out.println(original[0]); // 输出99，原数组也被修改

然而，有时候我们希望创建一个数组的完全独立副本，修改副本不影响原数组。此时需要使用深拷贝。Java的Arrays.copyOf()方法提供了简便的深拷贝方式。

示例：深拷贝

int[] original = {1, 2, 3};
int[] deepCopy = Arrays.copyOf(original, original.length);  // 深拷贝
deepCopy[0] = 99;
System.out.println(original[0]); // 输出1，原数组未被修改

2. 多维数组的深浅拷贝问题

对于多维数组，浅拷贝只会复制第一层的引用，而不会递归复制内部的子数组。因此，浅拷贝的多维数组在修改子数组时，原数组也会受到影响。若需要完全独立的副本，必须对多维数组进行逐层深拷贝。

示例：多维数组浅拷贝

int[][] original = {{1, 2}, {3, 4}};
int[][] shallowCopy = original;
shallowCopy[0][0] = 99;
System.out.println(original[0][0]);  // 输出99，原数组也被修改

示例：多维数组深拷贝

int[][] original = {{1, 2}, {3, 4}};
int[][] deepCopy = new int[original.length][];
for (int i = 0; i < original.length; i++) {
    deepCopy[i] = Arrays.copyOf(original[i], original[i].length);  // 逐层深拷贝
}
deepCopy[0][0] = 99;
System.out.println(original[0][0]);  // 输出1，原数组未被修改

通过对多维数组进行深拷贝，可以避免意外的引用传递问题。

数组的动态扩展

1. 使用 System.arraycopy()

数组一旦初始化后，其长度是固定的。在某些场景中，我们可能需要扩展数组的长度来容纳更多的数据。System.arraycopy()方法允许我们快速复制数组中的元素，适用于固定长度数组的扩展。

示例：

int[] original = {1, 2, 3};
int[] expanded = new int[5];  // 扩展后的数组
System.arraycopy(original, 0, expanded, 0, original.length);  // 复制原数组内容
expanded[3] = 4;  // 添加新元素
System.out.println(Arrays.toString(expanded));  // 输出 [1, 2, 3, 4, 0]

本地实际运行结果：

image.png

代码分析：

针对如上示例代码，这里我给大家详细的代码剖析下，以便于帮助大家理解的更为透彻，帮助大家早日掌握。、

这段代码展示了如何通过扩展一个数组的长度来容纳更多元素，并使用System.arraycopy()方法将原数组的内容复制到扩展后的数组中。下面对代码逐行进行详细解析：

  1. int[] original = {1, 2, 3};
  • 定义并初始化了一个名为original的一维整数数组，其中包含三个元素1, 2, 3。
  • 这是我们将要扩展的原始数组，长度为3。
  1. int[] expanded = new int[5];
  • 定义了一个新数组expanded，长度为5。
  • 该数组比原数组original长度更大，目的是扩展以容纳更多元素。新数组的元素默认值为0，即[0, 0, 0, 0, 0]。
  1. System.arraycopy(original, 0, expanded, 0, original.length);

  • 这是调用System.arraycopy()方法将原数组original的内容复制到新数组expanded中的关键部分。

  • System.arraycopy()方法的语法如下：

    System.arraycopy(srcArray, srcPos, destArray, destPos, length);

    各个参数的含义：

    • srcArray: 源数组，即需要复制的数组。在这里是original。
    • srcPos: 源数组的起始位置（索引），从0开始。
    • destArray: 目标数组，这里是扩展后的expanded。
    • destPos: 目标数组的起始位置，同样从0开始。
    • length: 要复制的元素数量，即从源数组中复制的元素个数。这里是original.length，即3。

  • 这行代码的实际作用是将original数组中的{1, 2, 3}复制到expanded数组的前3个位置中，expanded的内容此时变为{1, 2, 3, 0, 0}。

  1. expanded[3] = 4;
  • 在扩展后的数组expanded的第4个位置（索引为3）添加了一个新元素4。
  • 此操作将原数组original复制后，继续对扩展的数组添加新的数据。
  • 此时，数组expanded的内容变为{1, 2, 3, 4, 0}。
  1. System.out.println(Arrays.toString(expanded));
  • 使用Arrays.toString()方法将数组内容以字符串形式输出，方便打印和查看。
  • Arrays.toString()会将数组转换为字符串格式，如[1, 2, 3, 4, 0]，这使得输出变得更加直观。
  • 最终输出的结果为：[1, 2, 3, 4, 0]。

代码行为概述：

  • 数组扩展：将一个长度为3的数组original扩展到长度为5的数组expanded，并通过System.arraycopy()复制了original的内容。
  • 添加新元素：通过直接赋值的方式，将新元素4添加到扩展后的数组中。
  • 打印结果：将数组转换为可读的字符串格式并输出，结果显示数组内容成功扩展并添加了新元素。

深入理解：

  1. 数组的固定长度：在Java中，数组的长度在创建后是固定的。因此，我们无法直接在原数组的基础上进行扩展。通过创建一个新的更大数组并复制原数组内容，可以实现类似于数组扩展的效果。
  2. System.arraycopy()的高效复制：System.arraycopy() 是一个本地方法，效率非常高，它是Java中最常用的复制数组内容的方式之一。比起通过循环逐个复制元素，这种方式更简洁并且性能更好。
  3. 手动管理扩展和新元素的添加：这段代码展示了手动管理数组扩展的过程，尤其是在固定大小的数组中，如何通过扩展解决元素追加的问题。

进一步优化：

如果频繁需要对数组进行扩展，可以考虑使用ArrayList或其他动态数组结构，因为Java中的ArrayList能够自动调整大小，避免手动管理数组扩展。

总结

在本期【数组的高级操作】中，我们探讨了数组作为方法参数与返回值的使用，深入理解了深浅拷贝的区别，并学习了如何使用System.arraycopy()和Arrays.copyOf()实现数组的动态扩展。这些操作对于处理复杂数组操作以及优化程序性能非常有帮助。

下期预告：6. 常见数组应用场景

在下一期内容中，我们将探讨数组在实际应用中的常见场景，包括排序、搜索、去重、合并等。通过这些实际操作，我们将进一步加深对数组的理解，并学习如何将数组高效地应用于实际项目中。

最后

  大家如果觉得看了本文有帮助的话，麻烦给不熬夜崽崽点个三连（点赞、收藏、关注）支持一下哈，大家的支持就是我写作的无限动力。

avatar
文章
阅读
粉丝