Java备忘录（序列化）

最新推荐文章于 2021-02-27 04:20:08 发布

ア慕斯

最新推荐文章于 2021-02-27 04:20:08 发布

阅读量310

点赞数

分类专栏： Java基础备忘录文章标签： java

本文链接：https://blog.csdn.net/qq_44830078/article/details/108216887

版权

Java基础备忘录专栏收录该内容

9 篇文章 0 订阅

订阅专栏

序列化的简单记录与实践

ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

public ObjectOutputStream(OutputStream out)：创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

一个对象要想序列化，必须满足两个条件:

该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
    public void addressCheck() {
      	System.out.println("Address  check : " + name + " -- " + address);
    }
}

2.写出对象方法

public final void writeObject (Object obj) : 将指定的对象写出。

public class SerializeDemo{
   	public static void main(String [] args)   {
    	Employee e = new Employee();
    	e.name = "zhangsan";
    	e.address = "beiqinglu";
    	e.age = 20; 
    	try {
      		// 创建序列化流对象
          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
        	// 写出对象
        	out.writeObject(e);
        	// 释放资源
        	out.close();
        	fileOut.close();
        	System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        } catch(IOException i)   {
            i.printStackTrace();
        }
   	}
}
输出结果：
Serialized data is saved

ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

public ObjectInputStream(InputStream in)：创建一个指定InputStream的ObjectInputStream。

反序列化操作

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用ObjectInputStream读取对象的方法：

public final Object readObject () : 读取一个对象。

public class DeserializeDemo {
   public static void main(String [] args)   {
        Employee e = null;
        try {		
             // 创建反序列化流
             FileInputStream fileIn = new FileInputStream("employee.txt");
             ObjectInputStream in = new ObjectInputStream(fileIn);
             // 读取一个对象
             e = (Employee) in.readObject();
             // 释放资源
             in.close();
             fileIn.close();
        }catch(IOException i) {
             // 捕获其他异常
             i.printStackTrace();
             return;
        }catch(ClassNotFoundException c)  {
        	// 捕获类找不到异常
             System.out.println("Employee class not found");
             c.printStackTrace();
             return;
        }
        // 无异常,直接打印输出
        System.out.println("Name: " + e.name);	// zhangsan
        System.out.println("Address: " + e.address); // beiqinglu
        System.out.println("age: " + e.age); // 0
    }
}

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

速记

1.什么是序列化?
序列化就是把程序中的对象写入到临时存储或持久化的过程。
反序列化就是把临时存储和持久化的内容,反向写入程序中的过程。

2.实现序列化需要实现Serializable接口. 反序列化需要对比版本号.每次修改版本号会变更.
（这点重点体现在实现Serialzable接口的类的变化上，当序列化前的类，和反序列化时的类不一样（即版本号发生改变时）会报出版本号不一致的错误。而解决方案在目前已经学习的内容中有两种解决方案：一个是在类中写上版本号。另一个就是用改变的类重新序列化与反序列化的操作）

3.Serializable接口里面没有任何方法，是一个标志性接口。

序列化中的一些须注意点

下面大部分都是具体代码的实现，而要注意的点总结起来就是：
1.static、transient关键字修饰的属性，使用serializable方法的序列化后，反序列化时得不到该属性的值。即该属性不会被序列化。原因：因为序列化不能序列化类，而静态变量属于类的。而transient修饰的属性也不会被序列化，transient关键字的作用，在已实现序列化的类中，有的变量不需要保存在磁盘中，就要transient关键字修饰，如银行卡密码等，就这个作用------在已序列化的类中使变量不序列化
2. 通过Serializable接口实现的反序列化,不会执行自身的构造器.但是会执行父类无参构造.

1.static transient关键字

继承Serializable接口的类，里面调用了static和transient修饰，注意输出的结果

import java.io.Serializable;

public class Person implements Serializable {
    public static final  String GENDER_BOY = "男";
    public static final  String GENDER_GRIL = "女";
    private String name;
    private String gender;
    private int age;
    private String idCard;
    private static String type;
    private transient String nickName

    public Person() {
    }

    public static String getType() {
        return type;
    }

    public static void setType(String type) {
        Person.type = type;
    }

    public Person(String name, String gender, int age, String idCard) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.idCard = idCard;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                ", idCard='" + idCard + '\'' +
                ", type='" + type + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
	
	public String getNickName() {
        return nickname;
    }

    public void setNickName(String nickname) {
        this.nickname = nickname;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public String getIdCard() {
        return idCard;
    }

    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }
}

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializableOutTest {
    public static void main(String[] args) throws IOException {
        File file = new File("F:"+File.separator+"Test");
        if(!file.exists()){
            file.createNewFile();
        }
        Person person = new Person("叶叶",Person.GENDER_BOY,22,"356987458960716****");
        person.setType("黄种人");
        person.setNickName("小叶");
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(file));
        os.writeObject(person);

        os.close();
    }
}

import java.io.*;

public class SerializableInTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        File file = new File("F:"+File.separator+"Test");
        if(!file.exists()){
            throw new FileNotFoundException("找不到该文件夹!");
        }
        ObjectInputStream is = new ObjectInputStream(new FileInputStream(file));
        Person person = (Person)is.readObject();
        System.out.println(person);
    }
}
   
/*输出结果：
Person{name='叶叶', gender='男', age=22, idCard='356987458960716****', type='null', nickName='null'}
*/

2.父类实现序列化接口，子类没有实现接口，但是继承父类

未受到影响，子类继承了父类，都可以正常使用

//输出结果：
//Person{name='叶叶', gender='男', age=22, idCard='356987458960716****', nickName='小叶叶', type='黄种人'}

3.父类没有实现接口，子类有实现序列化接口

4.在3的基础上，添加父类的无参构造和不添加不添加父类的无参构造

`父类带无参：`

父类

public class Man {
    private String type;
    private String nickName;

    public Man() {
        System.out.println("父类无参构造");
    }

    public Man(String type, String nickName) {
        System.out.println("父类有参数构造");
        this.type = type;
        this.nickName = nickName;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }
}

子类：

import java.io.Serializable;

public class Person extends Man implements Serializable {
    public static final  String GENDER_BOY = "男";
    public static final  String GENDER_GRIL = "女";
    private String name;
    private String gender;
    private int age;
    private String idCard;
    /*private static String type;
    private transient String nickName;*/


    public Person() {
        System.out.println("子类无参构造");
    }

    public Person(String name, String gender, int age, String idCard) {
        System.out.println("子类有参构造");
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.idCard = idCard;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                ", idCard='" + idCard + '\'' +
                ", nickName='" + getNickName() + '\'' +
                ", type='" + getType() + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public String getIdCard() {
        return idCard;
    }

    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }
}

输入序列化

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializableOutTest {
    public static void main(String[] args) throws IOException {
        File file = new File("F:"+File.separator+"Test");
        if(!file.exists()){
            file.createNewFile();
        }
        Person person = new Person("叶叶",Person.GENDER_BOY,22,"356987458960716****");
        person.setNickName("小叶叶");
        person.setType("黄种人");
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(file));
        os.writeObject(person);

        os.close();
    }
}

输出反序列化：

import java.io.*;

public class SerializableInTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        File file = new File("F:"+File.separator+"Test");
        if(!file.exists()){
            throw new FileNotFoundException("找不到该文件夹!");
        }
        ObjectInputStream is = new ObjectInputStream(new FileInputStream(file));
        Person person = (Person)is.readObject();
        System.out.println(person);
    }
}

/*运行结果：
父类无参构造
Person{name='叶叶', gender='男', age=22, idCard='356987458960716****', nickName='null', type='null'}
*/

`父类不带无参构造`

父类：

public class Man  {
    private String type;
    private String nickName;

    public Man(String type, String nickName) {
        System.out.println("父类有参数构造");
        this.type = type;
        this.nickName = nickName;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }
}

子类

import java.io.Serializable;

public class Person extends Man implements Serializable {
    public static final  String GENDER_BOY = "男";
    public static final  String GENDER_GRIL = "女";
    private String name;
    private String gender;
    private int age;
    private String idCard;
    /*private static String type;
    private transient String nickName;*/


    public Person() {
        super("a","b");
        System.out.println("子类无参构造");
    }

    public Person(String name, String gender, int age, String idCard) {
        super("a","b");
        System.out.println("子类有参构造");
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.idCard = idCard;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                ", idCard='" + idCard + '\'' +
                ", nickName='" + getNickName() + '\'' +
                ", type='" + getType() + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public String getIdCard() {
        return idCard;
    }

    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }
}

序列化类：

import java.io.*;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializableOutTest {
    public static void main(String[] args) throws IOException {
        File file = new File("F:"+File.separator+"Test");
        if(!file.exists()){
            file.createNewFile();
        }
        Person person = new Person("叶叶",Person.GENDER_BOY,22,"356987458960716****");
        person.setNickName("小叶叶");
        person.setType("黄种人");
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(file));
        os.writeObject(person);

        os.close();
    }
}

反序列化类：

import java.io.*;

public class SerializableInTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        File file = new File("F:"+File.separator+"Test");
        if(!file.exists()){
            throw new FileNotFoundException("找不到该文件夹!");
        }
        ObjectInputStream is = new ObjectInputStream(new FileInputStream(file));
        Person person = (Person)is.readObject();
        System.out.println(person);
    }
}


/*运行结果：
Exception in thread "main" java.io.InvalidClassException: com.seecen.Day34.SerializableTestBoke.Person; no valid constructor
	at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
	at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:790)
	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1782)
	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)
	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
	at com.seecen.Day34.SerializableTestBoke.SerializableInTest.main(SerializableInTest.java:12)
*/

实现Externalizable接口序列化

前面的部分都是使用Serializable接口去序列化，而实际上还有一个Externalizable接口可以去实现序列化。
首先需要知道Externalizable接口是 java.io.Serializable的子类，所以本质上与之前继承Serializable接口序列化的方法差不多，但是Externalizable接口多了两个子类独有的方法：
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;

在使用时可以通过重写这两个方法对序列化的属性进行选择，即可以选择性的序列化属性，也可以选择性的反序列化部分属性。
Externalizable接口与Serializable接口除了多了两个独特的方法外，它的序列化是有顺序的（此处的顺序是指输入的属性的顺序和取出的属性顺序必须一致）。

举例：
实现Externalizable接口的Person类

import java.io.*;

public class Person implements Externalizable {
    public static final  String GENDER_BOY = "男";
    public static final  String GENDER_GRIL = "女";
    private String name;
    private String gender;
    private int age;
    private String idCard;

    public Person() {
    }

    public Person(String name, String gender, int age, String idCard) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.idCard = idCard;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                //", gender='" + gender + '\'' +
                ", age=" + age +
                //", idCard='" + idCard + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public String getIdCard() {
        return idCard;
    }

    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeObject(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String)in.readObject();
        age = (Integer)in.readObject();
    }
}

序列化ExterbalizableOutTest类

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ExterbalizableOutTest {
    public static void main(String[] args) throws IOException {
        File file = new File("F:"+File.separator+"Test");
        if(!file.exists()){
            file.createNewFile();
        }
        Person person = new Person("叶叶",Person.GENDER_BOY,22,"356987458960716****");
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(file));
        os.writeObject(person);
        os.close();
    }
}

反序列化ExterbalizableInTest类

import java.io.*;

public class ExterbalizableInTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        File file = new File("F:"+File.separator+"Test");
        if(!file.exists()){
            throw new FileNotFoundException("找不到该文件夹!");
        }
        ObjectInputStream is = new ObjectInputStream(new FileInputStream(file));
        Person person = (Person)is.readObject();
        System.out.println(person);
    }
}



/*输出结果
Person{name='叶叶', age=22}
*/

ア慕斯

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java备忘录（序列化）

序列化的简单记录与实践ObjectOutputStream类构造方法序列化操作ObjectInputStream类构造方法反序列化操作1速记序列化中的一些须注意点1.static transient关键字2.父类实现序列化接口，子类没有实现接口，但是继承父类3.父类没有实现接口，子类有实现序列化接口4.在3的基础上，添加父类的无参构造和不添加不添加父类的无参构造`父类带无参：``父类不带无参构造`实现Externalizable接口序列化ObjectOutputStream类java.io.Objec
复制链接

扫一扫