Java对象克隆

时间：2020-09-17 16:32:32 收藏：0 阅读：26

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

一、实现Cloneable接口

package Base;

public class SimpleObject implements Cloneable{
    private String str;

    public String getStr()
    {
        return str;
    }

    public void setStr(String str)
    {
        this.str = str;
    }

    public SimpleObject()
    {
        System.out.println("Enter SimpleObject.constructor()");
    }

    public Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }
}

package Base;

public class Test1 {
    public static void main(String[] args) throws Exception{
        SimpleObject so0 = new SimpleObject();
        so0.setStr("111");
        SimpleObject so1 = (SimpleObject)so0.clone();

        System.out.println("so0 == so1?" + (so0 == so1));
        System.out.println("so0.getClass() == so1.getClass()?" + (so0.getClass() == so1.getClass()));
        System.out.println("so0.equals(so1)?" + (so0.equals(so1)));

        so1.setStr("222");
        System.out.println("so0.getStr()：" + so0.getStr());
        System.out.println("so1.getStr()：" + so1.getStr());
    }
}

技术图片

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

浅克隆和深克隆

浅克隆（shallow clone）和深克隆（deep clone）反映的是，当对象中还有对象的时候，那么：

1、浅克隆，即很表层的克隆，如果我们要克隆对象，只克隆它自身以及它所包含的所有对象的引用地址

2、深克隆，克隆除自身对象以外的所有对象，包括自身所包含的所有对象实例

这两个概念应该很好理解，就不写代码了。多提一句，所有的基本数据类型，无论是浅克隆还是深克隆，都会进行原值克隆，毕竟它们都不是对象，不是存储在堆中的。

那其实Object的clone()方法，提供的是一种浅克隆的机制，如果想要实现对对象的深克隆，在不引入第三方jar包的情况下，可以使用两种办法：

1、先对对象进行序列化，紧接着马上反序列化出

2、先调用super.clone()方法克隆出一个新对象来，然后在子类的clone()方法中手动给克隆出来的非基本数据类型（引用类型）赋值，比如ArrayList的clone()方法：

二、实现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接口的

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