Serializable：用于保存及还原对象——《Thinking in Java》随笔031

//: Worm.java
package c10;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
*    @time:         上午10:35:14
*    @date:         2017年5月1日
*    @auther:    skyfffire
*    @version:    v0.1
*/
class Data implements Serializable {
    private static final long serialVersionUID = 
            -1235946666506705202L;
    
    private int i;
    
    Data(int x) {
        i = x;
    }
    
    public String toString() {
        return Integer.toString(i);
    }
}

public class Worm implements Serializable {
    private static final long serialVersionUID = 
            7755684981500799364L;
    
    private static int r() {
        return (int)(Math.random() * 10);
    }
    
    private Data[] d = 
        {new Data(r()), new Data(r()), new Data(r())};
    private Worm next = null;
    private char c;
    
    Worm(int i, char x) {
        System.out.println("Worm constructor:" + i);
        
        c = x;
        
        if (--i > 0) {
            next = new Worm(i, (char)(x + 1));
        }
    }
    
    Worm() {
        System.out.println("Default constructor.");
    }
    
    public String toString() {
        StringBuffer s = new StringBuffer(" " + c + "(");
        
        for (int i = 0; i < d.length; i++) {
            s.append(d[i].toString());
        }
        
        s.append(')');
        
        if (next != null) {
            s.append(next.toString());
        }
        
        return s.toString();
    }
    
    public static void main(String[] args) {
        Worm w = new Worm(6, 'a');
        
        System.out.println("w = " + w);
        
        // Object IO Stream
        try {
            // Output
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("worm.out"));
            out.writeObject("Worm storage");
            out.writeObject(w);
            out.close();
            
            // Input
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream("worm.out"));
            String s = (String)in.readObject();
            Worm w2 = (Worm)in.readObject();
            System.out.println(s + ", w2 = " + w2);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        // Byte IO Stream
        try {
            // Output
            ByteArrayOutputStream bout = 
                    new ByteArrayOutputStream();
            ObjectOutputStream out = 
                    new ObjectOutputStream(bout);
            out.writeObject("Worm storage");
            out.writeObject(w);
            out.flush();
            
            // Input
            ByteArrayInputStream bin = 
                    new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream in = 
                    new ObjectInputStream(bin);
            String s = (String)in.readObject();
            Worm w3 = (Worm)in.readObject();
            System.out.println(s + ", w3 = " + w3);
            
            // close IO stream
            in.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

///:~

输出结果：

Worm constructor:6
Worm constructor:5
Worm constructor:4
Worm constructor:3
Worm constructor:2
Worm constructor:1
w = a(842) b(627) c(504) d(753) e(709) f(651)
Worm storage, w2 = a(842) b(627) c(504) d(753) e(709) f(651)
Worm storage, w3 = a(842) b(627) c(504) d(753) e(709) f(651)

可以看到，实现了Serializable接口的类可以将对象转换为数据流并还原。

序列化(Serializable)可以说是Java中超级重要的东西了。