javaSE: System.arraycopy

在 StringBuilder, StringBuffer, ArrayList, Arrays等类的源码中有很多System.arraycopy的方法调用

Source code:

/**
     * Copies an array from the specified source array, beginning at the
     * specified position, to the specified position of the destination array.
     * A subsequence of array components are copied from the source
     * array referenced by <code>src</code> to the destination array
     * referenced by <code>dest</code>. The number of components copied is
     * equal to the <code>length</code> argument. The components at
     * positions <code>srcPos</code> through
     * <code>srcPos+length-1</code> in the source array are copied into
     * positions <code>destPos</code> through
     * <code>destPos+length-1</code>, respectively, of the destination
     * array.
     * <p>
     * If the <code>src</code> and <code>dest</code> arguments refer to the
     * same array object, then the copying is performed as if the
     * components at positions <code>srcPos</code> through
     * <code>srcPos+length-1</code> were first copied to a temporary
     * array with <code>length</code> components and then the contents of
     * the temporary array were copied into positions
     * <code>destPos</code> through <code>destPos+length-1</code> of the
     * destination array.
     * <p>
     * If <code>dest</code> is <code>null</code>, then a
     * <code>NullPointerException</code> is thrown.
     * <p>
     * If <code>src</code> is <code>null</code>, then a
     * <code>NullPointerException</code> is thrown and the destination
     * array is not modified.
     * <p>
     * Otherwise, if any of the following is true, an
     * <code>ArrayStoreException</code> is thrown and the destination is
     * not modified:
     * <ul>
     * <li>The <code>src</code> argument refers to an object that is not an
     *     array.
     * <li>The <code>dest</code> argument refers to an object that is not an
     *     array.
     * <li>The <code>src</code> argument and <code>dest</code> argument refer
     *     to arrays whose component types are different primitive types.
     * <li>The <code>src</code> argument refers to an array with a primitive
     *    component type and the <code>dest</code> argument refers to an array
     *     with a reference component type.
     * <li>The <code>src</code> argument refers to an array with a reference
     *    component type and the <code>dest</code> argument refers to an array
     *     with a primitive component type.
     * </ul>
     * <p>
     * Otherwise, if any of the following is true, an
     * <code>IndexOutOfBoundsException</code> is
     * thrown and the destination is not modified:
     * <ul>
     * <li>The <code>srcPos</code> argument is negative.
     * <li>The <code>destPos</code> argument is negative.
     * <li>The <code>length</code> argument is negative.
     * <li><code>srcPos+length</code> is greater than
     *     <code>src.length</code>, the length of the source array.
     * <li><code>destPos+length</code> is greater than
     *     <code>dest.length</code>, the length of the destination array.
     * </ul>
     * <p>
     * Otherwise, if any actual component of the source array from
     * position <code>srcPos</code> through
     * <code>srcPos+length-1</code> cannot be converted to the component
     * type of the destination array by assignment conversion, an
     * <code>ArrayStoreException</code> is thrown. In this case, let
     * <b><i>k</i></b> be the smallest nonnegative integer less than
     * length such that <code>src[srcPos+</code><i>k</i><code>]</code>
     * cannot be converted to the component type of the destination
     * array; when the exception is thrown, source array components from
     * positions <code>srcPos</code> through
     * <code>srcPos+</code><i>k</i><code>-1</code>
     * will already have been copied to destination array positions
     * <code>destPos</code> through
     * <code>destPos+</code><i>k</I><code>-1</code> and no other
     * positions of the destination array will have been modified.
     * (Because of the restrictions already itemized, this
     * paragraph effectively applies only to the situation where both
     * arrays have component types that are reference types.)
     *
     * @param      src      the source array.
     * @param      srcPos   starting position in the source array.
     * @param      dest     the destination array.
     * @param      destPos  starting position in the destination data.
     * @param      length   the number of array elements to be copied.
     * @exception  IndexOutOfBoundsException  if copying would cause
     *               access of data outside array bounds.
     * @exception  ArrayStoreException  if an element in the <code>src</code>
     *               array could not be stored into the <code>dest</code> array
     *               because of a type mismatch.
     * @exception  NullPointerException if either <code>src</code> or
     *               <code>dest</code> is <code>null</code>.
     */
    public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);

我的测试:

public class ArrayCopy {
    public static void main(String[] args) {
        User[] users = new User[]{new User(1, "admin", "admin@gmail.com"),
        new User(2, "lei", "lei@163.com"),
        new User(3, "fff", "fff@163.com")};

        User[] target = new User[users.length];
        System.arraycopy(users,0,target,0,users.length);
        System.out.println("源对象和目标对象物理地址是否相同: " );
        System.out.println((users[0] == target[0])? "相同: 浅拷贝":"不同: 深拷贝");

        target[0].setEmail("admin@163.com");
        System.out.println("修改目标对象属性值后，源对象users: ");
        for (User user : users) {
            System.out.println(user);
        }

        Integer[] integers = new Integer[]{1,2,3,4,5};
        Integer[] dest = new Integer[integers.length];
        System.arraycopy(integers,0,dest,0,integers.length);
        System.out.println("源int数组和目标数组物理地址是否相同: " );
        System.out.println((users[0] == target[0])? "相同: 浅拷贝":"不同: 深拷贝");

        dest[0] = 999;
        System.out.println("修改目标数组后, 源数组: ");
        for (Integer integer : integers) {
            System.out.print(integer);
        }
    }
}

结果:

源对象和目标对象物理地址是否相同: 
相同: 浅拷贝
修改目标对象属性值后，源对象users: 
User{id=1, username='admin', email='admin@163.com'}
User{id=2, username='lei', email='lei@163.com'}
User{id=3, username='fff', email='fff@163.com'}
源int数组和目标数组物理地址是否相同: 
相同: 浅拷贝
修改目标数组后, 源数组: 
12345

结论

i.e. System提供了一个native方法 System.arraycopy()深浅拷贝，实现数组之间的复制；

1. 对于一维primitive type来说是很典型的pass-by-value, 复制传递修改副本不会影响原来的值；
2. 一维数组存放的是对象的时候，复制结果是一个一维引用变量传递给副本的数组，改变副本的值会影响源数组。

public class User {

    private Integer id;
    private String username;
    private String email;

    public User () {}

    public User(Integer id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}