Java 数组操作：反转、扩容与缩容

在 Java 中，数组是一种固定长度的数据结构，一旦创建，其大小无法更改。然而，常常在实际编程中，我们需要对数组进行扩容、缩容或其他操作。本文将介绍如何通过 Java 实现数组反转、扩容和缩容的操作，并在代码中演示这些常见的数组操作。

1. 数组反转

数组反转是一个常见的操作，通常用于将数组中的元素顺序颠倒。下面是两种常见的实现方法：

方法 1：利用临时变量交换元素

这种方法通过交换数组的对称元素来实现反转。基本思路是用一个临时变量交换数组两端的元素，然后逐渐向数组的中心靠拢。

public static void main(String[] args) {
        //数组反转01
        int[] arr = new int[]{1, 2, 3, 4, 5};
        System.out.println("反转之前");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        //法1
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;

        }
        System.out.println();
        System.out.println("反转之后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }

解析：

• 在 for 循环中，i 从数组的开始位置逐渐向数组的中间移动。每次通过临时变量 temp 交换当前元素和对称元素的位置。
• 这种方法的时间复杂度是 O(n/2)，即 O(n)，其中 n 是数组的长度。

方法 2：使用双指针法

双指针法利用两个指针分别指向数组的左右两端，然后交换它们所指向的元素，并且逐渐向中间靠拢，直到两个指针相遇。

public static void main(String[] args) {
        //数组反转01
        int[] arr = new int[]{1, 2, 3, 4, 5};
        //法2
        for (int left = 0, right = arr.length - 1; left < right; left++, right--) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        System.out.println();
        System.out.println("反转之后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }

    }

解析：

• left 指针从数组的开始位置，right 指针从数组的末尾位置，两个指针逐步向中间移动。
• 每次交换 left 和 right 所指向的元素，直到 left 和 right 相遇或交错。

测试结果

反转之前
1	2	3	4	5	
法1
反转之后
5	4	3	2	1	
法2
反转之后
1	2	3	4	5

2. 数组扩容

Java 数组一旦初始化，长度是固定的。如果需要动态扩容，可以创建一个新的数组，并将原数组的元素复制到新数组中。假设我们需要为原数组扩容 3 个位置，并将新元素添加到新数组中。

   //数组的扩容，给老数组加上3个值
    public void enlarge() {
        int[] oldArr = new int[]{1, 2, 3, 4, 5};
        int[] newArr = new int[oldArr.length + 3];
        for (int i = 0; i < oldArr.length; i++) {
            newArr[i] = oldArr[i];
        }
        newArr[oldArr.length] = 10;
        newArr[oldArr.length + 1] = 20;
        newArr[oldArr.length + 2] = 30;
        oldArr = newArr;
        System.out.println("扩容之后");
        for (int i = 0; i < oldArr.length; i++) {
            System.out.print(oldArr[i] + "\t");
        }

    }

 测试结果：

扩容之后
1	2	3	4	5	10	20	30

解析：

• 首先创建一个比原数组大的新数组 newArr。
• 使用 for 循环将 oldArr 中的所有元素复制到 newArr 中。
• 添加新的元素 10、20、30。
• 扩容后的数组就变成了 newArr，并将其赋值给 oldArr。

3. 数组缩容

数组缩容通常发生在需要删除数组元素时。例如，删除数组中索引为 2 的元素，我们需要将后面的元素向前移动一位，并将数组的最后一个元素置为 0。

//数组缩容
    //删除数组中索引为2的元素
    public void shrink() {
        int[] oldArr = new int[]{1, 2, 3, 4, 5};
        int index = 2;
        for (int i = index; i < oldArr.length - 1; i++) {
            oldArr[i] = oldArr[i + 1];
        }
        oldArr[oldArr.length - 1] = 0;
        System.out.println("缩容之后");
        for (int i = 0; i < oldArr.length; i++) {
            System.out.print(oldArr[i] + "\t");
        }
    }

测试结果： 

缩容之后
1	2	4	5	0	

 解析：

• 我们需要删除 index 处的元素。通过将后面元素前移一位，覆盖被删除元素。
• 最后，将数组最后一位元素赋值为 0，避免出现残留数据。
• 缩容后的数组包含删除指定元素后的结果。

总结

在 Java 中，数组是一种固定大小的容器，无法动态调整大小。为了满足不同需求，我们可以通过以下几种方式处理数组：

1. 数组反转：可以使用交换法或双指针法实现数组的反转。
2. 数组扩容：当数组需要添加更多元素时，可以创建一个新的数组并将原数组的内容复制到新数组中。
3. 数组缩容：通过删除指定索引的元素并向前移动元素实现数组的缩容。

这些操作不仅是 Java 编程中常见的技术，也是解决实际问题时常用的手段。理解并掌握这些数组操作，可以帮助开发者编写更灵活、实用的代码。