Java里面关于数组拷贝的几种方式

向右看齐 2022-04-06 12:26 224阅读 0赞

在java里面数组拷贝有几种方式：  
  
（1）clone  
  
（2）System.arraycopy  
  
（3）Arrays.copyOf  
  
（4）Arrays.copyOfRange  
  
  
下面分别介绍下他们的用法：  
  
  
（1）clone方法是从Object类继承过来的，基本数据类型（String,boolean,char,byte,short,float,double.long）都可以直接使用clone方法进行克隆，注意String类型是因为其值不可变所以才可以使用。  
  
  
Int类型示例：

````
    `       int a1[]={1,3};
            int a2[]=a1.clone();
    
    
            a1[0]=666;
            System.out.println(Arrays.toString(a1));//[666,3]
            System.out.println(Arrays.toString(a2));//[1,3]
    ````

String 类型示例

````
    `       String[] a1={"a1","a2"};
            String[] a2=a1.clone();
    
            a1[0]="b1";//更变a1元素的值
    
    
            System.out.println(Arrays.toString(a1));//[b1,a2]
            System.out.println(Arrays.toString(a2));//[a1,a2]
    
    
    ````

（2）System.arraycopy方法是一个本地的方法，源码里定义如下：

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

参数含义：  
  
（原数组,原数组的开始位置，目标数组，目标数组的的开始位置，拷贝的个数)  
  
  
用法示例：

````
    `       int  a1[]={1,2,3,4,5};
            int a2[]=new int[10];
    
            System.arraycopy(a1,1,a2,3,3);
            System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]
            System.out.println(Arrays.toString(a2));//[0, 0, 0, 2, 3, 4, 0, 0, 0, 0]
    ````

注意这个方法，需要我们自己new一个新的数组  
  
（3）Arrays.copyOf底层其实也是用的System.arraycopy  
源码如下：

````
        public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
       
            @SuppressWarnings("unchecked")
            T[] copy = ((Object)newType == (Object)Object[].class)
                ? (T[]) new Object[newLength]
                : (T[]) Array.newInstance(newType.getComponentType(), newLength);
            System.arraycopy(original, 0, copy, 0,
                             Math.min(original.length, newLength));
            return copy;
        }
    ````

参数含义：  
  
（原数组，拷贝的个数）  
  
  
用法示例：

````
     `       int  a1[]={1,2,3,4,5};
            int a2[]=Arrays.copyOf(a1,3);
    
    
            System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]
            System.out.println(Arrays.toString(a2));//[1, 2, 3]
    ````

这个方法不需要我们new新的数组  
  
  
（4）Arrays.copyOfRange底层其实也是用的System.arraycopy，只不过封装了一个方法  
  
参数含义：  
  
（原数组，开始位置，拷贝的个数）  
  
  
用法示例：

````
    `       int  a1[]={1,2,3,4,5};
            int a2[]=Arrays.copyOfRange(a1,0,1);
    
    
            System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]
            System.out.println(Arrays.toString(a2));//[1]
    ````

最后需要注意的是基本类型的拷贝是不影响原数组的值的，如果是引用类型，就不能这用了，因为数组的拷贝是浅拷贝。  
  
  
那么如何实现对象的深度拷贝呢？  
  
  
（1）实现Cloneable接口，并重写clone方法，注意一个类不实现这个接口，直接使用clone方法是编译通不过的。

````
    public class Dog implements Cloneable {
       
    
        private String id;
        private String name;
    
        //省略getter / setter
    
    
    
        @Override
        public Dog clone() throws CloneNotSupportedException {
       
    
           Dog dog=(Dog)        super.clone();
    
           return dog;
    
        }
    
        }
    ````

示例：

````
    `       Dog d1=new Dog("1","dog1");
            Dog d2=d1.clone();
    
            d1.setName("dog1_change");
    
    
            System.out.println(d1);//Dog{id='1', name='dog1_change'}
            System.out.println(d2);//Dog{id='1', name='dog1'}
    
    ````

（2）如果一个类里面，又引用其他的类，其他的类又有引用别的类，那么想要深度拷贝必须所有的类及其引用的类都得实现Cloneable接口，重写clone方法，这样以来非常麻烦，简单的方法是让所有的对象实现序列化接口（Serializable），然后通过序列化的方法来深度拷贝对象。

````
       public Dog myclone() {
       
     6       Dog dog = null;
     7       try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
     8           ByteArrayOutputStream baos = new ByteArrayOutputStream();
     9           ObjectOutputStream oos = new ObjectOutputStream(baos);
    10           oos.writeObject(this);
    11 　　　　　　// 将流序列化成对象
    12           ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    13           ObjectInputStream ois = new ObjectInputStream(bais);
    14           dog = (Dog) ois.readObject();
    15       } catch (IOException e) {
       
    16           e.printStackTrace();
    17       } catch (ClassNotFoundException e) {
       
    18           e.printStackTrace();
    19       }
    20       return dog;
    21   }
    ````

总结：  
  
本文介绍了关于Java里面的数组拷贝的几种方式和用法，并给出了如何在Java里面实现对象的深度拷贝，注意除非必需，一般情况下不要使用对象的深度拷贝，因为性能较差。除了自己实现深度拷贝的功能外，网上也有一些开源的工具类也集成了这些功能，如Apache Common Lang3，但原理都大同小异，感兴趣的同学可以自己去学习下。  
  
\[b\]\[color=green\]\[size=large\] 有什么问题可以扫码关注微信公众号：我是攻城师(woshigcs)，在后台留言咨询。 技术债不能欠，健康债更不能欠， 求道之路，与君同行。 \[/size\]\[/color\]\[/b\] \[img\]http://dl2.iteye.com/upload/attachment/0104/9948/3214000f-5633-3c17-a3d7-83ebda9aebff.jpg\[/img\]