前言:深拷贝和浅拷贝的区别是什么？浅拷贝：被复制的对象的所有变量都含有原来对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。深拷贝：被复制对象的所有变量都含有与原来对象相同的值，而那些引用对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

浅拷贝

　　无论是浅拷贝还是深拷贝都要用到clone()方法，所有类都继承于Object，clone方法定义于Object类中但没有实现，

而如果要使用clone方法，根据源码则必须实现Cloneable接口，java.lang.Cloneable是一个标志性接口不包含任何方法，根据注释clone方法是由C或C++其他本地语言实现的。

  * @return     a clone of this instance.

     * @throws  CloneNotSupportedException  if the object's class does not

     *               support the {@code Cloneable} interface. Subclasses

     *               that override the {@code clone} method can also

     *               throw this exception to indicate that an instance cannot

     *               be cloned.

     * @see java.lang.Cloneable

     */

    protected native Object clone() throws CloneNotSupportedException;

　　实现浅拷贝：

package yunche.test.copy;

/**

 * @ClassName: Dog

 * @Description:

 * @author: yunche

 * @date: 2018/08/25

 */

public class Dog implements Cloneable

{

    public String color;

    public int age;

    /**

     * 引用变量

     */

    public Erha erha;

    public static void main(String[] args) throws CloneNotSupportedException

    {

        Dog d = new Dog();

        d.color="yellow";

        d.age=2;

        d.erha = new Erha();

        d.erha.name = "二哈";

        //此时clone方法为浅拷贝

        Dog copyDog = (Dog)d.clone();

        System.out.println(copyDog.color);

        System.out.println(copyDog.age);

        System.out.println(copyDog.erha.name);

        //hashcode不同，创建了新对象

        System.out.println(d==copyDog);

        System.out.println(d.hashCode());

        System.out.println(copyDog.hashCode());

        //hashcode相同，没有创建新的erha对象，只是复制了引用

        System.out.println(copyDog.erha==d.erha);

        System.out.println(copyDog.erha.hashCode());

        System.out.println(d.erha.hashCode());

    }

    private static class Erha

    {

         String name;

    }

}

深拷贝

　　深拷贝对于基本数据类型进行值传递，对引用数据类型，创建一个新的对象。并复制其内容。怎么实现深拷贝呢？通常的方案有两种：1.序列化这个对象，再反序列化回来，就可以得到这个新的对象，序列化的规则需要我们自己来写。2.重写clone方法，我们可以对其内部引用类型的变量，再进行一次clone()。

序列化方式

　序列化需要实现Serializable接口。

package yunche.test.copy;

import java.io.*;

/**

 * @ClassName: Dog

 * @Description:

 * @author: yunche

 * @date: 2018/08/25

 */

public class Dog implements Cloneable, Serializable

{

    public String color;

    public int age;

    /**

     * 引用变量

     */

    public Erha erha;

    public static void main(String[] args) throws CloneNotSupportedException

    {

        Dog d = new Dog();

        d.color="yellow";

        d.age=2;

        d.erha = new Erha();

        d.erha.name = "二哈";

        Dog copyDog = (Dog)d.deepClone();

        System.out.println(copyDog.color);

        System.out.println(copyDog.age);

        System.out.println(copyDog.erha.name);

        //hashcode不同，创建了新对象

        System.out.println(d==copyDog);

        System.out.println(d.hashCode());

        System.out.println(copyDog.hashCode());

        //hashcode不同，创建新的erha对象，实现了深拷贝

        System.out.println(copyDog.erha==d.erha);

        System.out.println(copyDog.erha.hashCode());

        System.out.println(d.erha.hashCode());

    }

    public Object deepClone()

    {

        File f = new File("dog.obj");

        Object obj =null;

        try(FileOutputStream fos = new FileOutputStream(f);

            ObjectOutputStream oos = new ObjectOutputStream(fos);

            FileInputStream fis = new FileInputStream(f);

            ObjectInputStream ois = new ObjectInputStream(fis))

        {

            oos.writeObject(this);

            obj = ois.readObject();

        }

        catch (FileNotFoundException e)

        {

            e.printStackTrace();

        }

        catch (IOException e)

        {

            e.printStackTrace();

        }

        catch (ClassNotFoundException e)

        {

            e.printStackTrace();

        }

        return obj;

    }

    private static class Erha implements Serializable

    {

         String name;

    }

}

重写clone

package yunche.test.copy;

import java.io.*;

/**

 * @ClassName: Dog

 * @Description:

 * @author: yunche

 * @date: 2018/08/25

 */

public class Dog implements Cloneable

{

    public String color;

    public int age;

    /**

     * 引用变量

     */

    public Erha erha;

    public static void main(String[] args) throws CloneNotSupportedException

    {

        Dog d = new Dog();

        d.color="yellow";

        d.age=2;

        d.erha = new Erha();

        d.erha.name = "二哈";

        //重新clone方法，实现深拷贝

        Dog copyDog = (Dog)d.clone();

        System.out.println(copyDog.color);

        System.out.println(copyDog.age);

        System.out.println(copyDog.erha.name);

        //hashcode不同，创建了新对象

        System.out.println(d==copyDog);

        System.out.println(d.hashCode());

        System.out.println(copyDog.hashCode());

        //hashcode不同，创建新的erha对象，实现了深拷贝

        System.out.println(copyDog.erha==d.erha);

        System.out.println(copyDog.erha.hashCode());

        System.out.println(d.erha.hashCode());

    }

    @Override

    public Object clone()

    {

        try

        {

            Dog dog = (Dog)super.clone();

            dog.erha = (Erha) this.erha.clone();

            return dog;

        }

        catch (CloneNotSupportedException e)

        {

            e.printStackTrace();

        }

        return null;

    }

    public static class Erha implements Cloneable

    {

         String name;

         @Override

         public Object clone()

         {

             try

             {

                 return super.clone();

             }

             catch (CloneNotSupportedException e)

             {

                 e.printStackTrace();

             }

             return null;

         }

    }

}

参考资料

　　https://segmentfault.com/a/1190000010648514

巴特西

浅谈java浅拷贝和深拷贝

浅拷贝

深拷贝

序列化方式

重写clone

参考资料

最新文章

热门文章