Java案例如何截取数组元素？

本文目录导读：

1. 使用 Arrays.copyOfRange()（推荐）
2. 使用 System.arraycopy()（性能更好）
3. 手动循环（最灵活）
4. 使用 Stream API（Java 8+）
5. 实用工具类
6. 方法对比
7. 最佳实践建议

在Java中,截取数组元素主要有以下几种常用方法：

使用 Arrays.copyOfRange()（推荐）

这是最常用、最安全的方法：

import java.util.Arrays;
public class ArraySliceExample {
    public static void main(String[] args) {
        // 原始数组
        int[] original = {1, 2, 3, 4, 5, 6, 7, 8};
        // 截取索引2到5（不包括5）的元素
        int[] sliced = Arrays.copyOfRange(original, 2, 5);
        System.out.println("原始数组: " + Arrays.toString(original));
        System.out.println("截取数组: " + Arrays.toString(sliced));
        // 输出: [3, 4, 5]
    }
}

使用 System.arraycopy()（性能更好）

适合性能要求较高的场景：

public class ArraySliceExample2 {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        // 创建目标数组
        int[] sliced = new int[4];
        // 从original的索引3开始，复制到sliced数组，共4个元素
        System.arraycopy(original, 3, sliced, 0, 4);
        System.out.println("截取数组: " + java.util.Arrays.toString(sliced));
        // 输出: [4, 5, 6, 7]
    }
}

手动循环（最灵活）

适合需要自定义处理的情况：

public class ArraySliceExample3 {
    public static int[] sliceArray(int[] array, int start, int end) {
        // 参数验证
        if (array == null || start < 0 || end > array.length || start >= end) {
            return new int[0];
        }
        int newLength = end - start;
        int[] result = new int[newLength];
        // 手动复制
        for (int i = 0; i < newLength; i++) {
            result[i] = array[start + i];
        }
        return result;
    }
    public static void main(String[] args) {
        int[] original = {10, 20, 30, 40, 50, 60};
        int[] sliced = sliceArray(original, 2, 5);
        System.out.println("截取数组: " + java.util.Arrays.toString(sliced));
        // 输出: [30, 40, 50]
    }
}

使用 Stream API（Java 8+）

函数式编程风格：

import java.util.Arrays;
public class ArraySliceExample4 {
    public static void main(String[] args) {
        int[] original = {5, 10, 15, 20, 25, 30, 35};
        // 截取索引1到4的元素
        int[] sliced = Arrays.stream(original, 1, 5)
                            .toArray();
        System.out.println("截取数组: " + Arrays.toString(sliced));
        // 输出: [10, 15, 20, 25]
    }
}

实用工具类

封装一个通用的数组截取工具：

public class ArrayUtil {
    // 通用数组截取方法
    public static int[] slice(int[] array, int start) {
        return slice(array, start, array.length);
    }
    public static int[] slice(int[] array, int start, int end) {
        if (array == null || start < 0) {
            return new int[0];
        }
        // 处理边界情况
        start = Math.min(start, array.length);
        end = Math.min(end, array.length);
        if (start >= end) {
            return new int[0];
        }
        int newLength = end - start;
        int[] result = new int[newLength];
        System.arraycopy(array, start, result, 0, newLength);
        return result;
    }
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.out.println("从索引2开始: " + Arrays.toString(slice(arr, 2)));
        System.out.println("从索引1到6: " + Arrays.toString(slice(arr, 1, 6)));
        System.out.println("无效范围: " + Arrays.toString(slice(arr, 5, 3)));
    }
}

方法对比

最佳实践建议

1. 日常使用：优先选择 Arrays.copyOfRange()
2. 性能敏感：使用 System.arraycopy()
3. 需要大量截取操作：建议封装工具类
4. 注意边界处理：始终检查索引是否在有效范围内

选择哪种方法取决于你的具体需求，如性能要求、代码可读性、是否需要特殊处理等。