AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

工作三年，小胖连 Clone 源码都没读过？真的菜！（下）

2022-05-20 113
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 工作三年，小胖连 Clone 源码都没读过？真的菜！

5. 深克隆还有哪些实现方式？

深克隆的实现方式很多，总的来说有以下几种：


  • 所有对象都实现克隆方法。
  • 通过构造方法实现深克隆。
  • 使用 JDK 自带的字节流。
  • 使用第三方工具实现，比如：Apache Commons Lang。
  • 使用 JSON 工具类实现，比如：Gson，FastJSON 等等。


1、有对象都实现克隆方法


/**
 * Project Name:review_java <br/>
 * Package Name:com.nasus.clone <br/>
 * Date:2021/1/31 20:57 <br/>
 *
 * @author <a href="turodog@foxmail.com">chenzy</a><br/>
 */
public class DeepCloneOneExample {
    static class User implements Cloneable {
        public User() {
        }
        public User(Integer age, String name, Address address) {
            this.age = age;
            this.name = name;
            this.address = address;
        }
        // 年龄
        private Integer age;
        // 名称
        private String name;
        // 地址
        private Address address;
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Address getAddress() {
            return address;
        }
        public void setAddress(Address address) {
            this.address = address;
        }
        @Override
        protected Object clone() throws CloneNotSupportedException {
            User user = (User) super.clone();
            // 引用类型克隆赋值
            user.setAddress((Address) this.address.clone());
            return user;
        }
    }
    static class Address implements Cloneable {
        public Address() {
        }
        public Address(String province, String city) {
            this.province = province;
            this.city = city;
        }
        // 省份
        private String province;
        // 城市
        private String city;
        public String getProvince() {
            return province;
        }
        public void setProvince(String province) {
            this.province = province;
        }
        public String getCity() {
            return city;
        }
        public void setCity(String city) {
            this.city = city;
        }
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return (Address) super.clone();
        }
    }
    public static void main(String[] args) throws CloneNotSupportedException {
        // 创建被赋值对象
        Address address = new Address("广东", "广州");
        User userOne = new User(22, "clone", address);
        // 克隆 userOne 对象
        User userTwo = (User) userOne.clone();
        // 修改原型对象
        userOne.getAddress().setCity("清远");
        // 输出 p1 和 p2 地址信息
        System.out.println("userOne:" + userOne.getAddress().getCity() +
                "，userTwo:" + userTwo.getAddress().getCity());
    }
}


运行结果：


userOne:清远，userTwo:广州


可以看到，修改了原型对象的引用对象并没有改变克隆对象的引用对象。说明两者引用对象已经不是同一个引用对象了，所以是深克隆。


2、通过构造方法实现深克隆


《Effective Java》 中「推荐使用构造器（Copy Constructor）来实现深克隆，如果构造器的参数为基本数据类型或字符串类型则直接赋值，如果是对象类型，则需要重新 new 一个对象」，实现代码如下：


/**
 * Project Name:review_java <br/>
 * Package Name:com.nasus.clone <br/>
 * Date:2021/1/31 21:16 <br/>
 *
 * @author <a href="turodog@foxmail.com">chenzy</a><br/>
 */
public class DeepCloneSecondExample {
    static class User {
        public User() {
        }
        public User(Integer age, String name, Address address) {
            this.age = age;
            this.name = name;
            this.address = address;
        }
        // 年龄
        private Integer age;
        // 名称
        private String name;
        // 地址
        private Address address;
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Address getAddress() {
            return address;
        }
        public void setAddress(Address address) {
            this.address = address;
        }
    }
    static class Address {
        public Address() {
        }
        public Address(String province, String city) {
            this.province = province;
            this.city = city;
        }
        // 省份
        private String province;
        // 城市
        private String city;
        public String getProvince() {
            return province;
        }
        public void setProvince(String province) {
            this.province = province;
        }
        public String getCity() {
            return city;
        }
        public void setCity(String city) {
            this.city = city;
        }
    }
    public static void main(String[] args) throws CloneNotSupportedException {
        // 创建对象
        Address address = new Address("广东", "广州");
        User userOne = new User(22, "clone", address);
        // 调用构造函数克隆对象
        User userTwo = new User(userOne.getAge(), userOne.getName(),
                new Address(userOne.getAddress().getProvince(), userOne.getAddress().getCity()));
        // 修改原型对象
        userOne.getAddress().setCity("清远");
        // 输出 userOne 和 userOne 地址信息
        System.out.println("userOne:" + userOne.getAddress().getCity() +
                "，userTwo:" + userTwo.getAddress().getCity());
    }
}


运行结果：


userOne:清远，userTwo:广州


3、使用 JDK 自带的字节流


使用 JDK 自带字节流实现，先将要原型对象写入到内存中的字节流，再从这个字节流中读出刚刚存储的信息，作为一个新对象返回，此时这个新对象和原型对象就不存在任何地址上的共享，从而实现深克隆，代码如下：


/**
 * Project Name:review_java <br/>
 * Package Name:com.nasus.clone <br/>
 * Date:2021/1/31 21:25 <br/>
 *
 * @author <a href="turodog@foxmail.com">chenzy</a><br/>
 */
public class DeepCloneThirdExample {
    static class User implements Serializable{
        public User() {
        }
        public User(Integer age, String name, Address address) {
            this.age = age;
            this.name = name;
            this.address = address;
        }
        // 年龄
        private Integer age;
        // 名称
        private String name;
        // 地址
        private Address address;
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Address getAddress() {
            return address;
        }
        public void setAddress(Address address) {
            this.address = address;
        }
    }
    static class Address implements Serializable {
        public Address() {
        }
        public Address(String province, String city) {
            this.province = province;
            this.city = city;
        }
        // 省份
        private String province;
        // 城市
        private String city;
        public String getProvince() {
            return province;
        }
        public void setProvince(String province) {
            this.province = province;
        }
        public String getCity() {
            return city;
        }
        public void setCity(String city) {
            this.city = city;
        }
    }
    /**
     * 通过字节流实现克隆
     */
    static class StreamClone {
        public static <T extends Serializable> T clone(User user) {
            T cloneObj = null;
            try {
                // 写入字节流
                ByteArrayOutputStream bo = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(bo);
                oos.writeObject(user);
                oos.close();
                // 分配内存,写入原始对象,生成新对象
                // 获取上面的输出字节流
                ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
                ObjectInputStream oi = new ObjectInputStream(bi);
                // 返回生成的新对象
                cloneObj = (T) oi.readObject();
                oi.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return cloneObj;
        }
    }
    public static void main(String[] args) throws CloneNotSupportedException {
        // 创建对象
        Address address = new Address("广东", "广州");
        User userOne = new User(22, "clone", address);
        // 调用构造函数克隆对象
        User userTwo = StreamClone.clone(userOne);
        // 修改原型对象
        userOne.getAddress().setCity("清远");
        // 输出 userOne 和 userOne 地址信息
        System.out.println("userOne:" + userOne.getAddress().getCity() +
                "，userTwo:" + userTwo.getAddress().getCity());
    }
}


运行结果：


userOne:清远，userTwo:广州


结果还是一样的，但这里要注意下。由于是通过字节流序列化实现的深克隆，所以每个对象必须能被序列化。也即必须实现 Serializable 接口。


4、通过第三方工具实现深克隆


比如：Apache Commons Lang，实现代码如下：


/**
 * Project Name:review_java <br/>
 * Package Name:com.nasus.clone <br/>
 * Date:2021/1/31 21:41 <br/>
 *
 * @author <a href="turodog@foxmail.com">chenzy</a><br/>
 */
public class DeepCloneFourthExample {
    static class User implements Serializable {
        public User() {
        }
        public User(Integer age, String name, Address address) {
            this.age = age;
            this.name = name;
            this.address = address;
        }
        // 年龄
        private Integer age;
        // 名称
        private String name;
        // 地址
        private Address address;
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Address getAddress() {
            return address;
        }
        public void setAddress(Address address) {
            this.address = address;
        }
    }
    static class Address implements Serializable {
        public Address() {
        }
        public Address(String province, String city) {
            this.province = province;
            this.city = city;
        }
        // 省份
        private String province;
        // 城市
        private String city;
        public String getProvince() {
            return province;
        }
        public void setProvince(String province) {
            this.province = province;
        }
        public String getCity() {
            return city;
        }
        public void setCity(String city) {
            this.city = city;
        }
    }
    public static void main(String[] args) {
        // 创建对象
        Address address = new Address("广东", "广州");
        User userOne = new User(22, "clone", address);
        // 调用 apache.commons.lang 克隆对象
        User userTwo = SerializationUtils.clone(userOne);
        // 修改原型对象
        userOne.getAddress().setCity("清远");
        // 输出 userOne 和 userOne 地址信息
        System.out.println("userOne:" + userOne.getAddress().getCity() +
                "，userTwo:" + userTwo.getAddress().getCity());
    }
}


输出结果：


userOne:清远，userTwo:广州


实际上，这种工作中我自己是用的比较多的一种方法。因为方便，它跟第三种有点像。其实底层是一样的，还是李用字节流实现。


5、使用 JSON 工具类实现


比如 Gson 或者 FastJson 等等，下面以 Gson 为例，实现代码如下：


/**
 * Project Name:review_java <br/>
 * Package Name:com.nasus.clone <br/>
 * Date:2021/1/31 21:58 <br/>
 *
 * @author <a href="turodog@foxmail.com">chenzy</a><br/>
 */
public class DeepCloneFifthExample {
    static class User {
        public User() {
        }
        public User(Integer age, String name, Address address) {
            this.age = age;
            this.name = name;
            this.address = address;
        }
        // 年龄
        private Integer age;
        // 名称
        private String name;
        // 地址
        private Address address;
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Address getAddress() {
            return address;
        }
        public void setAddress(Address address) {
            this.address = address;
        }
    }
    static class Address {
        public Address() {
        }
        public Address(String province, String city) {
            this.province = province;
            this.city = city;
        }
        // 省份
        private String province;
        // 城市
        private String city;
        public String getProvince() {
            return province;
        }
        public void setProvince(String province) {
            this.province = province;
        }
        public String getCity() {
            return city;
        }
        public void setCity(String city) {
            this.city = city;
        }
    }
    public static void main(String[] args) {
        // 创建对象
        Address address = new Address("广东", "广州");
        User userOne = new User(22, "clone", address);
        // 调用 Gson 克隆对象
        Gson gson = new Gson();
        User userTwo = gson.fromJson(gson.toJson(userOne), User.class);
        // 修改原型对象
        userOne.getAddress().setCity("清远");
        // 输出 userOne 和 userTwo 地址信息
        System.out.println("userOne:" + userOne.getAddress().getCity() +
                "，userTwo:" + userTwo.getAddress().getCity());
    }
}


运行结果：


userOne:清远，userTwo:广州


这种方法会先把对象转化成字符串，再从字符串转化成新的对象，因为新对象是从字符串转化而来的，因此不会和原型对象有任何的关联，所以实现了深克隆。


6. 总结

本文介绍了深浅克隆的概念、区别；怎么实现客隆；克隆有啥约定俗成的规则；


Arrays.copy () 是深克隆还是浅克隆；以及深刻龙的几种实现方式。希望对你有帮助～


文章标签：
Java
fastjson
Apache
数据格式
存储
JSON
一个优秀的废人
目录
相关文章
雪碧有白泡泡
|
8月前
|
移动开发 前端开发 JavaScript
童年回忆——开心消消乐（内含源码inscode一键运行）
童年回忆——开心消消乐（内含源码inscode一键运行）
雪碧有白泡泡
98 0
雪碧有白泡泡
|
8月前
|
前端开发 JavaScript Java
童年回忆——捕鱼达人（内含源码inscode一键运行）
童年回忆——捕鱼达人（内含源码inscode一键运行）
雪碧有白泡泡
151 0
一个优秀的废人
|
监控 Java 应用服务中间件
工作三年，小胖问我 SpringBoot 是怎么启动的？真的离谱！
现在的 Java 项目基本都是直接上 SpringBoot，因此在面试中，面试官也会经常问 SpringBoot 相关的问题。比如：SpringBoot 与 Spring 的区别？它的特性？它的启动过程？
一个优秀的废人
233 0
工作三年，小胖问我 SpringBoot 是怎么启动的？真的离谱！
一个优秀的废人
|
Java
工作三年，小胖连 Clone 源码都没读过？真的菜！（上）
哈喽，我是狗哥。这是 Java 源码剖析的第三篇。克隆这个知识点在工作中使用不多，很容易被人忽略。但是面试中的面试官就很常问，因此小伙伴们还是要了解下。
一个优秀的废人
122 0
工作三年，小胖连 Clone 源码都没读过？真的菜！（上）
沉默王二
|
缓存 运维 前端开发
火爆！GitHub 标星 144k 的前后端学习路线，2021 年最新整理，看完后不再迷茫不再徘徊
火爆！GitHub 标星 144k 的前后端学习路线，2021 年最新整理，看完后不再迷茫不再徘徊
沉默王二
5255 3
火爆！GitHub 标星 144k 的前后端学习路线，2021 年最新整理，看完后不再迷茫不再徘徊
码农工程师
|
安全 Java 程序员
Gitee 关闭部分开源仓库；大厂一半以上程序员愿意降薪跳槽；Deno 1.22 发布 | 思否周刊
Gitee 关闭部分开源仓库；大厂一半以上程序员愿意降薪跳槽；Deno 1.22 发布 | 思否周刊
码农工程师
236 0
一个优秀的废人
|
算法 Java
工作三年，小胖连 HashMap 源码都没读过？真的菜！（上）
工作三年，小胖连 HashMap 源码都没读过？真的菜！
一个优秀的废人
137 0
工作三年，小胖连 HashMap 源码都没读过？真的菜！（上）
一个优秀的废人
|
存储 算法 安全
工作三年，小胖连 HashMap 源码都没读过？真的菜！（下）
工作三年，小胖连 HashMap 源码都没读过？真的菜！
一个优秀的废人
127 0
工作三年，小胖连 HashMap 源码都没读过？真的菜！（下）
一个优秀的废人
|
缓存
工作三年，小胖连 String 源码都没读过？真的菜！（上）
工作三年，小胖连 String 源码都没读过？真的菜！
一个优秀的废人
141 0
工作三年，小胖连 String 源码都没读过？真的菜！（上）
一个优秀的废人
|
XML 缓存 JSON
工作三年，小胖连 String 源码都没读过？真的菜！（下）
工作三年，小胖连 String 源码都没读过？真的菜！
一个优秀的废人
174 0
工作三年，小胖连 String 源码都没读过？真的菜！（下）

热门文章

最新文章

  • 1
    为什么说流处理即未来？
  • 2
    【实战】锐捷AC+AP配置WLAN基本服务系列
  • 3
    丰富、连接、待集成—MaxCompute 生态再出发
  • 4
    securecrt克隆会话与sshd 的 MaxSessions
  • 5
    阿里云云端即时渲染技术带您“云考古”
  • 6
    Console-算法[for]-输出等腰三角形
  • 7
    asp.net日期显示 问题
  • 8
    MFC单文档应用程序显示图像
  • 9
    最新10款精美的免费PSD网站模板下载
  • 10
    嵌入式系统工程师的十个不要
  • 1
    《docker基础篇：5.本地镜像发布到阿里云》
    103
  • 2
    《人工智能可视化：数据洞察的新窗口》
    38
  • 3
    《揭秘人工智能数据安全风险评估方法：守护数字未来的关键》
    35
  • 4
    《探秘人工智能之关联规则挖掘：解锁数据背后的隐藏联系》
    30
  • 5
    《数据质量评估方法大揭秘：精准衡量数据价值的关键》
    31
  • 6
    《数据质量：人工智能模型的成败关键》
    20
  • 7
    发现API安全风险，F5随时随地保障应用和API安全
    17
  • 8
    机器学习在网络安全中的防护：智能化的安全屏障
    27
  • 9
    基于AI的运维资源调度：效率与智能的双重提升
    28
  • 10
    2024年终总结：选择错误、加班三月、降薪、面试无果...
    89

    • 相关课程

    更多
  • 4天Docker 实战-1024程序员节创造营公益课
  • 全栈数据工程师养成攻略
  • 面向运维的 python 脚本速成-1024程序员节创造营公益课
  • 场景实践 -新手玩转云计算制作一个浪漫的表白网页
  • 天池新人实战赛o2o优惠券使用预测代码学习分享
  • 深入浅出白话Serverless-1024程序员节创造营公益课

    • 相关电子书

    更多
  • DBA成长沉思录
  • 从码农到CTO再到CEO过程中的认知升级
  • 长安十二时辰背后的技术秘籍

    • 相关实验场景

    更多
  • 重温童年的“五子棋”，赢取专属阿里云Serverless证书
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月