Java对象表示方式1：序列化、反序列化的作用

1 /**
  2  * 序列化的演示测试程序
  3  *
  4  * @author skywang
  5  */
  6 
  7 import java.io.FileInputStream;   
  8 import java.io.FileOutputStream;   
  9 import java.io.ObjectInputStream;   
 10 import java.io.ObjectOutputStream;   
 11 import java.io.Serializable;   
 12 import java.io.IOException;   
 13 import java.lang.ClassNotFoundException;   
 14   
 15 public class SerialTest5 { 
 16     private static final String TMP_FILE = ".serialtest5.txt";
 17   
 18     public static void main(String[] args) {   
 19         // 将“对象”通过序列化保存
 20         testWrite();
 21         // 将序列化的“对象”读出来
 22         testRead();
 23     }
 24   
 25 
 26     /**
 27      * 将Box对象通过序列化，保存到文件中
 28      */
 29     private static void testWrite() {   
 30         try {
 31             // 获取文件TMP_FILE对应的对象输出流。
 32             // ObjectOutputStream中，只能写入“基本数据”或“支持序列化的对象”
 33             ObjectOutputStream out = new ObjectOutputStream(
 34                     new FileOutputStream(TMP_FILE));
 35             // 创建Box对象，Box实现了Serializable序列化接口
 36             Box box = new Box("desk", 80, 48);
 37             // 将box对象写入到对象输出流out中，即相当于将对象保存到文件TMP_FILE中
 38             out.writeObject(box);
 39             // 打印“Box对象”
 40             System.out.println("testWrite box: " + box);
 41             // 修改box的值
 42             box = new Box("room", 100, 50);
 43 
 44             out.close();
 45         } catch (Exception ex) {
 46             ex.printStackTrace();
 47         }
 48     }
 49  
 50     /**
 51      * 从文件中读取出“序列化的Box对象”
 52      */
 53     private static void testRead() {
 54         try {
 55             // 获取文件TMP_FILE对应的对象输入流。
 56             ObjectInputStream in = new ObjectInputStream(
 57                     new FileInputStream(TMP_FILE));
 58             // 从对象输入流中，读取先前保存的box对象。
 59             Box box = (Box) in.readObject();
 60             // 打印“Box对象”
 61             System.out.println("testRead  box: " + box);
 62             in.close();
 63         } catch (Exception e) {
 64             e.printStackTrace();
 65         }
 66     }
 67 }
 68 
 69 
 70 /**
 71  * Box类“支持序列化”。因为Box实现了Serializable接口。
 72  *
 73  * 实际上，一个类只需要实现Serializable即可实现序列化，而不需要实现任何函数。
 74  */
 75 class Box implements Serializable {
 76     private static int width;   
 77     private transient int height; 
 78     private String name;   
 79 
 80     public Box(String name, int width, int height) {
 81         this.name = name;
 82         this.width = width;
 83         this.height = height;
 84     }
 85 
 86     private void writeObject(ObjectOutputStream out) throws IOException{ 
 87         out.defaultWriteObject();//使定制的writeObject()方法可以利用自动序列化中内置的逻辑。 
 88         out.writeInt(height); 
 89         out.writeInt(width); 
 90         //System.out.println("Box--writeObject width="+width+", height="+height);
 91     }
 92 
 93     private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{ 
 94         in.defaultReadObject();//defaultReadObject()补充自动序列化 
 95         height = in.readInt(); 
 96         width = in.readInt(); 
 97         //System.out.println("Box---readObject width="+width+", height="+height);
 98     }
 99 
100     @Override
101     public String toString() {
102         return "["+name+": ("+width+", "+height+") ]";
103     }
104 }

/**
 * 序列化的演示测试程序
 *
 * @author skywang
 */

import java.io.FileInputStream;   
import java.io.FileOutputStream;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.io.ObjectOutput;   
import java.io.ObjectInput;   
import java.io.Serializable;   
import java.io.Externalizable;   
import java.io.IOException;   
import java.lang.ClassNotFoundException;   
  
public class ExternalizableTest2 { 
    private static final String TMP_FILE = ".externalizabletest2.txt";
  
    public static void main(String[] args) {   
        // 将“对象”通过序列化保存
        testWrite();
        // 将序列化的“对象”读出来
        testRead();
    }
  

    /**
     * 将Box对象通过序列化，保存到文件中
     */
    private static void testWrite() {   
        try {
            // 获取文件TMP_FILE对应的对象输出流。
            // ObjectOutputStream中，只能写入“基本数据”或“支持序列化的对象”
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream(TMP_FILE));
            // 创建Box对象
            Box box = new Box("desk", 80, 48);
            // 将box对象写入到对象输出流out中，即相当于将对象保存到文件TMP_FILE中
            out.writeObject(box);
            // 打印“Box对象”
            System.out.println("testWrite box: " + box);

            out.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * 从文件中读取出“序列化的Box对象”
     */
    private static void testRead() {
        try {
            // 获取文件TMP_FILE对应的对象输入流。
            ObjectInputStream in = new ObjectInputStream(
                    new FileInputStream(TMP_FILE));
            // 从对象输入流中，读取先前保存的box对象。
            Box box = (Box) in.readObject();
            // 打印“Box对象”
            System.out.println("testRead  box: " + box);
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


/**
 * Box类实现Externalizable接口
 */
class Box implements Externalizable {
    private int width;   
    private int height; 
    private String name;   

    public Box() {
    }

    public Box(String name, int width, int height) {
        this.name = name;
        this.width = width;
        this.height = height;
    }

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

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

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