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

一文深入Java浅拷贝和深拷贝

2022-05-16 156
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 一文深入Java浅拷贝和深拷贝

在这里插入图片描述

👨🏻‍🎓博主介绍：大家好，我是芝士味的椒盐，一名在校大学生，热爱分享知识，很高兴在这里认识大家🌟
🌈擅长领域：Java、大数据、运维、电子
🙏🏻如果本文章各位小伙伴们有帮助的话，🍭关注+👍🏻点赞+🗣评论+📦收藏，相应的有空了我也会回访，互助！！！
🤝另本人水平有限，旨在创作简单易懂的文章，在文章描述时如有错，恳请各位大佬指正，在此感谢！！！

@[TOC]

值类型和引用类型

  • 理解浅拷贝之前我们需要分清楚值类型（int、float...）、包装类（Integer、Double...）以及自己定义类等类，其实就就是值类型和引用类型两种.

在这里插入图片描述

  • 就像上面这个图中，int a=1024是值类型的所以是变量a就是直接等于实际的值1024，而object obj1、object obj2显然是引用类型，obj存储的不是实际的对象，而是对象在堆中的地址。

原型模式-浅拷贝和深拷贝图解

在这里插入图片描述

  • 浅拷贝：根据上面来讲解，原型对象在被克隆后克隆出来的新对象和原型对象的地址是不一样的，在克隆出来对象中基础类型的直接复制一份的，也就是说，克隆对象修改值类型和原型对象修改各自的属性是没有半毛钱关系的，而其中的引用对象就不一样了，克隆出来的对象引用地址和原型对象的是同一个，也就说其中任意一个更改引用属性的时候都会影响到对方的属性，都是引用同一个对象。（包装类型比较特殊的引用类型，克隆之后双方都是互不干扰的）。
  • 深拷贝：原型对象在通过深拷贝之后，基础类型仍旧是各自独立的，而各自引用对象的地址指向却是不同的，也就说在克隆对象和原型对象有任意一方修改引用参数都不会影响到对方。

先上个简单的demo

/**
 * <p>
 * 学生卡类
 * </p>
 *
 * @author starrysky
 * @since 2022/2/8
 */
public  class IdCard {
    private String cName;

    public IdCard(String cName) {
        this.cName = cName;
    }

    public String getcName() {
        return cName;
    }

    public void setcName(String cName) {
        this.cName = cName;
    }

    @Override
    public String toString() {
        return "IdCard{" +
                "cName='" + cName + '\'' +
                '}';
    }
}

/**
 * <p>
 * 学生类
 * </p>
 *
 * @author starrysky
 * @since 2022/2/8
 */
public class Student implements  Cloneable {
    private int id;
    private String name;
    private IdCard idCard;

     .....省略get set方法
     
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", idCard=" + idCard +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        IdCard cId = new IdCard("hhhhh");
        Student student1 = new Student(12,"student1", cId);
        Student student2 = (Student) student1.clone();

        student2.setId(1);
        student2.setName("student2");
        student2.idCard.setcName("xxxxx");
        System.out.println(student1);
        System.out.println(student2);


    }
}
  • 运行结果如下：

在这里插入图片描述

  • 包装类型和值类型的如图可知在浅拷贝后是互不相干的，但是我们自定义的IdCard引用对象一个改了就会影响另一个，这就是由于是同一个对象缘由。

那么为什么我们自定义对象是可变包装类又特殊不可变呢？

  • 其原因是遵守不可变原则，即Immutable设计模式：
  1. 类添加final修饰符，保证类不被继承。
  2. 保证所有成员变量必须私有，并且加上final修饰（不可变指的是引用不可变，也就是不可以重新指向其他对象）
  3. 不提供改变成员变量的方法，包括setter
  4. 通过构造器初始化所有成员，进行深拷贝(deep copy)
  5. 在getter方法中，不要直接返回对象本身，而是克隆对象，并返回对象的拷贝
  • 比如我们随便拿一个包装类Double类分析一下
public final class Double extends Number implements Comparable<Double> {
    public static final double POSITIVE_INFINITY = 1.0 / 0.0;

    public static final double NEGATIVE_INFINITY = -1.0 / 0.0;

    public static final double NaN = 0.0d / 0.0;

    public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308

    public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308

    @SuppressWarnings("unchecked")
    public static final Class<Double>   TYPE = (Class<Double>) Class.getPrimitiveClass("double");

    public static String toString(double d) {
        return FloatingDecimal.toJavaFormatString(d);
    }

    public static Double valueOf(String s) throws NumberFormatException {
        return new Double(parseDouble(s));
    }

 
    public static Double valueOf(double d) {
        return new Double(d);
    }

    public static double parseDouble(String s) throws NumberFormatException {
        return FloatingDecimal.parseDouble(s);
    }


    public static boolean isNaN(double v) {
        return (v != v);
    }

    public static boolean isInfinite(double v) {
        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
    }

    public static boolean isFinite(double d) {
        return Math.abs(d) <= DoubleConsts.MAX_VALUE;
    }

    private final double value;


    public Double(double value) {
        this.value = value;
    }


    public Double(String s) throws NumberFormatException {
        value = parseDouble(s);
    }


    public boolean isNaN() {
        return isNaN(value);
    }

    public boolean isInfinite() {
        return isInfinite(value);
    }
  • 首先这个Double类类是使用final关键字修饰表示不可继承，然后所有成员变量都是使用final修饰表示引用不可变，再其次就是不提供setter方法，即满足不可变原则。

如何浅拷贝

  • 如上面IdCard和Student类就是实现Cloneable接口，并且重写了clone的方法，就可以实现。

如何深拷贝

  • 有两种方法：一种继承Cloneable接口或者序列化
  • 继承Cloneable接口
/**
 * <p>
 * 学生卡类
 * </p>
 *
 * @author starrysky
 * @since 2022/2/8
 */
public class IdCard implements Cloneable{
    private  Double cName;

    public IdCard(Double cName) {
        this.cName = cName;
    }

    public Double getcName() {
        return cName;
    }

    public void setcName(Double cName) {
        this.cName = cName;
    }

    @Override
    public String toString() {
        return "IdCard{" +
                "cName='" + cName + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

/**
 * <p>
 * 学生类
 * </p>
 *
 * @author starrysky
 * @since 2022/2/8
 */
public  class Student implements  Cloneable {
    private int id;
    private String name;
    private IdCard idCard;

    public Student(int id, String name, IdCard idCard) {
        this.id = id;
        this.name = name;
        this.idCard = idCard;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public IdCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", idCard=" + idCard +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //需要将引用的对象也clone
        Student student = (Student)super.clone();
        student.idCard = (IdCard)idCard.clone();
        return student;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        IdCard cId = new IdCard(12.5);
        Student student1 = new Student(12,"student1", cId);
        Student student2 = (Student) student1.clone();

        student2.setId(1);
        student2.setName("student2");
        student2.idCard.setcName(10.2);
        System.out.println(student1);
        System.out.println(student2);


    }
}
  • 执行结果：

在这里插入图片描述

  • 使用序列化和反序列化的方式深度拷贝，和Cloneable相比可以解决多层继承带来的深度克隆失效的问题
/**
 * <p>
 * 学生卡类
 * </p>
 *
 * @author starrysky
 * @since 2022/2/8
 */
public class IdCard implements Serializable {

    private static final long serialVersionUID = 1L;

    private  Double cName;

    public IdCard(Double cName) {
        this.cName = cName;
    }

    public Double getcName() {
        return cName;
    }

    public void setcName(Double cName) {
        this.cName = cName;
    }

    @Override
    public String toString() {
        return "IdCard{" +
                "cName='" + cName + '\'' +
                '}';
    }

}

/**
 * <p>
 * 学生类
 * </p>
 *
 * @author starrysky
 * @since 2022/2/8
 */
public  class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private int id;
    private String name;
    private IdCard idCard;

    public Student(int id, String name, IdCard idCard) {
        this.id = id;
        this.name = name;
        this.idCard = idCard;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public IdCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", idCard=" + idCard +
                '}';
    }


    public Student deepClone() {
        Student student = null;
        try {
            // 序列化
             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
             ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
             objectOutputStream.writeObject(this);
             //反序列化
             ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
             ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
             student = (Student) objectInputStream.readObject();
        }catch (ClassNotFoundException | IOException e){
            e.printStackTrace();
        }
        return student;

    }

    public static void main(String[] args) throws CloneNotSupportedException {
        IdCard cId = new IdCard(12.5);
        Student student1 = new Student(12,"student1", cId);
        Student student2 = (Student) student1.deepClone();

        student2.setId(1);
        student2.setName("student2");
        student2.idCard.setcName(10.2);
        System.out.println(student1);
        System.out.println(student2);


    }
}
  • 执行结果：

在这里插入图片描述

集合浅拷贝和深拷贝

LinkedList浅拷贝
  • 通过构造方式
        IdCard ggc = new IdCard(1, "ggc");
        List<IdCard> list1 = new LinkedList<>();
        list1.add(ggc);
        List<IdCard> list2 = new LinkedList<>(list1);
        list2.get(0).setName("mm");
        System.out.println(list1);
        System.out.println(list2);
  • 执行结果：

在这里插入图片描述

  • 通过forEach一个个插入
        IdCard ggc = new IdCard(1, "ggc");
        List<IdCard> list1 = new LinkedList<>();
        list1.add(ggc);
        List<IdCard> list2 = new LinkedList<>();
        list1.forEach(s->list2.add(s));
        list2.get(0).setName("mm");
        System.out.println(list1);
        System.out.println(list2);
  • 执行结果：

在这里插入图片描述

  • 数组通过System.arraycopy
        IdCard ggc = new IdCard(1, "ggc");
        IdCard[] arr1 = new IdCard[]{ggc};
        IdCard[] arr2 = new IdCard[1];
        System.arraycopy(arr1,0,arr2,0,arr1.length);
        arr2[0].setName("hhhh");
        Arrays.asList(arr1).forEach(System.out::println);
        Arrays.asList(arr2).forEach(System.out::println);
  • 执行结果

在这里插入图片描述

LinkedList深拷贝
  • 通过list自带的addAll()方法
        List<Integer> list1 = new LinkedList<>(Arrays.asList(3,5,2,1));
        List<Integer> list2 = new LinkedList<>();
        list2.addAll(list1);
        list2.remove(0);
        System.out.println(list1);
        System.out.println(list2);
  • 执行结果：

在这里插入图片描述

  • 通过序列化和反向序列化

    /**
 * <p>
 *
 * </p>学生卡
 *
 * @author starrysky
 * @since 2022/2/8
 */
public class IdCard implements Serializable {
    private static final long serialVersionUID = 1L;
    private int Id;
    private String name;


    public IdCard(int id, String name) {
        Id = id;
        this.name = name;
    }

    public int getId() {
        return Id;
    }

    public void setId(int id) {
        Id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "IdCard{" +
                "Id=" + Id +
                ", name='" + name + '\'' +
                '}';
    }
}

        public static <T> List<T> deepClone(List<T> source) throws IOException, ClassNotFoundException {
    //序列化
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
    objectOutputStream.writeObject(source);
    //反向序列化
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
    ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream);
    List<T> o = (List<T>)inputStream.readObject();
    return o;

}
        public static void main(String[] args) throws IOException, ClassNotFoundException {

    List<IdCard> list1 = new LinkedList<>();
    list1.add(new IdCard(1,"123"));
    list1.add(new IdCard(2,"1233"));
    List<IdCard> list2 = deepClone(list1);
    list2.remove(0);
    System.out.println(list1);
    System.out.println(list2);
}
  • 执行结果：

在这里插入图片描述

  • 实现Cloneable接口，重写clone方法
    @Override
    public Object clone(){
        IdCard clone =null;
        try {
            clone = (IdCard) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
        IdCard idCard = new IdCard(1, "213");
        IdCard idCard2 = (IdCard) idCard.clone();
        idCard2.setName("gccc");
        System.out.println(idCard);
        System.out.println(idCard2);
  • 执行结果：

在这里插入图片描述

文章标签：
Java
运维
存储
大数据
设计模式
关键词：
Java浅拷贝
Java深拷贝
Java浅拷贝深拷贝
天是蔚蓝色的
目录
相关文章
极客李华
|
6月前
|
Java
Java的浅拷贝与深拷贝
Java的浅拷贝与深拷贝
极客李华
53 0
舒一笑
|
6月前
|
Java Apache
Java中的深拷贝与浅拷贝
Java中的深拷贝与浅拷贝
舒一笑
45 0
秋刀鱼不做梦
|
5月前
|
Java
“深入探讨Java中的对象拷贝：浅拷贝与深拷贝的差异与应用“
“深入探讨Java中的对象拷贝：浅拷贝与深拷贝的差异与应用“
秋刀鱼不做梦
63 5
67vpym2vvkfhs
|
5月前
|
存储 Dubbo Java
一篇文章讲明白Java的深拷贝和浅拷贝
一篇文章讲明白Java的深拷贝和浅拷贝
67vpym2vvkfhs
51 0
还在路上的秃头
|
6月前
|
Java
【JAVA面试题】什么是深拷贝？什么是浅拷贝？
【JAVA面试题】什么是深拷贝？什么是浅拷贝？
还在路上的秃头
78 3
赵广陆
|
Java
Java深拷贝和浅拷贝Map对象
Java深拷贝和浅拷贝Map对象
赵广陆
196 0
Heron
|
Java
【java面试题】- java深拷贝和浅拷贝区别？什么是引用拷贝？
java深拷贝和浅拷贝区别？什么是引用拷贝？
Heron
87 0
flydean程序那些事
|
存储 Java
java深入理解浅拷贝和深拷贝
java深入理解浅拷贝和深拷贝
flydean程序那些事
104 0
云栖号资讯小哥
|
存储 Java
java深入理解浅拷贝和深拷贝
云栖号资讯小哥
605 0
运营研究坊
|
11天前
|
安全 Java 测试技术
Java并行流陷阱：为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱，尤其是指定线程池的问题。文章分析了并行流的设计思想，指出了指定线程池的弊端，并提供了使用CompletableFuture等替代方案。同时，介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
运营研究坊
41 2

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    来聊聊Java项目分层规范
  • 3
    超全面！阿里巴巴最新发布23年秋招200道Java面试题（含答案）
  • 4
    JAVA虚拟机关闭钩子(Shutdown Hook)
  • 5
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 6
    JDK6笔记（5）----JDBC4
  • 7
    （JAVA编程练习）：判断101-200之间有多少个素数，并输出所有素数。
  • 8
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 9
    （十三）java类的继承
  • 10
    How to programmatically new a java class which implements sepecified interface in eclipse plugin development
  • 1
    前端和Java验签以太坊钱包签名实现中心化登录
    1021
  • 2
    零基础轻松入门Java数据库连接（JDBC）
    61
  • 3
    04｜零基础玩转面向对象编程：Java OOP
    33
  • 4
    03｜Java基础语法：讲解标识符、关键字、变量、数据类型、运算符、控制语句（条件分支、循环）
    38
  • 5
    探索Java世界的奇妙工具——运算符与表达式运算符
    30
  • 6
    深入浅出Java基础语法：标识符、关键字、变量、数据类型、运算符与控制语句
    31
  • 7
    Java一分钟之-Java IO流：文件读写基础
    114
  • 8
    轻松理解Java中的数据类型和变量
    24
  • 9
    Java一分钟之-Map接口与HashMap详解
    38
  • 10
    01｜Java简介与历史
    36

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云OSS设置跨域访问