Java数组反转案例怎么实现

本文目录导读：

1. 基础方法：双指针法（推荐）
2. 创建新数组方法
3. 使用Collections工具类（适配对象数组）
4. 递归方法
5. 字符串数组反转示例
6. 方法对比
7. 完整示例代码
8. 运行结果

我来介绍几种Java数组反转的实现方法：

基础方法：双指针法（推荐）

public class ArrayReverse {
    public static void reverseArray(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            // 交换左右两个元素
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            // 移动指针
            left++;
            right--;
        }
    }
    // 测试代码
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println("原始数组：" + Arrays.toString(arr));
        reverseArray(arr);
        System.out.println("反转后：" + Arrays.toString(arr));
    }
}

创建新数组方法

public static int[] reverseArrayNew(int[] arr) {
    int[] reversed = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        reversed[i] = arr[arr.length - 1 - i];
    }
    return reversed;
}
// 使用示例
int[] original = {1, 2, 3, 4, 5};
int[] reversed = reverseArrayNew(original);

使用Collections工具类（适配对象数组）

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public static Integer[] reverseUsingCollections(Integer[] arr) {
    List<Integer> list = Arrays.asList(arr);
    Collections.reverse(list);
    return list.toArray(new Integer[0]);
}
// 使用示例
Integer[] arr = {1, 2, 3, 4, 5};
Integer[] reversed = reverseUsingCollections(arr);
System.out.println(Arrays.toString(reversed)); // [5, 4, 3, 2, 1]

递归方法

public static void reverseRecursive(int[] arr, int left, int right) {
    if (left >= right) {
        return;
    }
    // 交换元素
    int temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;
    // 递归处理剩余部分
    reverseRecursive(arr, left + 1, right - 1);
}
// 使用示例
int[] arr = {1, 2, 3, 4, 5};
reverseRecursive(arr, 0, arr.length - 1);

字符串数组反转示例

public class StringArrayReverse {
    public static void main(String[] args) {
        String[] strArr = {"A", "B", "C", "D"};
        System.out.println("原始数组：" + Arrays.toString(strArr));
        for (int i = 0; i < strArr.length / 2; i++) {
            int j = strArr.length - 1 - i;
            String temp = strArr[i];
            strArr[i] = strArr[j];
            strArr[j] = temp;
        }
        System.out.println("反转后：" + Arrays.toString(strArr));
    }
}

方法对比

完整示例代码

import java.util.Arrays;
public class ArrayReverseDemo {
    // 双指针法（推荐）
    public static void reverse(int[] arr) {
        int left = 0, right = arr.length - 1;
        while (left < right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
    // 通用方法：支持任何类型数组
    public static <T> void reverse(T[] arr) {
        int left = 0, right = arr.length - 1;
        while (left < right) {
            T temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
    public static void main(String[] args) {
        // 测试整数数组
        int[] intArr = {1, 2, 3, 4, 5};
        System.out.println("原数组：" + Arrays.toString(intArr));
        reverse(intArr);
        System.out.println("反转后：" + Arrays.toString(intArr));
        // 测试字符串数组
        String[] strArr = {"Hello", "World", "Java"};
        System.out.println("\n原数组：" + Arrays.toString(strArr));
        reverse(strArr);
        System.out.println("反转后：" + Arrays.toString(strArr));
    }
}

运行结果

原数组：[1, 2, 3, 4, 5]
反转后：[5, 4, 3, 2, 1]
原数组：[Hello, World, Java]
反转后：[Java, World, Hello]

推荐使用双指针法，因为它的时间复杂度为O(n)，空间复杂度为O(1)，是最优的解决方案。