第18章 Java I/O系统

1. 新I/O(nio)所使用的的结构更接近于操作系统执行I/O的方式：通道和缓冲器。缓冲器作为我们与通道交互的媒介，我们可以通过缓冲器从通道中获取数据，也可以通过缓冲器将数据发送给通道。唯一直接与通道交互的缓冲器是ByteBuffer，但是无法读取或输出对象，字符串对象也不行。
2. “big endian”(高位优先)将最重要的字节存放在地址最低的存储器单元，而"little endian"(低位优先)将最重要的字节存放在地址最高的存储器单元，ByteBuffer以高位优先的方式存储数据。
   ps：据Jargon File记载，endian这个词来源于Jonathan Swift在1726年写的讽刺小说 “Gulliver’s Travels”（《格利佛游记》）。该小说在描述Gulliver畅游小人国时碰到了如下的一个场景。在小人国里的小人因为非常小（身高6英寸）所以总是碰到一些意想不到的问题。有一次因为对水煮蛋该从大的一端（Big-End）剥开还是小的一端（Little-End）剥开的争论而引发了一场战争，并形成了两支截然对立的队伍：支持从大的一端剥开的人Swift就称作Big-Endians，而支持从小的一端剥开的人就称作Little-Endians…
3. 对象序列化的实现可依靠两个接口：Serializable和Externalizable。其中Serializable接口自动序列化和反序列化对象包含的所有域（不包括方法），将某个域用transient关键字修饰可关闭序列化；而Externalizable接口则是继承了Serializable接口，同时添加了两个方法：writeExternal( )和readExternal( )，这两个方法在序列化与反序列化过程中会被自动调用。
   这两个接口在序列化与反序列化过程中的主要不同有：
   ①Serializable对象在序列化时自动保存其包含的所有域，而Externalizable对象需要在writeExternal( )方法处手动选择要保存的域，并在readExternal( )方法处手动恢复。（虽然繁琐，但提供了更大的灵活性。）
   ②恢复Serializable对象不需要调用对象的默认构造器，对象完全以它储存的二进制位为基础来构造，而要恢复一个Externalizable对象，其默认的构造器会调用，然后再调用readExternal( )方法。

    // Somethings类实现Externalizable接口：
    public static void test05() throws Exception {
        Somethings somethings = new Somethings(125, "A String ");
        System.out.println(somethings);
        ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("some.out"));
        System.out.println("save object:");
        o.writeObject(somethings);
        o.close();
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("some.out"));
        System.out.println("recover object:");
        somethings = (Somethings)in.readObject();
        System.out.println(somethings);
        /* output:
        A String 125
        save object:
        somethings.writeExternal
        recover object:
        default constructor
        somethings.readExternal
        A String 125
         */
    }

    static class Somethings implements Externalizable {
        private int i;
        private String s;

        public Somethings() {
            System.out.println("default constructor");
        }

        public Somethings(int i, String s) {
            this.i = i;
            this.s = s;
        }

        @Override
        public String toString() {
            return s + i;
        }

        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            System.out.println("somethings.writeExternal");
            // 手动保存成员对象
            out.writeObject(s);
            out.writeInt(i);
        }

        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            System.out.println("somethings.readExternal");
            // 手动恢复成员对象
            s = (String) in.readObject();
            i = in.readInt();
        }
    }
    
    // Others类实现Serializable接口：
    public static void test06() throws Exception{
        Others others = new Others(125, "A String ");
        System.out.println(others);
        ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("other.out"));
        System.out.println("save object:");
        o.writeObject(others);
        o.close();
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("other.out"));
        System.out.println("recover object:");
        others = (Others)in.readObject();
        System.out.println(others);
        /* output:
        A String 125
        save object:
        recover object:
        A String 125
         */
    }

    static class Others implements Serializable {
        private int i;
        private String s;

        public Others() {
            System.out.println("default constructor");
        }

        public Others(int i, String s) {
            this.i = i;
            this.s = s;
        }

        @Override
        public String toString() {
            return s + i;
        }
    }