Java浅拷贝、深拷贝和序列化

最新推荐文章于 2024-05-25 00:06:17 发布

Meanlgp

最新推荐文章于 2024-05-25 00:06:17 发布

阅读量411

点赞数 2

分类专栏： Java基础文章标签： Java基础浅拷贝与深拷贝序列化

本文链接：https://blog.csdn.net/swpssb/article/details/88060076

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java浅拷贝、深拷贝和序列化

1.简单变量拷贝

如果你想要复制一个简单变量，很简单

 1. 	int a = 10;  
 2. 	int b = a;

对于原始数据类型，都能够使用以上方法

2.浅拷贝

2.1 那么如何复制一个对象？

使用以上方法：

class Student{
    private String name;
    
    public Student(String name){
        this.name = name;
    }
    
    public Student(){
        
    }

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

    public String getName() {
        return name;
    }
}

public class CloneTest {
    public static void main(String[] args) {
        Student s1 = new Student("lgp");
        Student s2 = s1;

        System.out.println("学生1:" + s1.getName());
		System.out.println("学生2:" + s2.getName());
    }
    s2.setName("pgl");

        System.out.println("学生1:" +s1.getName());
        System.out.println("学生2:" +s2.getName());
}

打印结果：

学生1:lgp
学生2:lgp
学生1:pgl
学生2:pgl

这是因为原变量与副本都是同一对象的引用，任一变量改变都会影响另一个变量

2.2 浅拷贝

如果希望s2是一个新的对象，它的初始状态与s1相同，但是它们之后各自会有各自的不同状态。这个情况就可以使用clone方法；

clone方法是Object类中的protected方法，所以不能在类外进行访问

要想对一个对象进行复制，就需要对clone方法覆盖。

一般步骤是（浅拷贝）：

被拷贝的类需要实现Clonenable接口（不实现的话在调用clone方法会抛出CloneNotSupportedException异常) 该接口为标记接口(不含任何方法)
覆盖clone()方法，访问修饰符设为public。方法中调用super.clone()方法得到需要的拷贝对象，（native为本地方法)

实现以上方法：

public class CloneTest {
    public static void main(String[] args) {
        Student s1 = new Student("lgp");
        Student s2 = null;
        try {
            s2 = s1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        System.out.println("学生1:" + s1.getName());
        System.out.println("学生2:" + s2.getName());

        s2.setName("pgl");

        System.out.println("学生1:" + s1.getName());
        System.out.println("学生2:" + s2.getName());
    }
}

class Student implements Cloneable{
    private String name;

    public Student(String name){
        this.name = name;
    }

    public Student(){

    }

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

    public String getName() {
        return name;
    }

    @Override
    public Student clone() throws CloneNotSupportedException {
        return (Student)super.clone();
    }
}

打印结果：

学生1:lgp
学生2:lgp
学生1:lgp
学生2:pgl

3.深拷贝

3.1 浅拷贝的不足

Object类中的clone方法，对对象逐个域地进行拷贝。如果对象中的所有数据域都是数值或其他基本类型，拷贝这些域没有问题。但是如果对象中包含子类引用，拷贝域就会得到相同子对象的拎一个引用，那么原来的对象与克隆的对象仍然会共享一些信息。

例如：

public class CloneTest {
    public static void main(String[] args) {
        Address addr = new Address("fz");
        Student s1 = new Student("lgp", addr);
        Student s2 = null;
        try {
            s2 = s1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        System.out.println("学生1:" + s1.getName() + "住址" + s1.getAddress().getAddr());
        System.out.println("学生2:" + s2.getName() + "住址" + s2.getAddress().getAddr());

        addr.setAddr("bj");

        System.out.println("学生1:" + s1.getName() + "住址" + s1.getAddress().getAddr());
        System.out.println("学生2:" + s2.getName() + "住址" + s2.getAddress().getAddr());
    }
}

class Student implements Cloneable{
    private String name;
    private Address address;

    public Student(String name, Address address){
        this.name = name;
        this.address = address;
    }

    public Student(){

    }

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

    public String getName() {
        return name;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Address getAddress() {
        return address;
    }

    @Override
    public Student clone() throws CloneNotSupportedException {
        return (Student)super.clone();
    }
}

class Address{
    private String addr;

    public Address(String addr){
        this.addr = addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public String getAddr() {
        return addr;
    }
}

打印结果：

学生1:lgp住址fz
学生2:lgp住址fz
学生1:lgp住址bj
学生2:lgp住址bj

为什么两个学生的地址都改变了？
原因是浅复制只是复制了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。

3.2 深拷贝

所以，为了达到真正的复制对象，而不是纯粹引用复制。我们需要将Address类可复制化，并且修改clone方法，完整代码如下：

public class CloneTest {
    public static void main(String[] args) {
        Address addr = new Address("fz");
        Student s1 = new Student("lgp", addr);
        Student s2 = null;
        try {
            s2 = s1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        System.out.println("学生1:" + s1.getName() + "住址" + s1.getAddress().getAddr());
        System.out.println("学生2:" + s2.getName() + "住址" + s2.getAddress().getAddr());

        addr.setAddr("bj");

        System.out.println("学生1:" + s1.getName() + "住址" + s1.getAddress().getAddr());
        System.out.println("学生2:" + s2.getName() + "住址" + s2.getAddress().getAddr());
    }
}

class Student implements Cloneable{
    private String name;
    private Address address;

    public Student(String name, Address address){
        this.name = name;
        this.address = address;
    }

    public Student(){

    }

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

    public String getName() {
        return name;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Address getAddress() {
        return address;
    }

    @Override
    public Student clone() throws CloneNotSupportedException {
        Student cloned = (Student)super.clone();

        cloned.address = address.clone();

        return cloned;
    }
}

class Address implements Cloneable{
    private String addr;

    public Address(String addr){
        this.addr = addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public String getAddr() {
        return addr;
    }

    @Override
    public Address clone() throws CloneNotSupportedException {
        return (Address)super.clone();
    }
}

打印结果

学生1:lgp住址fz
学生2:lgp住址fz
学生1:lgp住址bj
学生2:lgp住址fz

存在这样一个问题：类0里有类1，类1里面又有类2 .，类2里又有类3，如此嵌套引用深拷贝就会非常麻烦；

所以下面介绍一个深拷贝更简便的实现方法：使用序列化

4.序列化

4.1 定义

什么是序列化？什么是反序列化？

序列化：把Java对象转换为字节序列的过程。
反序列化：把字节序列恢复为Java对象的过程。

4.2 作用

为什么需要序列化？

在当今的网络社会，我们需要在网络上传输各种类型的数据，包括文本、图片、音频、视频等，而这些数据都是以二进制序列的形式在网络上传送的，那么发送方就需要将这些数据序列化为字节流后传输，而接收方接到字节流后需要反序列化为相应的数据类型。当然接收方也可以将接收到的字节流存储到磁盘中，等到以后想恢复的时候再恢复。

综上，可以得出对象的序列化和反序列化主要有两种用途：

把对象的字节序列永久地保存到磁盘上。（持久化对象）
可以将Java对象以字节序列的方式在网络中传输。（网络传输对象）可以将Java对象以字节序列的方式在网络中传输。（网络传输对象）

4.3 如何实现

如果要让某个对象支持序列化机制，则其类必须实现下面这两个接口中任一个。

Serializable

public interface Serializable {
}

Externalizable、

public interface Externalizable extends java.io.Serializable {
   void writeExternal(ObjectOutput out) throws IOException;
   void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
 }

4.4 序列化机制算法

所有序列化过的，包括磁盘中的的实例对象都有一个序列化编号
当试图序列化一个对象时，程序会先检查该对象是否已经被序列化过，当对象在本次虚拟机中从未被序列化过，则系统将其序列化为字节序列并输出
如果某个对象在本次虚拟机中已经序列化过，则直接输出这个序列化编号

鉴于以上的算法可能会造成一个潜在的问题：当序列化一个可变对象时，只有第一次使用writeObject()方法输出时才会输出字节序列，而第二次调用时仅仅输出一个序列化编号，即使我们改变了这个对象的一些属性，这些改变后的属性也不会序列化到磁盘上，这点在开发中需要非常注意。

4.5 版本 serialVersionUID

Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException。

具体的序列化过程是这样的：序列化操作的时候系统会把当前类的serialVersionUID写入到序列化文件中，当反序列化时系统会去检测文件中的serialVersionUID，判断它是否与当前类的serialVersionUID一致，如果一致就说明序列化类的版本与当前类版本是一样的，可以反序列化成功，否则失败。

serialVersionUID有两种显示的生成方式：

一是默认的1L，比如：private static final long serialVersionUID = 1L;
二是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：
private static final long serialVersionUID = xxxxL;

当实现java.io.Serializable接口的类没有显式地定义一个serialVersionUID变量时候，Java序列化机制会根据编译的Class自动生成一个serialVersionUID作序列化版本比较用，这种情况下，如果Class文件(类名，方法明等)没有发生变化(增加空格，换行，增加注释等等)，就算再编译多次，serialVersionUID也不会变化的。

如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。

那么我们如何维护这个版本号呢？

只修改了类的方法，无需改变serialVersionUID；
只修改了类的static变量和使用transient 修饰的实例变量，无需改变serialVersionUID；
如果修改了实例变量的类型，例如一个变量原来是int改成了String,则反序列化会失败，需要修改serialVersionUID；如果删除了类的一些实例变量，可以兼容无需修改；如果给类增加了一些实例变量，可以兼容无需修改，只是反序列化后这些多出来的变量的值都是默认值。

4.6 继承及引用对象序列化

当要序列化的类存在父类的时候，直接或者间接父类，其父类也必须可以序列化。

当要序列化的类中引用了其他类的对象，那么这些对象的类也必须是可序列化的。

如果子类实现Serializable接口而父类未实现时，父类不会被序列化！
如果父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。

4.7 实现Serializable接口

Address类：

class Address implements Cloneable, Serializable {

    private static final long serialVersionUID = 123456789L;

    private String addr;

    public Address(String addr){
        this.addr = addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public String getAddr() {
        return addr;
    }

    @Override
    public Address clone() throws CloneNotSupportedException {
        return (Address)super.clone();
    }
}

序列化：那么我们如何将此类的对象序列化后保存到磁盘上呢？

创建一个 ObjectOutputStream 输出流oos
调用此输出流oos的writeObject()方法

public static void main(String[] args) {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));

            Address addr = new Address("fz");
            oos.writeObject(addr);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

这样就把addr对象写入了object.txt文件中

反序列化：我们如从文本文件中将此对象的字节序列恢复成Address对象呢？

创建一个ObjectInputStream 输入流ois
调用此输入流ois的readObject()方法。

public static void main(String[] args) {
        try {
        
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
            Address addr1 = (Address) ois.readObject();

            System.out.println(addr.getAddr());

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

4.8 实现Externalizable接口

Externalizable将序列化和反序列化的工作完全交给了程序员，那样的好处就是自由度变大，一般情况下还是使用Serializable较为稳妥。

public class Teacher implements Externalizable{
    private String name;
    private Integer age;
    public Teacher(String name,Integer age){
        System.out.println("有参构造");
        this.name = name;
        this.age = age;
    }
    //setter、getter方法省略

    //编写自己的序列化逻辑
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject("hello:"+name); //将name加上前缀
        out.writeInt(age);  //注掉这句后，age属性将不能被序化
    }

    //编写自己的反序列化逻辑
    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        name = ((StringBuffer) in.readObject()).reverse().toString();
        age = in.readInt();  
    }

    @Override 
    public String toString() {  
        return "[" + name + ", " + age+ "]";  
    } 
}

4.9 选择序列化

transient

当对某个对象进行序列化时，系统会自动将该对象的所有属性依次进行序列化，如果某个属性引用到别一个对象，则被引用的对象也会被序列化。如果被引用的对象的属性也引用了其他对象，则被引用的对象也会被序列化。这就是递归序列化。

有时候，我们并不希望出现递归序列化，或是某个存敏感信息（如银行密码）的属性不被序列化，我们就可通过transient关键字修饰该属性来阻止被序列化。

writeObject()方法与readObject()方法

使用transient关键字阻止序列化虽然简单方便，但被它修饰的属性被完全隔离在序列化机制之外，导致了在反序列化时无法获取该属性的值，而通过在需要序列化的对象的Java类里加入writeObject()方法与readObject()方法可以控制如何序列化各属性，甚至完全不序列化某些属性（此时就transient一样）。

如果我们想要Person类里的name属性在序列化后存在文件里不让别人知道具体是什么（加密），我们就可在Person类里加如下代码：

class Person implements Serializable{
    private String name;

    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        // out.defaultWriteObject();  // 将当前类的非静态和非瞬态字段写入此流。
        //如果不写，如果还有其他字段，则不会被序列化

        out.writeObject(new StringBuffer(name).reverse());
        //将name简单加密（反转），这样别人就知道是怎么回事，当然实际应用不可能这样加密。

        out.writeInt(age);
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        //in.defaultReadObject();// 从此流读取当前类的非静态和非瞬态字段。
        //如果不写，其他字段就不能被反序列化

        name = ((StringBuffer)in.readObject()).reverse().toString();  //解密

        age = in.readInt();
    }
}

4.10 利用序列化来做深拷贝

把对象写到流里的过程是序列化过程（Serialization），而把对象从流中读出来的过程则叫做反序列化过程（Deserialization）。

应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。

public class CloneTest {
    public static void main(String[] args) {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Student.txt"));

            Address addr1 = new Address("fz");
            Student stu1 = new Student("stu1", addr1);
            oos.writeObject(stu1);

            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Student.txt"));
            Student stu2 = (Student) ois.readObject();

            System.out.println("学生1：" + stu1.getName() + " ,住址:" + stu1.getAddress().getAddr());
            System.out.println("学生2：" + stu2.getName() + " ,住址:" + stu2.getAddress().getAddr());

            System.out.println();

            stu2.getAddress().setAddr("xm");

            System.out.println("学生1：" + stu1.getName() + "住址:" + stu1.getAddress().getAddr());
            System.out.println("学生2：" + stu2.getName() + "住址:" + stu2.getAddress().getAddr());


        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Student implements Serializable{
    private String name;
    private Address address;

    public Student(String name, Address address){
        this.name = name;
        this.address = address;
    }

    public Student(){

    }

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

    public String getName() {
        return name;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Address getAddress() {
        return address;
    }

}

class Address implements Serializable {

    private String addr;

    public Address(String addr){
        this.addr = addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public String getAddr() {
        return addr;
    }

}

4.11 序列化对象注意事项

对象的类名、属性都会被序列化；而方法、static属性（静态属性）、transient属性（即瞬态属性）都不会被序列化（这也就是第4条注意事项的原因）
虽然加static也能让某个属性不被序列化，但static不是这么用的
要序列化的对象的引用属性也必须是可序列化的，否则该对象不可序列化，除非以transient关键字修饰该属性使其不用序列化。
反序列化地象时必须有序列化对象生成的class文件（很多没有被序列化的数据需要从class文件获取）
当通过文件、网络来读取序列化后的对象时，必须按实际的写入顺序读取。

5.参考链接

Meanlgp

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java浅拷贝、深拷贝和序列化

Java浅拷贝、深拷贝和序列化1.简单变量如果你想要复制一个简单变量，很简单 1. int a = 10; 2. int b = a;对于原始数据类型，都能够使用以上方法2.浅拷贝那么如何复制一个对象？使用以上方法：class Student{ private String name; public Student(String name){...
复制链接

扫一扫