Java基础之浅拷贝与深拷贝

最新推荐文章于 2024-06-27 01:38:03 发布
最新推荐文章于 2024-06-27 01:38:03 发布
阅读量1k 收藏
点赞数 1
分类专栏： Java基础 文章标签： java 浅拷贝 深拷贝 串行化对象 不是用构造器创建对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chun0801/article/details/51858835
版权
含义
  • 浅拷贝：进对对象本身（包括对象中的基本变量）进行拷贝，而不拷贝对象包含的引用指向的对象。
  • 深拷贝：不仅对对象本身，而且还对对象所包含的引用指向的对象进行拷贝。
  • 深拷贝可以看做是对浅拷贝的递归。
  • 举例来说：对象A1中包含对B1的引用，B1中包含对C1的引用。浅拷贝A1得到A2，A2 中依然包含对B1的引用，B1中依然包含对C1的引用。深拷贝则是对浅拷贝的递归，深拷贝A1得到A2，A2中包含对B2（B1的copy）的引用，B2 中包含对C2（C1的copy）的引用。
克隆方法clone()

protected native Object clone() throws CloneNotSupportedException;

  • 它是一个protected修饰的native方法，因此它的实现是取决于本地代码。native方法的效率一般来说都是远高于java中的非native方法。
  • Object中的clone方法是protected的，所以要使用clone就必须继承Object类（默认）。并且为了可以使其它类调用该方法，覆写克隆方法时必须将其作用域设置为public。
  • 克隆方法返回的是一个Object对象，所以必须要经过强制类型转换。

通常克隆对象都是通过调用super.clone()方法来获取克隆对象的，所以任何克隆的过程最终都将到达java.lang.Object 的clone()方法。但是在覆写clone()方法时，这个类需要继承Clonable接口，这个接口中没有定义方法，只做为一种标识存在。如果 clone 类没有实现 Cloneable 接口，并调用了 Object 的 clone() 方法（也就是调用了 super.Clone() 方法），那么Object 的 clone() 方法就会抛出 CloneNotSupportedException 异常。

通过从源码的注释中可以看出，克隆的一些特性：
  • x.clone() != x 必须为真，也就是对于基础类型来说，其克隆后在堆中有两个独立且内容相同的内存区域。而对于引用类型来说，其引用也不相同。也就是说克隆对象和原始对象在java 堆(heap)中是两个独立的对象。
  • x.clone().getClass() == x.getClass() 他们所属的类是同一个。
  • x.clone().equals(x) 所比较的对象内容相同。

从上述的第二和第三点可以看出，克隆完全是拷贝一个独立的副本到内存中。但是由于克隆方法可以覆写，所以并不能保证克隆出来的对象能够达到（2）和（3）要求的标准，所以他们不是克隆方法所必须要求的。

浅拷贝

只对对象本身进行拷贝，而不对对象包含的引用进行拷贝。

  • 例子如下：
package com.xqq.浅拷贝;
public class Professor implements Cloneable {
    private int age;
    private String name;
    public Professor(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Object clone() {
        Professor professor = null;
        try {
            professor = (Professor) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return professor;
    }
    @Override
    public String toString() {
        return "Professor name:" + name + " age:" + age;
    }
}

package com.xqq.浅拷贝;
public class Student implements Cloneable {
    private String name;
    private int age;
    private Professor professor;// 浅拷贝完之后，所指对象仍为同一个
    public Student(String name, int age, Professor professor) {
        this.name = name;
        this.age = age;
        this.professor = professor;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Professor getProfessor() {
        return professor;
    }
    public void setProfessor(Professor professor) {
        this.professor = professor;
    }
    @Override
    protected Object clone() {
        Student student = null;
        try {
            student = (Student) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return student;
    }
    @Override
    public String toString() {
        return "Student name: " + name + " age:" + age + " professor: "
                + professor;
    }
}

package com.xqq.浅拷贝;
public class TestShallowCopy {
    public static void main(String[] args) {
        String name = "Tom";
        int age = 20;

        Professor professor = new Professor(30, "Json");
        Student student1 = new Student(name, age, professor);

        Student student2 = (Student)student1.clone();

        System.out.println("1" + student1);
        System.out.println("Copy" + student2);

        System.out.println("修改了学生1的教授名-------");
        professor.setName("Change");

        System.out.println(student1);
        System.out.println(student2);
    }
}
运行结果：
1Student name: Tom age:20 professor: Professor name:Json age:30
CopyStudent name: Tom age:20 professor: Professor name:Json age:30
修改了学生1的教授名-------
Student name: Tom age:20 professor: Professor name:Change age:30
Student name: Tom age:20 professor: Professor name:Change age:30
  • shallow1和shallow的内存模型

这里写图片描述

可以看出，基本类型可以使用浅克隆，而对于引用类型，由于引用的是内容相同，所以改变shallow1实例对象中的属性就会影响shallow2对象中的属性。

深拷贝

深拷贝与浅拷贝的主要区别在于对复合类型数据的复制，若对象中的某个字段为复合类型数据，在拷贝时，需要对该字段也进行一份拷贝，深拷贝相当于对浅拷贝进行递归。

  • 例子如下：
package com.xqq.深拷贝;

public class Professor implements Cloneable {

    private int age;
    private String name;
    public Professor(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Object clone(){
        Professor professor = null;
        try {
            professor = (Professor)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return professor;
    }
    @Override
    public String toString() {
        return "Professor name:" + name + " age:" + age;
    }
}

package com.xqq.深拷贝;

public class Student implements Cloneable {

    private String name;
    private int age;
    private Professor professor;// 浅拷贝完之后，所指对象仍为同一个

    public Student(String name, int age, Professor professor) {
        this.name = name;
        this.age = age;
        this.professor = professor;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Professor getProfessor() {
        return professor;
    }

    public void setProfessor(Professor professor) {
        this.professor = professor;
    }

    @Override
    protected Object clone() {
        Student student = null;
        try {
            student = (Student) super.clone();// 对自身对象克隆

            student.setProfessor((Professor)professor.clone());//还要对该对象内部的引用变量进行克隆
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return student;
    }

    @Override
    public String toString() {
        return "Student name: " + name + " age:" + age + " professor: "
                + professor;
    }
}
package com.xqq.深拷贝;
public class TestDeepCopy {
    public static void main(String[] args) {
        String name = "Tom";
        int age = 20;

        Professor professor = new Professor(30, "Json");
        Student student1 = new Student(name, age, professor);

        Student student2 = (Student)student1.clone();

        System.out.println("1" + student1);
        System.out.println("Copy" + student2);

        System.out.println("修改了学生1的教授名-------");
        professor.setName("Change");

        System.out.println(student1);
        System.out.println(student2);
    }
}

运行结果：
1Student name: Tom age:20 professor: Professor name:Json age:30
CopyStudent name: Tom age:20 professor: Professor name:Json age:30
修改了学生1的教授名-------
Student name: Tom age:20 professor: Professor name:Change age:30
Student name: Tom age:20 professor: Professor name:Json age:30
  • copy1与copy2的内存模型

这里写图片描述

通过反序列化进行深拷贝
  • 例子如下：
package com.xqq.深拷贝之串行化;
import java.io.Serializable;
public class Professor implements Serializable {
    private static final long serialVersionUID = -5625634096029788266L;
    private int age;
    private String name;
    public Professor(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Professor name:" + name + " age:" + age;
    }
}
package com.xqq.深拷贝之串行化;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Student implements Serializable {
    private static final long serialVersionUID = -6910385562039120926L;
    private String name;
    private int age;
    private Professor professor;// 浅拷贝完之后，所指对象仍为同一个
    public Student(String name, int age, Professor professor) {
        this.name = name;
        this.age = age;
        this.professor = professor;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Professor getProfessor() {
        return professor;
    }
    public void setProfessor(Professor professor) {
        this.professor = professor;
    }
    public Object deepClone() throws IOException, ClassNotFoundException {
        //创建输出流
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        //输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(out);
        //将对象写进输出流
        oos.writeObject(this);

        //创建输入流
        ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(in);
        //从输入流读出读出对象
        Student student = (Student) ois.readObject();
        return student;
    }
    @Override
    public String toString() {
        return "Student name: " + name + " age:" + age + " professor: "
                + professor;
    }
}
package com.xqq.深拷贝之串行化;
import java.io.IOException;
public class TestShallowCopy {
    public static void main(String[] args) throws ClassNotFoundException, IOException {
        String name = "Tom";
        int age = 20;

        Professor professor = new Professor(30, "Json");
        Student student1 = new Student(name, age, professor);

        Student student2 = (Student)student1.deepClone();

        System.out.println("1" + student1);
        System.out.println("Copy" + student2);

        System.out.println("修改了学生1的教授名-------");
        professor.setName("Change");

        System.out.println(student1);
        System.out.println(student2);
    }
}
运行结果：
1Student name: Tom age:20 professor: Professor name:Json age:30
CopyStudent name: Tom age:20 professor: Professor name:Json age:30
修改了学生1的教授名-------
Student name: Tom age:20 professor: Professor name:Change age:30
Student name: Tom age:20 professor: Professor name:Json age:30

但是串行化却很耗时，在一些框架中，它们往往将对象进行串行化后进行传递，耗时较多。

总结
  • 克隆方法用于创建对象的拷贝，为了使用clone方法，类必须实现java.lang.Cloneable接口重写protected方法clone，如果没有实现Clonebale接口会抛出CloneNotSupportedException.。
  • 在克隆java对象的时候不会调用构造器
  • java提供一种叫浅拷贝（shallow copy）的默认方式实现clone，创建好对象的副本后然后通过赋值拷贝内容，意味着如果你的类包含引用类型，那么原始对象和克隆都将指向相同的引用内容，这是很危险的，因为发生在可变的字段上任何改变将反应到他们所引用的共同内容上。为了避免这种情况，需要对引用的内容进行深度克隆。
  • 按照约定，实例的克隆应该通过调用super.clone()获取，这样有助克隆对象的不变性。如：clone!=original和clone.getClass()==original.getClass()，尽管这些不是必须的。

本文参考：http://www.cnblogs.com/shuaiwhu/archive/2010/12/14/2065088.html

夏倩倩
关注
专栏目录
Java中的深拷贝和浅拷贝
Tony Chen的专栏
04-19 8967
1．浅拷贝与深拷贝概念 (1)浅拷贝（浅克隆）  浅拷贝又叫浅复制，将对象中的所有字段复制到新的对象（副本）中。其中，值类型字段(java中8中原始类型)的值被复制到副本中后，在副本中的修改不会影响到源对象对应的值。而引用类型的字段被复制到副本中的还是引用类型的引用，而不是引用的对象，在副本中对引用类型的字段值做修改会影响到源对象本身。 浅拷贝简单归纳就是只复制一个对象，对象内部存在指向其他
java深入理解浅拷贝和深拷贝
12-21
拷贝对象是java中经常会遇到的问题。java中存在两种类型，基础类型和引用类型。 java的赋值都是传值的，对于基础类型来说，会拷贝具体的内容，但是对于引用对象来说，存储的这个值只是指向实际对象的地址，拷贝也只会拷贝引用地址。 因为引用对象的存在，所以经常会出现和预期不一样的情况。 本文将会深入的探讨一下在拷贝对象中会出现的浅拷贝和深拷贝的情况。 拷贝接口 java中所有的对象都是继承自java.lang.Object。Object对象中提供了一个clone方法，来供我们对java对象进行拷贝。 protected native Object clone() throws CloneNot
Java 浅拷贝和深拷贝的理解和实现方式
weixin_30662011的博客
10-11 634
Java中的对象拷贝(Object Copy)指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去。举例说明：比如，对象A和对象B都属于类S，具有属性a和b。那么对对象A进行拷贝操作赋值给对象B就是：B.a=A.a; B.b=A.b; 在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用现有对象的部分或全部 数据。 Java中的对象拷贝主要分为：浅拷贝(Shal...
java干货 浅拷贝和深拷贝
最新发布
qq_51305563的博客
06-27 2933
java干货 浅拷贝和深拷贝
Java 浅拷贝与深拷贝
u011035026的博客
11-27 8830
1、什么叫Java浅拷贝？  浅拷贝是会将对象的每个属性进行依次复制，但是当对象的属性值是引用类型时，实质复制的是其引用，当引用指向的值改变时也会跟着变化。 2、什么叫Java深拷贝？  深拷贝复制变量值，对于引用数据，则递归至基本类型后，再复制。深拷贝后的对象与原来的对象是完全隔离的，互不影响，对一个对象的修改并不会影响另一个对象。 3、Java浅拷贝和深拷贝的区别是什么？  通俗来讲浅拷贝的复...
Java 浅拷贝以及深拷贝
时间海绵
04-11 391
Java 浅拷贝以及深拷贝1. Java数据类型在Java程序中，存在基本类型以及引用类型两种数据类型结构 - 基本类型 - 基本类型分为3类： - 数值性 - 整数型：byte, int, short, long - 浮点数：float, double - 字符型：char - 布
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
Java Clone 深拷贝与浅拷贝的两种实现方法 Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅...
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
在Java编程语言中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种不同的对象复制方式，它们涉及到内存中数据的复制和引用的处理。理解这两种拷贝方式对于开发过程中正确管理和操作对象至关重要。 浅拷贝，又...
java 深拷贝与浅拷贝机制详解
08-31
了解和掌握深拷贝与浅拷贝的概念以及如何在Java中实现它们，对于编写高效、健壮的代码至关重要，尤其是在处理复杂的对象结构和数据时。正确地使用拷贝机制可以帮助我们避免不必要的副作用，并确保程序的正确性。
Java-深拷贝、浅拷贝
Subuprogrammer的博客
07-10 168
一、深拷贝、浅拷贝 什么是浅拷贝？ 简单点说， 对于简单类型来说，深拷贝拷贝的是值，对于引用类型来说，深拷贝是两个对象两个引用，内容一样 浅拷贝拷贝的是地址（两个引用指向同一个对象） 什么是深拷贝？ 二、数组拷贝 数组拷贝有下面四种方法： 如果数组中的值是基本类型，那么就是浅拷贝 如果数组中放的是引用类型，那么就是深拷贝 （1）for （2）System.arraycopy(src,0,dest,0,length) （3） Arrays.copyof(int[] original,int newleng
超详细！Java浅拷贝与深拷贝
2302_81982408的博客
05-25 945
超详细！浅克隆与深克隆的实现与运用
Java深拷贝和浅拷贝
海纳百川Android的博客
07-10 481
Java浅拷贝和深拷贝 一看就懂的，java深拷贝浅拷贝 将一个对象的引用复制给另外一个对象，一共有三种方式。第一种方式是直接赋值，第二种方式是浅拷贝，第三种是深拷贝。所以大家知道了哈，这三种概念实际上都是为了拷贝对象啊。 1、直接赋值 好，下面我们先看第一种方式，直接赋值。在Java中，A a1 = a2，我们需要理解的是这实际上复制的是引用，也就是说a1和a2指向的是...
Java中的深浅拷贝
qq_53026081的博客
11-10 428
深拷贝作为面试常考的题目，里面确实涉及到了很多细节：考察你的递归能力考察处理循环引用，还可以深入挖掘对weakSet、weakMap弱引用的了解程度考察各种引用类型的处理，对数据类型的掌握的程度。
Java浅拷贝与深拷贝
L_explorer的博客
12-30 740
Java中组合与聚合是非常重要的两个内容，本文主要来解释与区别两者。 概念 组合： 顾名思义，就是使用多个已有的对象组合为一个功能更加复杂强大的新对象。体现的是整体与部分、拥有的关系。又因为在对象之间，各自的内部细节是不可见的，所以我们也说这种方式的代码复用是黑盒式代码复用。 聚合： ...
Java中的深拷贝与浅拷贝
qq_43460095的博客
07-13 6382
浅拷贝：对基本类型数据进行值传递，对引用类型数据进行引用传递的拷贝深拷贝：对基本类型数据进行值传递，对引用类型数据创建一个新的对象，并复制其内容在Java中，所有的对象都继承自，在类中提供了一个方法来供我们对Java对象进行拷贝： 这个方法是的，所以不需要我们来实现。不过需要注意的是，这个方法还是的，这意味着方法只在包或其子类可见。方法还抛出了一个异常，通过源码注释可以知道，当调用了方法的对象类没有实现接口，或者无法克隆对象的时候，会抛出该异常，也就是说，如果要成功的调用接口，首先该类要实现接口。 Clon
JAVA 浅拷贝和深拷贝
skystep的博客
08-07 3720
在 java 中，默认的拷贝指的是类重写 Object 类中的 clone 方法，调用该方法进行拷贝。使用 clone 方法生生成新的对象，此时在堆中产生新的对象，clone 存放了该对象的引用。对浅拷贝进行加强，对象中引用属性进行 clone 操作，以下例子 User 类 clone 的时候也对 animal 进行拷贝。深拷贝相对于浅拷贝而言，会对所有数据类型都进行拷贝一份，包括这个对象所包含的内部对象。User 类实现 Serializable 接口，对堆区中的实例进行读写，从而实现对实例的全部拷贝。.
java的深拷贝和浅拷贝
weixin_45771158的博客
07-11 4071
浅拷贝和深拷贝
Java浅拷贝与深拷贝详解：原理与实例
对象拷贝主要分为浅拷贝、深拷贝和延迟拷贝三种类型。本篇将重点介绍浅拷贝。 浅拷贝，也称为浅层次拷贝，是指创建一个新的对象，并将原对象的属性值逐个复制过去。在Java中，浅拷贝主要针对的是对象的属性，包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值