黑马程序员------java -io操作

最新推荐文章于 2022-01-29 17:49:00 发布

Mauiie

最新推荐文章于 2022-01-29 17:49:00 发布

阅读量1k

点赞数

分类专栏： java 基础

本文链接：https://blog.csdn.net/Maiuiie/article/details/39506403

版权

java 基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

对程序语言设计者来说，设计一个令人满意的I/O系统，是极其艰巨的一个任务。——《Think in java》

关于I/O系统的设计，话再多的时间去研究也不足为怪，这里仅仅我再初步学习I/O时的点点滴滴的记录。

一、File类

　　File类是File类是java.io包中唯一处理磁盘文件和目录的类。它提供的方法都是与平台无关的，
通过使用File类提供各种方法能够创建、删除文件和目录，或者获取磁盘上指定的文件和目录的相关信息。

package com.tai.io;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;

public class FileDemo
{
    /**
     * File类是java.io包中唯一处理磁盘文件和目录的类。它提供的方法都是与平台无关的，
     * 通过使用File类提供各种方法能够创建、删除文件和目录，或者获取磁盘上指定的文件和目录的相关信息。
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException
    {
        File file = new File("E:/文件夹");
        if(file.mkdir())
        {
            System.out.println("文件夹已创建！");
        }
            
        File file2 = new File("E:/文件夹/文件.txt");
        if(file2.createNewFile())
        {
            System.out.println("文件已经创建!");
        }
        
        getInfor(file2);
        
        if(file2.delete())
        {
            System.out.println("文件已删除！");
        }
        
        File Dir = new File("C:"+File.separator+"abc");//separator 文件分割符这样写便于代码跨平台，更加健壮!
        fFilter(Dir);
    }
    
    /*
     *获取相关信息
     */
    private static void getInfor(File file)
    {
        System.out.println("文件名"+file.getName());
        System.out.println("文件父路径"+file.getParent());
        System.out.println("文件的绝对路径"+file.getAbsolutePath());
        System.out.println("所在磁盘的大小"+file.getTotalSpace()/(1024*1024*1024)+"GB");
        System.out.println("所在磁盘的可用空间"+file.getUsableSpace()/(1024*1024*1024)+"GB");
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否是文件夹"+file.isDirectory());
        System.out.println("是否是隐藏文件"+file.isHidden());
        System.out.println("是否可读"+file.canRead()+"  是否可写"+file.canWrite()+"  是否可执行"+file.canExecute());
    }
    
    /*
     * FilenameFilter 过滤接口 此处用内部类实现FileFilter的accept()方法
     * FilenameFilter和FileFilter类似，也提供文件过滤功能
     * 性能上FilennameFilter较FileFilter效率稍高
     */
    private static void fFilter(File file)
    {
        File[] files = file.listFiles(new FileFilter()
        {
            @Override
            public boolean accept(File pathname)
            {
                if(pathname.isFile()&&pathname.getName().endsWith(".txt"))
                {
                    return true;
                }
                return false;
            }
        });
        System.out.println("该目录下的所有文本文件");
        for(File f:files)
        {
            System.out.println(f.getName());
        }
    }
    
}

运行结果：

文件夹已创建！
文件已经创建!
文件名文件.txt
文件父路径E:\文件夹
文件的绝对路径E:\文件夹\文件.txt
所在磁盘的大小84GB
所在磁盘的可用空间31GB
是否是文件true
是否是文件夹false
是否是隐藏文件false
是否可读true  是否可写true  是否可执行true
文件已删除！
该目录下的所有文本文件
b.txt
新建文本文档 (2).txt
新建文本文档.txt

二、字节流

　　计算机中的数据都是以字节为单位进行处理的，这类的数据保存文件也成为“二进制文本”，在Java中对这些文本的操作就是要使用Java的字节流对象。

InputStream和OutputStream分别是输入与输出字节流，它们都是抽象类型的，都不能实例化，它们在I/O包中的顶层，作为了众多字节流的父类。

Java中的字节流有很多，这是我写的几个常用的字节流Demo.

FileInputStream/FileOutputStream

FileInputStream与FileOutputStream 被称为文件流，是最常见的字节流。用于对磁盘文件的读写操作。
* File类不只能创建、删除、获取文剪信息，但是不能打开和读写文件。FileInputStream与FileOutoutStream就是用于读写文件的
* FileInputStream 的构造方法
*   FileInputStream fis = new FileInputStream("c:/abc");
  File file = new File("c:/abc");
  FileInputStream fis = new FileInputStream(file);
  为了简化常用：
  FileInputStream fis = new FileInputStream(new File("c:/abc"));

package com.tai.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamDemo
{
/**
 * FileInputStream与FileOutputStream 被称为文件流，是最常见的字节流。用于对磁盘文件的读写操作。
 * File类不只能创建、删除、获取文剪信息，但是不能打开和读写文件。FileInputStream与FileOutoutStream就是用于读写文件的
 * FileInputStream 的构造方法
 *         FileInputStream fis = new FileInputStream("c:/abc");
        File file = new File("c:/abc");
        FileInputStream fis = new FileInputStream(file);
        为了简化常用：
        FileInputStream fis = new FileInputStream(new File("c:/abc"));
 * @throws IOException 
 */
    public static void main(String[] args) throws IOException
    {
        FileInputStream fis = new FileInputStream(new File("C:/abc/Demo.txt"));
        FileInputStream fis2 = new FileInputStream(new File("C:/abc/b.txt"));
        int b=0,len=0;
        System.out.println("使用read()方法，每次读一个字节：");
        //使用循环，每次读入一个字节，直到文件结尾。
        while((b=fis.read())!=-1)
        {
            System.out.print((char)b);
        }
        fis.close();
        System.out.println("\n使用read(byte[] b)的方法，读取文件存入字符数组中");
        //读取文件，直到结尾，存入byte数组中，打印。
        byte[] bt = new byte[516];
        while(-1!=(len=fis2.read(bt,0,516)))
        {
            String str = new String(bt,0,len);这里需要特别注意的是  从0到len  len是实际的长度可能不到516 、
            System.out.print(str);
        }
        fis2.close();
        
    }
  
}

运行结果：

使用read()方法，每次读一个字节：
this is a FileInputDemo.
使用read(byte[] b)的方法，读取文件存入字符数组中
回家过年，这本是很简单的四个字，却是许许多多游子一年中的期盼，当然，这也包括那些在外求学的莘莘学子们。

在外瓢泼久了，多想回到家乡看看为我们牵挂的父母亲人。曾经多少个日日夜夜想及这些，我们可以做的只是一壶浊酒而后在心底默默的祝福与思念。

“举头望明月，低头思故乡”一年到头，隐藏在我们心底的除了深深的牵挂还剩下什么呢？一年到头，又有多少父母无时无刻不在思念着远方的儿女？

记得还小的时候我们是多么的喜欢过年，有新衣服穿、有压岁钱拿，好多好吃好玩的，还不用担心作业是否已经完成。而今我们盼望着过年，却只是那短暂的团聚，可以陪父母陪亲人说说心里的话。同时我们又多么地害怕，害怕父母那期望的眼神，尤其是害怕看见父母那满头乌发渐渐泛白，甚至脱落。虽然我知道，人没有不会老的，但看见父母脸上渐添的皱纹，和那渐渐泛白的乌发，心中总会有一种心酸的感觉。

FileOutputStream

     * FileOutputStream类是用于向磁盘文件写入字符数据的输出类
     * 当想磁盘某个文件写入时如果文件不存在它不会向FileInputStream那样抛异常，而是创建一个新的文件。
   * 构造方法与FileInputStream类似，但是有的会多个参数：
    * FileOutputStream fos = new FileOutputStream(File file,boolean append)
     * append 是否想文件尾部追加 true 在该文件的结尾追加内容，flase将清除原有的内容，添加新的内容。

package com.tai.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo
{
    /**
     * 本程序的功能是将一个文本中的内容复制到另一个文本中。
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException
    {
        FileInputStream fis = new FileInputStream(new File("C:/abc/Demo.txt"));
        FileOutputStream fos = new FileOutputStream(new File("C:/abc/Demo2.txt"),false);
        int b= 0,len=0;
        byte[] bt = new byte[512];
        
        while(-1!=(len=fis.read(bt,0,512) ) )
        {
            fos.write(bt,0,len);
        }
        System.out.println("已经吧Demo.txt中的内容复制到了Demo2.txt中！！");
        fos.close();
        fis.close();
       
        FileOutputStream fos2 = new FileOutputStream(new File("C:/abc/Demo3.txt"),false);
        writein(fos2,"hello world!");
        System.out.println("已经hello world写入到了文件C:/abc/Demo3.txt中");
    }
    
    /*
     * 简单的向文件写入字符串
     */
    private static void writein(FileOutputStream fos,String str)
    {
        byte[] b  = str.getBytes();
        try
        {
            fos.write(b);
            fos.close();
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

执行结果：

　　已经吧Demo.txt中的内容复制到了Demo2.txt中！！
已经hello world写入到了文件C:/abc/Demo3.txt中

java.io包中提供了FilterInputStream和FilterOutputStream类分别对其他输入输出流进行特殊的处理，它们在
* 读/写数据的同时还能够对数据进行特殊的处理。另外它们还提供了同步机制，是的某一时刻之后一个线程可以访问输入/输出流。
* FilterInputStream/FilterOutputStream都是抽象类。
* FilterInputStream有三个子类：BufferedInputStream、DataInputStream、PushbackInputStream
* FilterOutputStream也有三个子类：BufferedOutputStream、DataOutoutStream、PrintStream
*
* 使用过滤字节流的时候，必须先制定节点流对象处理底层的数据，然后把节点流对象作为过滤流对象的实参使用。即把过滤流对象连接到某个输入/输出节点流对象上如下：
* FileInputStream fis = new FileInputStream(new File("c:/abc.txt"));
* DataInputSream dis = new DataInputStream(fis);

一、BufferedInputStream/BufferedOutputStream

* BufferedInputStream/BufferedOutputStream 是缓冲字节流，它引入了针对内存缓冲区的操作，从而提高了读写数据的效率。
* 缓冲区的默认大小为32字节，也可以指定缓冲区的大小。
* 相应的构造的方法
* BufferedInputStream(InputStream in) 这里的in只要是继承自InputSream的对象都可以作为参数
* BufferedInputStream(InputStream in,int size)
* BufferedOutputStream与上面的对应。

Demo:使用BufferedInputStream/BufferdeOutputStream完成文件的复制。

package com.tai.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedInputStreamDemo
{
    /**
     * java.io包中提供了FilterInputStream和FilterOutputStream类分别对其他输入输出流进行特殊的处理，它们在
     * 读/写数据的同时还能够对数据进行特殊的处理。另外它们还提供了同步机制，是的某一时刻之后一个线程可以访问输入/输出流。
     * FilterInputStream/FilterOutputStream都是抽象类。
     * FilterInputStream有三个子类：BufferedInputStream、DataInputStream、PushbackInputStream
     * FilterOutputStream也有三个子类：BufferedOutputStream、DataOutoutStream、PrintStream
     * 
     * 使用过滤字节流的时候，必须先制定节点流对象处理底层的数据，然后把节点流对象作为过滤流对象的实参使用。即把过滤流对象连接到某个输入/输出节点流对象上
     * 
     * FileInputStream fis = new FileInputStream(new File("c:/abc.txt"));
     * DataInputSream dis = new DataInputStream(fis);
     * BufferedInputStream/BufferedOutputStream 是缓冲字节流，它引入了针对内存缓冲区的操作，从而提高了读写数据的效率。
     * 缓冲区的默认大小为32字节，也可以指定缓冲区的大小。
     * 相应的构造的方法
     * BufferedInputStream(InputStream in) 这里的in只要是继承自InputSream的对象都可以作为参数
     * BufferedInputStream(InputStream in,int size)
     * BufferedOutputStream与上面的对应。
     */
    public static void main(String[] args) throws IOException
    {
        FileInputStream fis = new FileInputStream(new File("c:/曲婉婷 - 没有什么不同 [mqms].mp3"));
        BufferedInputStream bis = new BufferedInputStream(fis,1024);
        FileOutputStream fos = new FileOutputStream(new File("c:/没有什么不同.mp3"));
        BufferedOutputStream bos = new BufferedOutputStream(fos,1024);
        
        byte[] buffer = new byte[1024];
        int len =0;
        while(-1!=(len=bis.read(buffer,0,1024)))
        {
            //将buffer中从fis读取来的数据写入到bos中
            bos.write(buffer,0,len);
        }
        bos.flush();//最近一次读取的数据可能达不到1024字节，这里强制清空缓冲区\
        System.out.println("已经将c:/曲婉婷 - 没有什么不同 [mqms].mp3复制到c:/没有什么不同.mp3");
        bos.close();
        fos.close();
    }
}

二、DataInputStream和DataOutputStream

* java.io包中还有连个接口DataInput和DataOutput,这两个接口设计了较高级的数据输入输出方式，除了可以处理字节个字节数组外
* 还可以处理 int、float、boolean等基本的数据类型，这些数据在文件中的表示方式和它们在内存中的方式一样，无序转换，它们相应的提供了
* 很多处理基本数据类型的方法，如：DataInput提供了read()、readInt()、readByte()等DataOutput提供了write()、writeInt()、
* writeFloat()、writeChar()等 ....
*
* 而数据流类 DataInputStream和DataOutputStream分别实现了DataInput和DataOutput接口。它们以统一的方式向输入流中写入boolean、int、long
* double等基本的数据类型，并且还可以把基本的数据类型取出来，同时它们也有针对字符串的读写方法

Demo:

package com.tai.io;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class DataInputStreamDemo
{
    /**
     * java.io包中还有连个接口DataInput和DataOutput,这两个接口设计了较高级的数据输入输出方式，除了可以处理字节个字节数组外
     * 还可以处理  int、float、boolean等基本的数据类型，这些数据在文件中的表示方式和它们在内存中的方式一样，无序转换，它们相应的提供了
     * 很多处理基本数据类型的方法，如：DataInput提供了read()、readInt()、readByte()等DataOutput提供了write()、writeInt()、
     * writeFloat()、writeChar()等 ....
     * 
     * 而数据流类 DataInputStream和DataOutputStream分别实现了DataInput和DataOutput接口。它们以统一的方式向输入流中写入boolean、int、long
     * double等基本的数据类型，并且还可以把基本的数据类型取出来，同时它们也有针对字符串的读写方法
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException
    {
        FileOutputStream fos = new FileOutputStream(new File("C:/abc/a.txt"));
        DataOutputStream dos = new DataOutputStream(fos);
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入数据： ");
        
        dos.writeBoolean(scan.nextBoolean());
        dos.writeByte(scan.nextInt());
        dos.writeFloat(scan.nextFloat());
        dos.writeShort(scan.nextInt());
        dos.writeChar('A');
        dos.close();
        
        FileInputStream fis = new FileInputStream(new File("C:/abc/a.txt"));
        DataInputStream dis = new DataInputStream(fis);
        System.out.println("读取Boolean数据 \t" + dis.readBoolean());
        System.out.println("读取Byte数据 \t" + dis.readByte());
        System.out.println("读取Float数据 \t" + dis.readFloat());
        System.out.println("读取Short数据 \t" + dis.readShort());
        System.out.println("读取Char数据 \t" + dis.readChar());
        dis.close();
        
    }
}

管道字节流

* 管道用来把程序、线程或程序块的输出连接到另一个程序、线程或者程序块作为它的输入。
* java.io提供了类PipedInputSteramh和PipedOutputStream 作为管道的输入/输出流。
* 管道输入流作为一个通信管道接收端，管道输出流作为发送端。管道流必须是输入流输出流同时并用，即在使用管道前，两者必须进行连接。
* 无论PipedInputStream还是PipdeOutputStream类都提供了connect()方法可以使用connect()方法建立一个管道进行数据传输。
* 管道输入/输出流可以用两种方式进行连接，一种方式是使用connect()方法：
*   PipedInputStream pis = new PipedInputStream();
*  PipedOutputStream pos = new PipedOutputStream();
*  pis.connect(pos);
*  pos.connect(pis);
*  另外一种是直接使用构造方法进行连接：
*  PipedInputStream pis = new PipedInputStream();
*  PipedOutputStream pos = new PipedOutputStream(pis);
*
* 除了connect()方法PipedInputStream类还继承了InputStream类的read()方法。另外又增加了receive()方法
* PipedOutputStream类也继承自OutputStream类的write()方法。

Demo1：

package com.tai.io;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipedStreamDemo
{
/**
 * 管道字节流
 * 管道用来把程序、线程或程序块的输出连接到另一个程序、线程或者程序块作为它的输入。
 * java.io提供了类PipedInputSteramh和PipedOutputStream 作为管道的输入/输出流。
 * 管道输入流作为一个通信管道接收端，管道输出流作为发送端。管道流必须是输入流输出流同时并用，即在使用管道前，两者必须进行连接。
 * 无论PipedInputStream还是PipdeOutputStream类都提供了connect()方法可以使用connect()方法建立一个管道进行数据传输。
 * 管道输入/输出流可以用两种方式进行连接，一种方式是使用connect()方法：
 *         PipedInputStream pis  = new PipedInputStream();
 *        PipedOutputStream pos = new PipedOutputStream();
 *        pis.connect(pos);
 *        pos.connect(pis);
 *        另外一种是直接使用构造方法进行连接：
 *        PipedInputStream pis = new PipedInputStream();
 *        PipedOutputStream pos = new PipedOutputStream(pis);
 *         
 *     除了connect()方法PipedInputStream类还继承了InputStream类的read()方法。另外又增加了receive()方法
 *     PipedOutputStream类也继承自OutputStream类的write()方法。    
 * @throws IOException 
 */
    
    public static void main(String[] args) throws IOException
    {
        int ch1 = 0;
        PipedInputStream pis = new PipedInputStream();
        PipedOutputStream pos = new PipedOutputStream(pis);
        //也可以使用connect()方法
         //    PipedOutputStream pos = new PipedOutputStream();
         //        pos.connect(pis);
        System.out.println("请输入一个字符，按#结束程序！");
        while((ch1 = System.in.read())!='#')
        {
            pos.write(ch1);
            System.out.println((char)pis.read());
        }
    }
}

PipedInputStream 和PipedOutStream常与线程连用，已达到在不同线程间的通讯：

package com.tai.io;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipedStreamDemo2
{
    public static void main(String[] args) throws IOException
    {
        PipedInputStream pis = new PipedInputStream();
        //实例管道输出流并与上面的管道输入流连接
        PipedOutputStream pos = new PipedOutputStream(pis);
        
        new Thread(new InputThread(pis)).start();
        new Thread(new OutputThread(pos)).start();
    }
}

class InputThread implements Runnable
{

    private PipedInputStream pis;
    public InputThread(PipedInputStream in)
    {
        this.pis = in;
    }
    
    @Override
    public void run()
    {
        byte[] buffer = new byte[1024];
        int len = 0;
        try
        {
            len = pis.read(buffer);
            
            String str = new String(buffer,0,len);
            
            System.out.println("管道输入流作为接收端，接受来自管道输出流发送的内容。  内容是：    "+ str);
            pis.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        
    }
}

class OutputThread implements Runnable
{
    private PipedOutputStream pos;
    public OutputThread (PipedOutputStream out)
    {
        this.pos = out;
    }
    @Override
    public void run()
    {
        try
        {
            pos.write("管道输出流作为发送端向管道输入流发送内容".getBytes());
            pos.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
    
}

对象持久化（Persistence）就是将对象保存到磁盘文件或者网络中，保存对象的过程实质上就是对象持久化的过程。
* 也就是记录对象的状态以便于将来具有再生的能力。 Java提供了对象流以实现对象的输入输出，也就是实现对象的持久化。
* 需要注意的是在使用对象流之前必须要将该对象序列化。所谓的序列化就是将对象的状态转化成字节流，并且以后可以通过这些值再生成相同状态的对象。
* 简单来说序列化就是一种用来处理对象流的机制，而对象流也就是将对象的内容进行流化，我们可以对流化后的对象进行读取操作，
* 也可以将流化后的对象传输于网络之间。
*
* 对象序列化，只需要被序列化的类实现Serializable接口就可以了。
* Serializable接口中没有任何的方法，让一个类实现该接口只是为了标注该对象是可以被序列化的，然后就可以对该对象进行持久化。
*
* 注意：序列化只能保存对象的实例变量，但不能保存类的任何方法和类变量，并且保存的只是变量的值。对于任何修饰符都不能保存。
* 有些类型的变量是瞬时的，这样的对象也是无法保存的，如：线程对象、或流对象。对于这样的变量，必须用transient关键字标明，否则编译器将报错。
*
* 任何被transient标明的成员变量，将不被保存。
* 考虑到序列化可能涉及对象保存在磁盘上或者网络上，对于一些保密的数据就要加上transient关键字。
*
*
* 对象序列化之后，必须与一定的对象输入/输出流联系起来，通过对象输出流将对象的状态保存下来，再通过对象输入流将对象的状态恢复。
* java提供了ObjectInputStream
* 类和ObjectOutputStream类分别实现了ObjectInput和ObjectOutput。
* ObjectOutput接口用writeObject
* ()方法，可以将对象的状态保存到输出流中。而ObjectInput接口用readObject()方法以从输入流中读入一个对象。
*

package com.tai.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class PersistenceDome
{
    /**
     * 对象持久化（Persistence）就是 将对象保存到磁盘文件或者网络中，保存对象的过程实质上就是对象持久化的过程。
     * 也就是记录对象的状态以便于将来具有再生的能力。 Java提供了对象流以实现对象的输入输出，也就是实现对象的持久化。
     * 需要注意的是在使用对象流之前必须要将该对象序列化。所谓的序列化就是将对象的状态转化成字节流，并且以后可以通过这些值 再生成相同状态的对象。
     * 简单来说序列化就是一种用来处理对象流的机制，而对象流也就是将对象的内容进行流化，我们可以对流化后的对象进行读取操作，
     * 也可以将流化后的对象传输于网络之间。
     * 
     * 对象序列化，只需要被序列化的类实现Serializable接口就可以了。
     * Serializable接口中没有任何的方法，让一个类实现该接口只是为了标注该对象是可以被序列化的，然后就可以对该对象进行持久化。
     * 
     * 注意： 序列化只能保存对象的实例变量，但不能保存类的任何方法和类变量，并且保存的只是变量的值。 对于任何修饰符都不能保存。
     * 有些类型的变量是瞬时的，这样的对象也是无法保存的，如：线程对象、或流对象。对于这样的变量，必须用transient关键字标明，否则编译器将报错。
     * 
     * 任何被transient标明的成员变量，将不被保存。
     * 考虑到序列化可能涉及对象保存在磁盘上或者网络上，对于一些保密的数据就要加上transient关键字。
     * 
     * 
     * 对象序列化之后，必须与一定的对象输入/输出流联系起来，通过对象输出流将对象的状态保存下来，再通过对象输入流将对象的状态恢复。
     * java提供了ObjectInputStream
     * 类和ObjectOutputStream类分别实现了ObjectInput和ObjectOutput。
     * ObjectOutput接口用writeObject
     * ()方法，可以将对象的状态保存到输出流中。而ObjectInput接口用readObject()方法以从输入流中读入一个对象。
     * 
     * @throws Exception
     */
    public static void main(String[] args) throws Exception
    {
        Person p = new Person("张三", "Mauiie", "男");
        Person p2 = new Person("p2", "Mauiie", "男");
        Person p3 = new Person("p3", "Mauiie", "男");
        Student s = new Student("孙俪", "Mauiie", "女");
        Person temp = null;
        Person temp2 = null;
        Student stemp = null;
        FileOutputStream fos = new FileOutputStream("c:/data.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(p);
        oos.writeObject(p2);
//        oos.writeObject(p3);
        oos.writeObject(s);
        oos.close();
        System.out.println("已经将p和s对象写入到了 c:/data.dat");

        FileInputStream fis = new FileInputStream("c:/data.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);

        temp = (Person) ois.readObject();
        temp2 = (Person) ois.readObject();
        stemp = (Student) ois.readObject();
        
        ois.close();
        System.out.println(temp.toString());
        System.out.println(stemp.toString());
        System.out.println(temp2.toString());
    }
}

class Person implements Serializable
{
    String Pname;
    transient String Pid;
    String Psex;

    public Person(String name, String ID, String sex)
    {
        this.Pname = name;
        this.Pid = ID;
        this.Psex = sex;
    }

    public String toString()
    {
        return "Name  " + Pname + "  ID  " + Pid + "  sex  " + Psex;
    }
}

class Student implements Serializable
{
    String Sname;
    transient String Sid;
    String Ssex;

    public Student(String name, String ID, String sex)
    {
        this.Sname = name;
        this.Sid = ID;
        this.Ssex = sex;
    }

    public String toString()
    {
        return "这是Student对象      " + "Name  " + Sname + "  ID  " + Sid
                + "  sex  " + Ssex;
    }
}

ObjectInputStream/ObjectOutputStream

运行结果：

已经将p和s对象写入到了 c:/data.dat
Name  张三  ID  null  sex  男
这是Student对象      Name  孙俪  ID  null  sex  女
Name  p2  ID  null  sex  男

值得注意的是：

使用缺省的serializetion的实现时，一个ObjectOutputStream的构造和一个ObjectInputStream的构造必须一一对应。

ObjectOutputStream的构造函数会向输出流中写入一个标识头，而ObjectInputStream会首先读入这个标识头。因此，多次以追加方式向一个文件中写入object时，该文件将会包含多个标识头。

所以用ObjectInputStream来deserialize这个ObjectOutputStream时，将产生StreamCorruptedException。
一种解决方法是可以构造一个ObjectOutputStream的子类，并覆盖writeStreamHeader()方法。被覆盖后的writeStreamHeader()方法应判断是否为首次向文件中写入object?

若是，则调用super.writeStreamHeader()；若否，即以追加方式写入object时，则应调用ObjectOutputStream.reset()方法。