Java对象克隆 - 陌路lui

　　想对一个对象进行处理，又想保留原有的数据进行接下来的操作，就需要克隆了，Java语言中克隆针对的是类的实例。

一、Java值传递和引用传递

　　值传递：只要是基本类型传递都是值传递；引用传递：针对于基本类型进行封装，对封装进行传递，是引用传递。值转递，指的是方法调用时，复制一份实际参数（基本类型的值或者引用对象）到方法参数中。这样在方法中参数变更了，不影响实际参数。引用传递，指方法调用时，直接将实际参数传递到方法参数中，对方法参数的变更，会影响实际参数。概念中的实际参数和方法参数指的是基本类型的值或者引用对象。引用对象是引用本身，不是引用对象所指向的实际对象。

值传递：

public class Test4 {
    public static void main(String[] args) {
        int a =10;
        change(a);
        System.out.println(a);
    }
    public static void change(int a){
        a = 1;
    }
}

输出：10，基本类型的值进行传递时，是复制一份实际参数进行传递，实际参数的值发生改变时，参数本身并不会发生变化。

引用传递：

public class Test4 {
    public static void main(String[] args) {
        int a[] ={1,2,3};
        change(a);
        System.out.println(a[0]);
    }
    public static void change(int[] a){
        a[0] = 9;
    }
}

输出：9

　　当引用类型的值进行传递时，在栈中复制一个对象，指向同一个引用，当引用本身发生改变时，对象就会发生改变。

二、浅克隆和深克隆

浅拷贝

　　浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制资源。

(1) 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个。
(2) 对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝只是把内存地址赋值给了成员变量，它们指向了同一内存空间。改变其中一个，会对另外一个也产生影响。

深拷贝

对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。
对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。
对于有多层对象的，每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的串行层层拷贝。
深拷贝相比于浅拷贝速度较慢并且花销较大。

深拷贝的两种实现方法：

通过重写clone方法来实现深拷贝
通过对象序列化实现深拷贝

三、实现Cloneable接口

package Math;

public class Teacher implements Cloneable{
    private String name;

    private int age;

    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 Teacher(String name, int age){
        this.name = name;
        this.age = age;
    }

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

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

package Math;

public class Student implements Cloneable{
    private String name;

    private int age;

    private Teacher teacher;

    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 Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

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

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

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

    public static void main(String[] args) throws CloneNotSupportedException{
        Teacher teacher = new Teacher("王老师",30);

        Student student = new Student("张三", 20, teacher);

        System.out.println("student:"+student + ",hashcode"+System.identityHashCode(student));

        System.out.println("teacher:"+teacher+ ",hashcode"+System.identityHashCode(teacher));
        Student student1 = (Student) student.clone();
        student1.setName("李四");
        student1.setAge(40);
        Teacher teacher1 = student1.getTeacher();
        teacher1.setName("批老师");
        teacher1.setAge(90);

        System.out.println("student1:"+student1 + ",hashcode:"+System.identityHashCode(student1));
        System.out.println("teacher1 "+teacher1 + ",hashcode:"+System.identityHashCode(student1.getTeacher()));

        System.out.println("student:"+student + ",hashcode"+System.identityHashCode(student));
    }
}

实现了Cloneable接口，以指示Object的clone()方法可以合法地对该类实例进行按字段复制
如果在没有实现Cloneable接口的实例上调用Object的clone()方法，则会导致抛出CloneNotSupporteddException
按照惯例，实现此接口的类应该使用公共方法重写Object的clone()方法，Object的clone()方法是一个受保护的方法

通过重写clone方法实现深克隆

package Math;

public class Student implements Cloneable{
    private String name;

    private int age;

    private Teacher teacher;

    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 Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

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

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student student = (Student) super.clone();
        student.teacher = (Teacher) teacher.clone();
        return student;
    }

    public static void main(String[] args) throws CloneNotSupportedException{
        Teacher teacher = new Teacher("王老师",30);

        Student student = new Student("张三", 20, teacher);

        System.out.println("student:"+student + ",hashcode"+System.identityHashCode(student));

        System.out.println("teacher:"+teacher+ ",hashcode"+System.identityHashCode(teacher));
        Student student1 = (Student) student.clone();
        student1.setName("李四");
        student1.setAge(40);
        Teacher teacher1 = student1.getTeacher();
        teacher1.setName("批老师");
        teacher1.setAge(90);

        System.out.println("student1:"+student1 + ",hashcode:"+System.identityHashCode(student1));
        System.out.println("teacher1 "+teacher1 + ",hashcode:"+System.identityHashCode(student1.getTeacher()));

        System.out.println("student:"+student + ",hashcode"+System.identityHashCode(student));
    }
}

四、实现Serializable接口

当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
当你想用套接字在网络上传送对象的时候；
当你想通过RMI传输对象的时候；

　　序列化和反序列化的定义：Java序列化就是指把Java对象转换为字节序列的过程，Java反序列化就是指把字节序列恢复为Java对象的过程。

　　序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。

　　反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。

　　总结：核心作用就是对象状态的保存和重建。（整个过程核心点就是字节流中所保存的对象状态及描述信息）

实现过程

实现序列化的必备要求：只有实现了Serializable或者Externalizable接口的类的对象才能被序列化为字节序列。（不是则会抛出异常）
JDK中序列化和反序列化的API：①java.io.ObjectInputStream：对象输入流。该类的readObject()方法从输入流中读取字节序列，然后将字节序列反序列化为一个对象并返回。　　 ②java.io.ObjectOutputStream：对象输出流。该类的writeObject(Object obj)方法将将传入的obj对象进行序列化，把得到的字节序列写入到目标输出流中进行输出。
实现序列化和反序列化的三种实现：
①若Student类仅仅实现了Serializable接口，则可以按照以下方式进行序列化和反序列化。

ObjectOutputStream采用默认的序列化方式，对Student对象的非transient的实例变量进行序列化。
ObjcetInputStream采用默认的反序列化方式，对Student对象的非transient的实例变量进行反序列化。

②若Student类仅仅实现了Serializable接口，并且还定义了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，则采用以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeObject(ObjectOutputStream out)的方法进行序列化。
ObjectInputStream会调用Student对象的readObject(ObjectInputStream in)的方法进行反序列化。

③若Student类实现了Externalnalizable接口，且Student类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，则按照以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeExternal(ObjectOutput out))的方法进行序列化。
ObjectInputStream会调用Student对象的readExternal(ObjectInput in)的方法进行反序列化。

package Base;

import java.io.Serializable;

public class Student implements Serializable {
    private String userName;
    private String password;
    private String year;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getYear() {
        return year;
    }

    public void setYear(String year) {
        this.year = year;
    }

    public Student(String userName, String password, String year) {
        this.userName = userName;
        this.password = password;
        this.year = year;
    }
}

package Base;

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException{
        //序列化
        FileOutputStream fos = new FileOutputStream("object.out");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        Student student1 = new Student("lihao", "wjwlh", "21");
        oos.writeObject(student1);
        oos.flush();
        oos.close();
        //反序列化
        FileInputStream fis = new FileInputStream("object.out");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Student student2 = (Student) ois.readObject();
        System.out.println(student2.getUserName()+ " " +
                student2.getPassword() + " " + student2.getYear());


    }
}

　　序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。为它赋予明确的值。显式地定义serialVersionUID有两种用途：

在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID
在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID

　　Java有很多基础类已经实现了serializable接口，比如String,Vector等。但是也有一些没有实现serializable接口的

　　如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存！这是能用序列化解决深拷贝的重要原因

posted on 2020-09-06 17:23 陌路lui 阅读(310) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部


Copyright © 2024 陌路lui Powered by .NET 8.0 on Kubernetes 博客园

导航