java克隆之浅层克隆与深层克隆

最新推荐文章于 2025-03-17 08:35:52 发布

search_forever

最新推荐文章于 2025-03-17 08:35:52 发布

阅读量335

点赞数

分类专栏： java 文章标签： java 克隆

本文链接：https://blog.youkuaiyun.com/search_forever/article/details/78405680

版权

java 专栏收录该内容

5 篇文章

订阅专栏

本文通过具体示例对比了浅层克隆与深度克隆的区别。浅层克隆仅复制对象的基本属性，引用型属性仍指向同一对象；而深度克隆则完全复制对象及其所有属性，确保对象间完全独立。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、浅层克隆

public class Shallow implements Cloneable
{
    int age = 0;
    // 存在类属性
    Inner in = new Inner();

    public static void main(String[] args)
    {
        Shallow s = new Shallow();
        Shallow s2 = s.clone();
        s2.age = 1;
        s2.in.token = 1;
        System.out.println(s);// Shallow [age=0, in=Inner [token=1]]
        System.out.println(s2);// Shallow [age=1, in=Inner [token=1]]
        System.out.println(s.in.getWhichObject());// com.lv.test.abstractTest.Shallow$Inner@6fd46259
        System.out.println(s2.in.getWhichObject());// com.lv.test.abstractTest.Shallow$Inner@6fd46259
    }

    /**
     * 浅层复制
     * 
     * 对于类属性，只会复制引用
     */
    @Override
    public Shallow clone()
    {
        try
        {
            return (Shallow) super.clone();
        } catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public String toString()
    {
        return "Shallow [age=" + age + ", in=" + in + "]";
    }

    class Inner
    {
        int token = 0;

        @Override
        public String toString()
        {
            return "Inner [token=" + token + "]";
        }

        public String getWhichObject()
        {
            return super.toString();
        }
    }
}

上边代码中的克隆方法调用的是基类Object的克隆方法。Object的克隆是浅层克隆。通过main方法的执行，可以发现，在浅层克隆中，克隆对象与原对象并不是完全独立的，其基本属性（int，String等）是独立的，而起引用型属性指向同一对象in。当克隆对象改变in的属性时，原对象也会发生改变。

二、深度克隆

public class Deep implements Serializable
{
    private static final long serialVersionUID = 1L;

    int token = 0;
    // 引用型属性
    Inner in = new Inner();

    public static void main(String[] args)
    {
        Deep s = new Deep();
        Deep s2 = s.clone();
        s2.token = 1;
        s2.in.token = 1;
        System.out.println(s);// Deep [token=0, in=Inner [token=0]]
        System.out.println(s2);// Deep [token=1, in=Inner [token=1]]
        System.out.println(s.in.getWhichObject());// com.lv.test.abstractTest.Deep$Inner@51d9d7ab
        System.out.println(s2.in.getWhichObject());// com.lv.test.abstractTest.Deep$Inner@248a4156
    }

    /**
     * 深度克隆
     */
    public Deep clone()
    {
        ByteArrayOutputStream baos = null;
        ObjectInputStream ois = null;
        try
        {
            new ObjectOutputStream(baos = new ByteArrayOutputStream()).writeObject(this);
            // 从流里读出来
            ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
            return (Deep) ois.readObject();
        } catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public String toString()
    {
        return "Deep [token=" + token + ", in=" + in + "]";
    }

    class Inner implements Serializable
    {
        private static final long serialVersionUID = 1L;

        int token = 0;

        @Override
        public String toString()
        {
            return "Inner [token=" + token + "]";
        }

        public String getWhichObject()
        {
            return super.toString();
        }
    }
}

通过流将对象完全复制一份。通过main方法可以看到前后两个对象的in属性的内存地址是不一样的。