Java中Arrays.copyOf和Arrays.copyOfRange区别

Arrays.copyOf从索引0开始复制并可调整长度，适用于全数组或开头截取；Arrays.copyOfRange可指定起始和结束索引，用于精确截取子数组。

Java中

Arrays.copyOf

和

Arrays.copyOfRange

的核心区别在于它们复制数组的起始位置和范围控制。简单来说，

copyOf

总是从原数组的第一个元素（索引0）开始复制，你可以指定新数组的长度；而

copyOfRange

则允许你精确指定原数组中要复制的起始索引和结束索引，从而截取一个特定的子数组。

解决方案

在我看来，

Arrays.copyOf

和

Arrays.copyOfRange

虽然都用于创建数组的副本，但它们解决的是略有不同的问题场景。

Arrays.copyOf

更像是一个“全盘复制”或“从头开始复制并可能调整大小”的工具。当你需要一个现有数组的完整副本，或者需要一个从原数组开头截取一部分、或者甚至比原数组更长（多余部分用默认值填充）的新数组时，

copyOf

是首选。它内部其实也是调用了

System.arraycopy

，但封装得更简洁，尤其是当你只需要从0开始操作时。

举个例子，如果你有一个

int[] original = {1, 2, 3, 4, 5};

int[] copy = Arrays.copyOf(original, 3);

结果会是

{1, 2, 3}

。

int[] largerCopy = Arrays.copyOf(original, 7);

结果会是

{1, 2, 3, 4, 5, 0, 0}

。

而

Arrays.copyOfRange

则提供了更精细的控制。它允许你从原数组的任意一个位置开始，到任意一个位置结束，截取出一个全新的数组。这在处理数据流、分页或者需要从大数组中提取特定片段时非常有用。它的参数是

original

,

from

(inclusive),

to

(exclusive)。

还是上面的

original

数组：

int[] subArray = Arrays.copyOfRange(original, 1, 4);

结果会是

{2, 3, 4}

。这里从索引1开始（值为2），到索引4之前（值为4）结束。 如果

to

索引超出了原数组的长度，新数组的对应位置也会用默认值填充，这和

copyOf

处理超长的方式一致。

import java.util.Arrays;

public class ArrayCopyComparison {
    public static void main(String[] args) {
        int[] original = {10, 20, 30, 40, 50};

        // 使用 Arrays.copyOf
        // 从索引0开始，复制3个元素
        int[] copyFromStart = Arrays.copyOf(original, 3);
        System.out.println("Arrays.copyOf(original, 3): " + Arrays.toString(copyFromStart)); // 输出: [10, 20, 30]

        // 从索引0开始，复制比原数组更长的长度，多余部分用默认值0填充
        int[] copyAndExpand = Arrays.copyOf(original, 7);
        System.out.println("Arrays.copyOf(original, 7): " + Arrays.toString(copyAndExpand)); // 输出: [10, 20, 30, 40, 50, 0, 0]

        // 使用 Arrays.copyOfRange
        // 从索引1开始 (包含), 到索引4结束 (不包含)
        int[] subArraySpecificRange = Arrays.copyOfRange(original, 1, 4);
        System.out.println("Arrays.copyOfRange(original, 1, 4): " + Arrays.toString(subArraySpecificRange)); // 输出: [20, 30, 40]

        // 从索引2开始 (包含), 到索引7结束 (不包含), 即使7超出了原数组长度
        int[] subArrayExpandRange = Arrays.copyOfRange(original, 2, 7);
        System.out.println("Arrays.copyOfRange(original, 2, 7): " + Arrays.toString(subArrayExpandRange)); // 输出: [30, 40, 50, 0, 0]

        // 尝试复制整个数组，等同于 Arrays.copyOf(original, original.length)
        int[] fullCopyRange = Arrays.copyOfRange(original, 0, original.length);
        System.out.println("Arrays.copyOfRange(original, 0, original.length): " + Arrays.toString(fullCopyRange)); // 输出: [10, 20, 30, 40, 50]
    }
}

何时选择Arrays.copyOf？理解其适用场景与效率

在我的开发实践中，

Arrays.copyOf

通常在我需要对整个数组进行操作，或者只是想简单地从数组开头截取一部分数据时使用。它的语义非常直接：“给我一个从头开始的副本，长度是多少。”这种明确性减少了出错的可能性，尤其是在不需要复杂索引计算的时候。

立即学习“Java免费学习笔记（深入）”；

比如，你可能有一个配置项列表，需要将其传递给一个不允许修改原始列表的方法，这时

Arrays.copyOf(originalList, originalList.length)

就能快速创建一个完整的独立副本。或者，你正在实现一个队列，底层用数组存储，当队列满时需要扩容，

Arrays.copyOf(oldArray, newCapacity)

就非常自然地完成了扩容和数据迁移。

从效率上看，

Arrays.copyOf

和

Arrays.copyOfRange

底层都依赖于Java的

System.arraycopy

方法，这是一个本地（native）方法，效率非常高。所以，在性能方面，两者并没有本质上的优劣，主要取决于你的具体需求。选择哪一个更多是关于代码的可读性和意图表达。如果你的意图就是从数组开头复制，那么用

Arrays.copyOf

比

Arrays.copyOfRange(array, 0, length)

更清晰。

Arrays.copyOfRange的灵活性：如何精确截取数组片段？

Arrays.copyOfRange

的真正价值在于它的灵活性。它赋予了你对数组复制范围的精确控制，就像从一本书中摘录出某个章节一样。这种能力在处理子集数据、实现分页逻辑、或者在算法中需要处理数组的某个特定区间时显得尤为重要。

想象一下，你从数据库查询到了一大批数据，存储在一个数组里。但前端页面只需要显示第10条到第20条数据。这时，你就可以用

Arrays.copyOfRange(allData, 9, 20)

来轻松获取所需的数据片段。注意这里的索引，

from

是包含的，

to

是不包含的，这符合Java集合和数组API的常见约定，初次使用时需要特别留意。

另一个场景是处理文件字节流。你可能读取了一个大文件的所有字节到一个

byte[]

中，但现在需要解析其中某个特定消息头或者数据块，这些数据块位于字节数组的中间某个位置。

Arrays.copyOfRange

就成了你的得力助手，让你能“剪切”出所需的数据块进行独立处理。

这种灵活性也带来了一点点复杂度，主要是对

from

和

to

索引的准确把握。如果

from

或

to

设置不当，可能导致

ArrayIndexOutOfBoundsException

。例如，

from

大于

to

，或者

from

小于0，或者

from

大于原数组长度。不过，

Arrays.copyOfRange

在

to

超出原数组长度时，会智能地用默认值填充，这在某些情况下是很有用的特性。

性能考量与常见陷阱：Arrays复制操作的深层分析

虽然

Arrays.copyOf

和

Arrays.copyOfRange

在大多数情况下都表现出色，因为它们都基于高效的

System.arraycopy

，但在大规模数据操作时，一些细节仍然值得关注。

首先，这些方法执行的是浅拷贝。这意味着如果你的数组存储的是对象引用（例如

String[]

或自定义对象数组），那么新数组中的元素仍然引用着旧数组中相同的对象。修改新数组中的对象，会影响到旧数组中的对象。如果你需要深度拷贝，你必须手动遍历新数组，并为每个元素创建其自身的副本（如果元素本身是可变对象的话）。这是一个非常常见的陷阱，尤其是在不熟悉Java对象引用机制的开发者那里。

其次，关于内存分配。每次调用

copyOf

或

copyOfRange

都会创建一个新的数组对象。这意味着会产生新的内存分配和随之而来的垃圾回收开销。在性能敏感的循环中频繁调用这些方法，可能会导致不必要的性能损耗。在这种情况下，如果可能，考虑复用数组或者直接使用

System.arraycopy

到预先分配好的数组中，以减少对象创建。

例如，如果你知道目标数组的大小是固定的，并且只需要覆盖其中的一部分：

// 假设 targetArray 已经存在且足够大
System.arraycopy(sourceArray, sourceStart, targetArray, targetStart, length);

这种直接使用

System.arraycopy

的方式，避免了每次都创建新数组的开销，尤其适用于固定大小的缓冲区或需要精确控制内存使用的场景。但它也要求你手动处理更多的细节，比如目标数组的容量检查等。

最后，边界条件的错误。

from

和

to

参数的校验非常重要。

• from

  不能小于0。

• from

  不能大于

  original.length

  。

• to

  不能小于

  from

  。

• to

  可以大于

  original.length

  ，此时新数组会用默认值填充。 这些错误通常会导致

  ArrayIndexOutOfBoundsException

  ，在编码时应通过适当的条件判断来规避。例如，在调用前检查

  if (from < 0 || from > original.length || to < from)

  。

总而言之，理解

Arrays.copyOf

和

Arrays.copyOfRange

的细微差别，并结合实际需求选择合适的方法，是编写高效、健壮Java代码的关键一步。同时，对浅拷贝的认识以及对内存和性能的考量，能帮助我们避免一些潜在的问题。