Java数组反转案例怎么实现

wen java案例 2026-07-02 25

本文目录导读：

Java数组反转案例怎么实现

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

我来介绍几种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));
    }
}

方法对比

方法	优点	缺点	适用场景
双指针法	空间复杂度O(1)，效率高	修改原数组	大多数场景推荐
创建新数组	不修改原数组	空间复杂度O(n)	需要保留原数组
Collections工具类	代码简洁	只适用于对象数组	简单测试使用
递归方法	思路清晰	可能栈溢出	学习递归概念

完整示例代码

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)，是最优的解决方案。