JavaSE--Arrays.copyof

背景:

想偷懒一次数组赋值下面多个例子复制下数组就好了..

以为 Arrays.copyof(Arrays.copyof内部调用的是 System.copy, 所以同 Arrays.copy)拷贝出来的数组和原来的数组是独立不干扰的.

然后就悲剧了..

原来copy之后的数组指向原数组的地址.

例:https://blog.csdn.net/qq_27093465/article/details/54970538

 /**

arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);

 * 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
从 源数组src 中复制子序列到 目标数组dest, 子序列的长度由 length参数控制.
     * 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.
从 src 数组中的 srcPos, srcPos+length-1 的元素将会被复制到 dest 数组的 destPos, destPos+length-1 位置.
     * <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.
如果 src 和 dest 引用的是相同的数组,那么复制的过程就是首先从 数组的 srcPos, srcPos+length-1 复制到 length 长度的临时数组,
然后在从临时数组中拷贝内容到这个数组的 destPos, destPos+length-1 的位置.
     * <p>
     * If <code>dest</code> is <code>null</code>, then a
     * <code>NullPointerException</code> is thrown.
如果 dest 是 null, 会抛出 NullPointerException 异常.

* <p> 
* If <code>src</code> is <code>null</code>, then a 
* <code>NullPointerException</code> is thrown and the destination 
* array is not modified. 
如果 src 是 null, 也将会抛出 NullPointException 异常,但是并不会改变 dest 的内容.
* <p> 
* Otherwise, if any of the following is true, an 
* <code>ArrayStoreException</code> is thrown and the destination is 
* not modified: 
另外,下面的情况都会抛出 ArrayStoreException 异常,且都不会修改 dest 的内容.
* <ul> 
* <li>The <code>src</code> argument refers to an object that is not an 
* array. 
　　src 引用的对象不是数组.
* <li>The <code>dest</code> argument refers to an object that is not an 
* array. 
　　dest 引用的对象不是数组.
* <li>The <code>src</code> argument and <code>dest</code> argument refer 
* to arrays whose component types are different primitive types. 
　　src 和 dest 原始类型不同.
* <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. 

另外,下面的情况都会抛出 IndexOutOfBoundsException 异常,且都不会修改 dest 的内容.

* </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. 
　　srcPos 是负数.
* <li>The <code>destPos</code> argument is negative. 
　　destPos 是负数.
* <li>The <code>length</code> argument is negative. 
　　length 是负数.
* <li><code>srcPos+length</code> is greater than 
　　srcPos+length 大于 src 数组的出长度
* <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. 
　　destPos+length 大于 dest 数组的长度
* </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 
另外,如果 src 的元素不能转换成 dest 目标的类型,也会抛出 ArrayStoreException 异常.
* <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);

 import java.util.Arrays;
 
 public class ArrayCopyThink {
 
     public static void main(String[] args) {
 
         User u1 = new User("test1");
         User u2 = new User("test2");
         User u3 = new User("test3");
         User u4 = new User("test4");
         User[] users = {u1, u2, u3, u4};
 
         User u5 = new User("ooo");
         System.out.println("源数组 users: " + Arrays.toString(users));
 
         User[] copyUsers = new User[5];
         copyUsers[0] = u5;
         System.out.println("目标数组 copyUsers: " + Arrays.toString(copyUsers));
 
         System.out.println("将源数组的所有元素拷贝到目标数组的后面..");
         System.arraycopy(users, 0, copyUsers, 1, users.length);
 
         System.out.println("源数组 users: " + Arrays.toString(users));
         System.out.println("目标数组 copyUsers: " + Arrays.toString(copyUsers));
 
         System.out.println("更改拷贝数组拷贝过来的第一个元素,");
         copyUsers[1].setName("###");
         System.out.println("源数组 users: " + Arrays.toString(users));
         System.out.println("目标数组 copyUsers: " + Arrays.toString(copyUsers));
 
     }
 
     static class User {
 
         private String name;
 
         public User(String name) {
             this.name = name;
         }
 
         public String getName() {
             return name;
         }
 
         public void setName(String name) {
             this.name = name;
         }
 
         @Override
         public String toString() {
             return "User{" +
                     "name='" + name + '\'' +
                     '}';
         }
     }
 
 }