Java中的深浅拷贝

1.什么是深拷贝和浅拷贝

浅拷贝和深拷贝都是对一个已有对象的操作,编译系统会自动调用一种构造函数——拷贝构造函数,如果用户未定义拷贝构造函数,则会调用默认拷贝构造函。
在java中,一般使用=好做赋值操作的时候,对于基本数据类型,实际上是拷贝他的值,但是对于对象而言,其实赋值的指示这个对象的引用,将原对象的引用传递过去,他们实际上还是指向的用一个对象。
而浅拷贝和深拷贝就是在这个基础之上做的区分,如果在拷贝这个对象的时候,只对基本数据类型进行了拷贝,而对引用数据类型只是进行了引用的传递,而没有创建一个新的对象,那就是浅拷贝。反之,在对引用数据类型进行拷贝的时候,新创建了一个新的对象,并完全复制了其内的成员变量,那么这就是深拷贝。实际浅拷贝和深拷贝只是相对的,如果一个对象内部只有基本数据类型,那用 clone() 方法获取到的就是这个对象的深拷贝,而如果其内部还有引用数据类型,那用 clone() 方法就是一次浅拷贝的操作。
clone在平时项目的开发中可能用的不是很频繁,但是区分深拷贝和浅拷贝会让我们对java内存结构和运行方式有更深的了解。深拷贝和彻底深拷贝,在创建不可变对象时,可能对程序有着微妙的影响,可能会决定我们创建的不可变对象是不是真的不可变。

简单总结

1.1 浅拷贝:对基本数据类型进行值传递,对引用数据类型进行引用传递般的拷贝,此为浅拷贝。
1.2 深拷贝:对基本数据类型进行值传递,对引用数据类型,创建一个新的对象,并复制其内容,此为深拷贝。

2.java中的clone方法

在编程中,经常会遇到从一个对象A创建出另外一个与A具有相同状态的对象B,并且对B的修改不会影响到A的状态,Java中提供clone()方法来满足此需求,Java中的类默认继承自Object类,而Object类提供了clone()方法。方法的作用是返回一个Object对象的复制。这个复制函数返回的是一个全新的对象而不是一个引用。

    protected native Object clone() throws CloneNotSupportedException; 
    Cloneable:CloneNotSupportedException

只有子类实现了Cloneable接口后才可以使用Object类提供的clone方法,在类中自定义clone()。(异常原因)
clone顾名思义就是复制,在java语言中,clone方法被对象调用,所以会复制对象,首先要分配一个和源对象同样大小的空间,在这个空间中创建一个新对象。

在java语言中,使用new操作创建一个对象与使用clone方法复制一个对象有什么不同?

使用new操作创建对象本意是分配内存。程序只领到new操作符时,首先去看new操作符后面的类型,因为知道了类型,才能知道要分配多大的内存空间。分配完内存之后,再调用构造函数,填充对象的各个域,这就叫对象的初始化。对象初始化完毕后,可以把引用发布到外部,在外部就可以使用这个引用操纵这个对象。

clone在第一步和new相似的,都是分配内存的,调用clone方法时,分配的内存和源对象(即调用clone方法的对象)相同,然后在使用原对象中对应的各个域,填充新对象的域,填充完成之后,clone方法返回,一个新的相同对象就能被创建,同样这个新对象的引用发布到外部。

3.实现深浅拷贝的要求

要想让对象具有拷贝的功能,必须实现Cloneable接口【标识接口(Serializable和Cloneable接口没有任何方法,这种接口称为标识接口。),表示此类允许被clone】并且在类中自定义clone调用Object类提供的继承权限clone方法

4.浅拷贝如何实现

4.1 包含的其他类继续实现Cloneable接口,并且调用clone方法(递归实现clone)
实现代码如下:

package JavaSe.Io;
class Teacher implements Cloneable{
    private String name;
    private String job;
    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
}
class Student implements Cloneable{
    private String name;
    private int age;
    private Teacher teacher;

    public Student clone(){
        Student student=null;
        try{
            //实现拷贝处理,产生一个新的Student对象,拷贝原来的所有属性值
            student =(Student) super.clone();//浅拷贝
        } catch (CloneNotSupportedException e) {
            e.printStackTrace( );
        }
        return student;
    }

    public Student(String name,int age,Teacher teacher){
        this.name=name;
        this.age=age;
        this.teacher=teacher;
    }
    public void setName(String name) {
        this.name = name;

    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}

public class DepthCopy {
    public static void main(String[] args) {
        Teacher teacher=new Teacher("马云","teacher");
        Student student=new Student("我",20,teacher);
        Student student1=student.clone();
        System.out.println(student);
        System.out.println(student1);
        System.out.println("-----------");
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        System.out.println(student1.getTeacher().getName());
        System.out.println(student1.getTeacher().getJob());
        System.out.println("------------");
        System.out.println(teacher==student1.getTeacher());

    }
}

在这里插入图片描述

5.深拷贝如何实现

5.1 包含的其他类继续实现Cloneable接口,并且调用clone方法(递归实现clone)

package JavaSe.Io;
class Teacher implements Cloneable{
    private String name;
    private String job;
    public Teacher clone(){
        Teacher teacher=null;
            try{
              teacher =(Teacher) super.clone();//深拷贝
            } catch (CloneNotSupportedException e) {
                e.printStackTrace( );
            }
            return teacher;
    }

    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
}
class Student implements Cloneable{
    private String name;
    private int age;
    private Teacher teacher;

    public Student clone(){
        Student student=null;
        try{
            //实现拷贝处理,产生一个新的Student对象,拷贝原来的所有属性值
            student =(Student) super.clone();//浅拷贝
            student.teacher=this.teacher.clone();//深拷贝(递归实现)
        } catch (CloneNotSupportedException e) {
            e.printStackTrace( );
        }
        return student;
    }

    public Student(String name,int age,Teacher teacher){
        this.name=name;
        this.age=age;
        this.teacher=teacher;
    }
    public void setName(String name) {
        this.name = name;

    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}

public class DepthCopy {
    public static void main(String[] args) {
        Teacher teacher=new Teacher("马云","teacher");
        Student student=new Student("我",20,teacher);
        Student student1=student.clone();
        System.out.println(student);
        System.out.println(student1);
        System.out.println("-----------");
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        System.out.println(student1.getTeacher().getName());
        System.out.println(student1.getTeacher().getJob());
        System.out.println("------------");
        System.out.println(teacher==student1.getTeacher());

    }
}

在这里插入图片描述

5.2 使用序列化,使用序列化进行深拷贝时,无需再实现Cloneable接口,只需要实现serializable即可
(序列化可参考序列化与反序列化详解

package JavaSe.Io;
import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;
import java.io.*;
class Teacher implements Serializable {
    private String name;
    private String job;

    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
}
class Student implements Serializable {
    private String name;
    private int age;
    private Teacher teacher;

    public Student cloneObject() throws IOException, ClassNotFoundException {
        //通过内存进行序列化的读取写入
        //获取内存流
        // 获取序列化的两个核心类
        ByteOutputStream bos=new ByteOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(bos);
        oos.writeObject(this);
        ByteArrayInputStream bis=new ByteArrayInputStream(bos.getBytes());
        ObjectInputStream ois=new ObjectInputStream(bis);
        return (Student) ois.readObject();
    }

    public Student(String name,int age,Teacher teacher){
        this.name=name;
        this.age=age;
        this.teacher=teacher;
    }
    public void setName(String name) {
        this.name = name;

    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}

public class DepthCopy {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Teacher teacher=new Teacher("马云","teacher");
        Student student=new Student("我",20,teacher);
        Student student1=student.cloneObject();
        System.out.println(student);
        System.out.println(student1);
        System.out.println("-----------");
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        System.out.println(student1.getTeacher().getName());
        System.out.println(student1.getTeacher().getJob());
        System.out.println("------------");
        System.out.println(teacher==student1.getTeacher());

    }
}

在这里插入图片描述

6.深浅拷贝存在的问题

浅拷贝:对象值拷贝,对于拷贝而言,拷贝出来的对象仍然保留原对象的所有引用
问题:牵一发而动全身,只要任意一个拷贝对象(或原有对象)中的引用发生改变,所有对象均会受到影响
优点:效率高,相对于深拷贝节约空间
深拷贝:深拷贝出来的对象产生了所有引用的新的对象
问题:深拷贝效率低,且浪费空间。
优点:修改任意一个对象,不会对其他对象产生影响

7.综合使用(延迟拷贝)

延迟拷贝=深拷贝+浅拷贝
读取时使用浅拷贝,如果内容修改时用深拷贝,浅拷贝快于深拷贝

  • 2
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值