ObjectInputStream和ObjectOutputStream类

1.  在Java程序执行过程中，很多数据都是以对象的方式存在于内存中。有时会希望直接将内存中的对象存储至文件，而不是仅存储对象中的某些基本类型成员信息，而在下一次程序运行时，希望能从文件中读出数据并还原为对象。这时可以利用java.io.ObjectInputStream和java.io.ObjectOutputStream类来进行这项工作。

2.  如果要存储对象，定义该对象的类必须实现java.io.Serializable接口，这是一个标志接口，没有规范任何必须实现的方法，仅仅代表该对象是可序列化的(Serializable)。为了说明如何直接存储对象，先来实现一个User类。

package onlyfun.caterpillar;

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String name;
    private int number; 

    public User() { 
    } 

    public User(String name, int number) { 
        this.name = name; 
        this.number = number; 
    } 

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

    public String getName() { 
        return name; 
    } 

    public int getNumber() { 
        return number; 
    } 
}

 注意到serialVersionUID,它代表了可序列化对象的版本。如果没有提供这个版本信息，则实现Serializable接口的类会自动根据类名称、实现的接口、成员等来产生。如果是自动产生的，则下次更改User类，自动产生的serialVersionUID也会跟着变更，从文件读回对象时若两个对象的serialVersionUID不相同，就会丢出java.io.InvalidClassException。如果想要维持版本信息的一致，则要明确声明serialVersionUID。

3. 在写入对象时，要使用writeObject()方法，读出对象时用readObject()方法，被读出的对象都是以Object的类型返回的。所以，必须将之转换为对象原来的类型，才能正确地实现被读回的对象。下面的例子示范了如何将User对象存储至文件中，然后再将它读回并还原为User实例。

package ysu.hxy;

import java.io.*;
import java.util.*;

public class ObjectStreamDemo
{
	public static void main(String[] args) 
	{
		User[] users = {new User("cater",101),new User("justin",102)};
		//写入新文件
		writeObjectsToFile(users,args[0]);

		try
		{
			//读取文件数据
			users = readObjectsFromFile(args[0]);
			//显示读回的对象
			for(User user : users)
			{
				System.out.printf("%s\t%d%n",user.getName(),user.getNumber());
			}
			System.out.println();

			users = new User[2];
			users[0] = new User("momor",103);
			users[1] = new User("becky",104);

			//附加新对象至文件
			appendObjectsToFile(users,args[0]);

			//读取文件数据
			users = readObjectsFromFile(args[0]);
			//显示读回的对象
            for(User user : users)
			{
				System.out.printf("%s\t%d%n",user.getName(),user.getNumber());
			}
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println("没有指定文件名");
		}
		catch(FileNotFoundException e)
		{
            e.printStackTrace();
	    }
	}

	//将指定的对象写入至指定的文件
	public static void writeObjectsToFile(Object[] objs,String filename)
	{
		File file = new File(filename);

		try
		{
			ObjectOutputStream objOutputStream =
				new ObjectOutputStream(new FileOutputStream(file));

			for(Object obj : objs)
			{
				//将对象写入文件
			    objOutputStream.writeObject(obj);
			}
			
			//关闭流
			objOutputStream.close();
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
	}

	//将指定文件中的对象数据读回
	public static User[] readObjectsFromFile(String filename) throws FileNotFoundException
	{
		File file = new File(filename);

        //如果文件不存在就抛出异常
		if(!file.exists())
			throw new FileNotFoundException();

		//使用List先存储读回的对象
		List<User> list = new ArrayList<User>();

		try
		{
			FileInputStream fileInputStream = new FileInputStream(file);
			ObjectInputStream objInputStream = new ObjectInputStream(fileInputStream);
            
			while(fileInputStream.available()>0)
			{
				list.add((User)objInputStream.readObject());
			}
			objInputStream.close();
		}
		catch(ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}

		User[] users = new User[list.size()];
		return list.toArray(users);
	}

	//将对象附加至指定的文件之后
	public static void appendObjectsToFile(Object[] objs,String filename) throws FileNotFoundException
	{
		File file = new File(filename);

		//如果文件不存在，则抛出异常
		if(!file.exists())
			throw new FileNotFoundException();

		try
		{
			//附加模式
			ObjectOutputStream objOutputStream = 
				new ObjectOutputStream(new FileOutputStream(file,true))
				{
                       //如果要附加对象至文件后，必须重新定义这个方法
					   protected void writeStreamHeader() throws IOException{}
				};

		    for(Object obj : objs)
			{
				//将对象写入文件
				objOutputStream.writeObject(obj);
			}
			objOutputStream.close();
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
	}
}

 注意，在试图将对象附加至一个先前已写入对象的文件时，由于ObjectOutputStream在写入数据时，还会加上一个特别的流头(Stream Header)，所以在读取文件时会检查这个流头。如果一个文件中被多次附加对象，那么该文件中会有多个流头，这样读取检查时就会发现不一致，这会丢出java.io.StreamCorruptedException异常。为了解决这个问题，可以重新定义ObjectOutputStream的writeStreamHeader()方法，这样的话如果是以附加方式来写入对象，就不再重复写入流头：

ObjectOutputStream objOutputStream (new FileOutputStream(file,true))
	{
	  protected void writeStreamHeader() throws IOException{}
	};