Java IO流中的对象串行化

将Java程序中的对象保存在外存(除了CUP缓存、内存)当中，称为对象永久化。

Java中有两种类型的字节流可以实现对象永久化。ObjectInputStream、 ObjectOutputStream 支持对象的读和写。

对象永久化的关键是将它的状态以一种串行格式表示出来，以便以后读取该对象时能够把它重构。

因此对Java对象读写的过程被称为对象串行化。

把对象写入文件中保存，并把对象读取到标准输出（即屏幕中）；

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        String address = new String("D:"+File.separator+"text.txt");
        Date day = new Date();
        try {
            ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(address));
            oout.writeObject(day);
            oout.close();
            
        }catch(IOException e) {
            System.out.println(e.getMessage());
        }
        day = null;
        try {
            ObjectInputStream oin = new ObjectInputStream (new FileInputStream(address));
            day = (Date)oin.readObject();
            oin.close();
            System.out.println(day);
            
        }catch(IOException e) {
            System.out.println(e.getMessage());
        }catch(ClassNotFoundException e) {
            System.out.println(e.getMessage());
        }
    }
}

构造可串行化对象的类

一个类只有实现了Serializable 他的对象才是可以串行化的。

如果你写的类要串行化，必须实现Serializable接口。

实际上Serializable是一个空接口，它只是简单的标识一个类的对象可以被串行化。

在对象进行串行化时，只有对象的数据被保存，该对象所属类方法与构造方法不在串行化的流中。

可串行化类变量的访问劝你先拿对于数据的串行化没有影响。数据一般是以字节写入流，而字符串型数据将表示为UTF格式。

扫描二维码关注公众号，回复： 1061955 查看本文章

定制串行化：

1. 仅对可串行化类自己定义的数据输出进行定制，这称为部分定制串行化。

2. 对可串行化类所有的数据（包括父类）的输出进行定制这称为完全定制串行化。

部分定制串行化：（Serializable）

只需要定义并实现两个方法。writeObject（）、readObject（）

完全定制串行化：（Externalizable）

需要实现Externalizable接口。

Externalizable接口实现了Serializable。

必须要定义一个具有public访问权限不带参数的构造器；

代码DEMO；

import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.Date;

public class Objecttext {
    public static void main(String[] args) {
        ManagerExtern manager = new ManagerExtern(1,"A",1,2,"00/00/00","intel","teamleader");
        ManagerExtern manager1 = new ManagerExtern(2,"B",3,4,"01/01/01","intel1","teamleader1");
        String address = new String("D:"+File.separator+"text1.txt");
        try {
            ObjectOutputStream oout = new ObjectOutputStream (new FileOutputStream(address)); 
            oout.writeObject(manager);
            oout.writeObject(manager1);
            oout.close();
        }catch(IOException e) {
            System.out.println(e.getMessage());
        }
        manager = null;
        manager1 = null;
        try {
            ObjectInputStream oin = new ObjectInputStream(new FileInputStream(address));
            manager = (ManagerExtern)oin.readObject();
            manager1 = (ManagerExtern)oin.readObject();
            oin.close();
            System.out.println(manager);
            System.out.println(manager1);
        }catch(Exception e) {
            System.out.println(e.getMessage());
        }
        
    }
}
class EmployExtern{
    protected int id;
    protected String name;
    protected int age;
    protected int salary;
    protected String hireDay;
    protected String department;
    protected EmployExtern() {
        
    }
    public  EmployExtern(int id,String name,int age,int salary,String hireDay,String department) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.hireDay = hireDay;
        this.department = department;
    }
    public String toString() {
        return " ID:"+id+"\n Name:"+name+"\n Age:"+age+"\n Salary:"+salary+"\n hireDay"+hireDay+"\n Department"+department;
    }
    
}
class ManagerExtern extends EmployExtern implements Externalizable{
    private String position;
    public ManagerExtern() {
        
    }
    public ManagerExtern(int id,String name,int age,int salary,String hireDay,String department,String position) {
        super(id,name,age,salary,hireDay,department);
        this.position = position;
    }
     public void writeExternal(ObjectOutput out) throws java.io.IOException{
         Date savedDate = new Date();
         out.writeInt(id);
         out.writeInt(age);
         out.writeInt(salary);
         out.writeUTF(name);
         out.writeUTF(hireDay);
         out.writeUTF(department);
         out.writeUTF(position);
         out.writeInt(savedDate.getYear());
     }
     public void readExternal(ObjectInput in) throws java.io.IOException, java.lang.ClassNotFoundException{
         Date readDate = new Date();
         int savedDate;
         id = in.readInt();
         age = in.readInt();
         salary = in.readInt();
         name = in.readUTF();
         hireDay = in.readUTF();
         department = in.readUTF();
         position = in.readUTF();
         savedDate = in.readInt();
         age = age +(readDate.getYear()-savedDate);
         
         
     }
     public String toString() {
         return super.toString()+"\n Position:"+position;
     }
     
}

transient 可以保护信息不被串行化、反串行化。

敏感嘻嘻或重要的类不应该允许串行化。这样的类不能实现Externalizable 接口和Serializable接口

Java IO流中的对象串行化

猜你喜欢