System.arraycopy的用法

刚刚遇到数组拼接的问题，上网搜到System.arraycopy方法，简单学习了一下，分享一下。

api是这样描述的：

arraycopy

public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。从 src 引用的源数组到 dest 引用的目标数组，数组组件的一个子序列被复制下来。被复制的组件的编号等于 length 参数。源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。

如果参数 src 和 dest 引用相同的数组对象，则复制的执行过程就好像首先将 srcPos 到srcPos+length-1 位置的组件复制到一个带有 length 组件的临时数组，然后再将此临时数组的内容复制到目标数组的destPos 到 destPos+length-1 位置一样。

If 如果 dest 为 null，则抛出 NullPointerException 异常。

如果 src 为 null, 则抛出 NullPointerException 异常，并且不会修改目标数组。

否则，只要下列任何情况为真，则抛出 ArrayStoreException 异常并且不会修改目标数组：

• src 参数指的是非数组对象。
• dest 参数指的是非数组对象。
• src 参数和 dest 参数指的是那些其组件类型为不同基本类型的数组。
• src 参数指的是具有基本组件类型的数组且 dest 参数指的是具有引用组件类型的数组。
• src 参数指的是具有引用组件类型的数组且 dest 参数指的是具有基本组件类型的数组。

否则，只要下列任何情况为真，则抛出 IndexOutOfBoundsException 异常，并且不会修改目标数组：

• srcPos 参数为负。
• destPos 参数为负。
• length 参数为负。
• srcPos+length 大于 src.length，即源数组的长度。
• destPos+length 大于 dest.length，即目标数组的长度。

否则，如果源数组中 srcPos 到 srcPos+length-1 位置上的实际组件通过分配转换并不能转换成目标数组的组件类型，则抛出ArrayStoreException 异常。在这种情况下，将 k 设置为比长度小的最小非负整数，这样就无法将src[srcPos+k] 转换为目标数组的组件类型；当抛出异常时，从 srcPos 到srcPos+k-1 位置上的源数组组件已经被复制到目标数组中的 destPos 到destPos+k-1 位置，而目标数组中的其他位置不会被修改。（因为已经详细说明过的那些限制，只能将此段落有效地应用于两个数组都有引用类型的组件类型的情况。）

参数：

src - 源数组。

srcPos - 源数组中的起始位置。

dest - 目标数组。

destPos - 目标数据中的起始位置。

length - 要复制的数组元素的数量。

抛出：

IndexOutOfBoundsException - 如果复制会导致对数组范围以外的数据的访问。

ArrayStoreException - 如果因为类型不匹配而使得无法将 src 数组中的元素存储到 dest 数组中。

NullPointerException - 如果 src 或 dest 为 null。

前面写的有点复杂，看参数基本就可以看出用法了，下面写一个简单的例子：

public class Test {

    public static void main(String[] args) {
        byte[] bytes1 = new byte[] { 1, 2, 3, 4 };
        byte[] bytes2 = new byte[] { 5, 6, 7, 8 };
        System.arraycopy(bytes1, 1, bytes2, 0, 2);
        for (int i = 0; i < bytes2.length; i++) {
            System.out.print(bytes2[i] + " ");
        }
    }
}

运行打印结果： 2 3 7 8
从结果可以看出，System.arraycopt(bytes1, 1, bytes2, 0, 2)把bytes1的部分内容拷贝到bytes2中，1为bytes1开始拷贝的下标，0为bytes2被覆盖开始下标，2为拷贝的数量。

下面是两个小应用：

1.获取数组一部分

public class Test {

    public static void main(String[] args) {
        byte[] bytes1 = new byte[] { 1, 2, 3, 4 };
        byte[] bytes2 = getPartOfBytes(bytes1, 2, 2);
        for (int i = 0; i < bytes2.length; i++) {
            System.out.print(bytes2[i] + " ");
        }
    }

    /**
     * 截取数组
     * 
     * @param b 源数组
     * @param begin 开始截取下标
     * @param size 截取大小
     * @return byte[]
     */
    private static byte[] getPartOfBytes(byte[] b, int begin, int size) {
        byte[] b1 = new byte[size];
        System.arraycopy(b, begin, b1, 0, size);
        return b1;
    }
}

2.连接两个数组

public class Test {

    public static void main(String[] args) {
        byte[] bytes1 = new byte[] { 1, 2, 3, 4 };
        byte[] bytes2 = new byte[] { 5, 6, 7, 8 };
        byte[] bytes3 = collectTwoBytes(bytes1, bytes2);
        for (int i = 0; i < bytes3.length; i++) {
            System.out.print(bytes3[i] + " ");
        }
    }

    /**
     * 连接两个byte数组
     */
    private static byte[] collectTwoBytes(byte[] b1, byte[] b2) {
        byte[] b3 = new byte[b1.length + b2.length];
        System.arraycopy(b1, 0, b3, 0, b1.length);
        System.arraycopy(b2, 0, b3, b1.length, b2.length);
        return b3;
    }
}