Java复习之IO对象流

这篇博客主要是总结一下Java中的IO对象流。

1.对象序列化

对象序列化就是指将一个对象转化成二进制的byte流

两种情况：
将对象保存在文件上的操作称为对象的序列化操作
将对象从文件中恢复称为反序列化的操作

使用ObjectOutputStream类实现对象的序列化，使用ObjectInputStream类实现反序列

被序列化对象所在的类必须实现java.io.Serializable接口

**
 * 要序列化的对象千万不要忘记实现serializable接口
 * 标记接口，没有任何方法
 */
public class Dog implements Serializable{
    private String name;
    private int age;
    public  Dog()
    {
    }
    public Dog(String name,int age)
    {
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "name:"+name+" age:"+age;
    }
}

2.ObjectOutputStream

public class ObjectOutputStream
extends OutputStream
implements ObjectOutput,ObjectStreamConstants

ObjectOutputStream将java对象的基本数据类型和图形写入OutputStream

public ObjectOutputStream(OutputStream out) throws IOException

接收OutputStream实例，进行实例化操作

public final void writeObject(Object obj) throws IOException
输出一个对象

public void close() throws IOException
关闭

/**
     * 使用ObjectOutputStream把对象写入文件中
     */
    public static void writeObject()
    {
        try {
            OutputStream outputStream =new FileOutputStream(
                    new File("H:"+ File.separator+"对象输出.txt")
            );
           //根据字节输出流构造一个对象流
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            //输出数据
            objectOutputStream.writeInt(111);
            //输出对象
            objectOutputStream.writeObject(new Dog("小白",3));
        }catch (FileNotFoundException ex)
        {
            ex.printStackTrace();
        }catch (IOException ex)
        {
            ex.printStackTrace();
        }
    }

3.ObjectInputStream

public class ObjectInputStream
extends InputStream
implements ObjectInput,ObjectStreamConstants

ObjectInputStream对以前使用的ObjectOutputStream
写入的数据和对象进行反序列化

public ObjectInputStream(InputStream in) throws IOException
根据输入流的不同，实例化ObjectInputStream类的对象

public final Object readObject() throws
IOException,ClassNotFoundException
读取对象

 /**
     * 使用ObjectOInputStream把从文件中读取对象
     */
    public static void readerObject()
    {
        try {
            InputStream inputStream=new FileInputStream(
                    new File("H:"+File.separator+"对象输出.txt")
            );
            //根据字节输入流构造一个对象流
            ObjectInputStream objectInputStream=new ObjectInputStream(inputStream);
            //读取的时候一定要按照写入的顺序读取
            //读取一个整数
            int num=objectInputStream.readInt();
            //读取一个对象
            Dog dog =(Dog)objectInputStream.readObject();
            System.out.println("num=:"+num);
            System.out.println(dog);
            objectInputStream.close();
            inputStream.close();
        }catch (FileNotFoundException ex)
        {
            ex.printStackTrace();
        } catch (IOException ex)
        {
            ex.printStackTrace();
        }catch (ClassNotFoundException ex)
        {
            ex.printStackTrace();
        }
    }

4.序列化一组对象

在序列化操作中，同时序列化多个对象时，反序列化也必须
按照顺序操作，如果想要序列化一组对象该如何操作？

序列化一组对象可采用：
对象数组的方式，因为对象数组可以向Object进行转型操作

//把一组对象序列化到文件中
    public static void writeObject2()
    {
        try {
            OutputStream outputStream =new FileOutputStream(
                    new File("H:"+ File.separator+"对象输出1.txt")
            );
            //根据字节输出流构造一个对象流
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            //输出对象
            Dog [] dogs={new Dog("小白",3),new Dog("小红",2),
                    new Dog("小黑",4)};
            //以对象数组形式写入
            objectOutputStream.writeObject(dogs);
        }catch (FileNotFoundException ex)
        {
            ex.printStackTrace();
        }catch (IOException ex)
        {
            ex.printStackTrace();
        }
    }
//将一组对象读取到程序中来
    public static void readerObject2()
    {
        try {
            InputStream inputStream=new FileInputStream(
                    new File("H:"+File.separator+"对象输出1.txt")
            );
            //根据字节输入流构造一个对象流
            ObjectInputStream objectInputStream=new ObjectInputStream(inputStream);
            //读取的时候一定要按照写入的顺序读取
            //注意数组的强制类型转换
            Dog [] dogs =(Dog[])objectInputStream.readObject();
            //打印数组的内容
            //在不知道具体的对象的个数的时候使用foreach循环
            for(Dog dog:dogs)
            {
                System.out.println(dog);
            }
            objectInputStream.close();
            inputStream.close();
        }catch (FileNotFoundException ex)
        {
            ex.printStackTrace();
        } catch (IOException ex)
        {
            ex.printStackTrace();
        }catch (ClassNotFoundException ex)
        {
            ex.printStackTrace();
        }
    }

5.transient关键字

如果用transient声明一个实例变量，当对象存储时，它的值不需要维持

当持久化对象时，可能有一个特殊的对象数据成员我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialzation，可以在这个域前加上关键字transient。当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的