Java的对象序列化以及文件IO处理

最新推荐文章于 2022-04-20 17:44:00 发布

最新推荐文章于 2022-04-20 17:44:00 发布 · 106 阅读

文章标签：

本文详细介绍了Java中对象序列化的概念、应用场景及其实现过程。包括如何通过实现Serializable接口进行对象序列化，以及序列化与反序列化的具体步骤。同时对比了对象序列化与普通文件读写的区别。

1．对象的序列化就是保存对象的当前状态。

2．保存对象的状态有两种主要的方式：

1)对象序列化 (将对象写入到文件 ,以后再反序列化 ,见后例 )

如果保存的数据用于 Java程序内交互，则采用对象的序列化；

2)写入文件 (将对象写入到文本文件 ,注意 ,是 文本文件 )

如果保存的数据用于和其他非 Java程序交互，则保存到文本文件。

3．对象如果需要序列化，则它所在的类必须要实现 Serializable接口。

如果某类是可序列化的，则它的子类自动地可以序列化。

4．对象序列化的步骤：

1) 创建文件输出流；

2)创建对象输出流；

3)写入对象状态；

4)关闭对象输出流；

//1.创建文件输出流

FileOutputStream fs = new FileOutputStream("OutputFile.file");
        
//2.创建对象输出流

ObjectOutputStream os = new ObjectOutputStream(fs);

//3.写入对象状态

os.writeObject(characterOne);
os.writeObject(characterTwo);
os.writeObject(characterThree);

//4.关闭对象输出流

os.close();

对象写入文件的顺序为：

其中， ObjectOutputStream是把对象转换成字节流； FileOutputStream是把字节流写入文件。

5．序列化对象会把对象的所有属性保存，被对象的实例变量所引用的对象也会被序列化。

如果某实例变量不能或不应该被序列化，则把这个变量标记为 transient。将属性标记为 transient 后，对象序列化时会将该属性保存为 null值。

6．对象解序列化的步骤：

1)创建文件输入流；

2)创建对象输入流；

3)读出对象状态；

4)转换对象类型（因为对象读出后为 Object类型）；

5)关闭对象输入流；

//1.创建文件输入流
,如果文件不存在
,则程序抛出异常

FileInputStream fs = new FileInputStream("OutputFile.file");

//2.创建对象输入流

ObjectInputStream oi = new ObjectInputStream(fs);

//3.读出对象状态

Object one = oi.readObject();
Object two = oi.readObject();
Object three = oi.readObject();

//4.转换对象类型

GameCharacter elf = (GameCharacter) one;
GameCharacter troll = (GameCharacter) two;
GameCharacter magician = (GameCharacter) three;
                
//5.关闭对象输入流

oi.close();

对象写出的顺序为：

在对象读出到对象输入流后， JVM会尝试查找和加载对象的类，如果不成功则报异常。

7． 对象被还原时，静态变量维持类中原本的样子，而不是存储时的样子。

8．将对象状态写入文件的步骤：（使用 BufferedWriter）

//先用缓冲区存放数据
,然后链接到文件

BufferedWriter writer = new BufferedWriter(new FileWriter(aFile));
//写入数据

writer.write("blabla");
//关闭

writer.close();

对象写入文件的顺序：

使用缓冲区 Writer的原因：如果直接使用 FileWriter的话，写硬盘需要好多次，速度较慢（硬盘读写速度远远慢于内存读写速度）。使用了缓冲区 Writer就可以先缓冲数据，然后一次性得写到硬盘文件中。

9．将对象从文件读出的步骤：（使用 BufferedReader）

//FileReader是字符的连接到文本文件的串流

FileReader fileReader = new FileReader(new File("File.txt"));
//使用
BufferedReader链接到
FileReader,使得接收更有效率

BufferedReader reader = new BufferedReader(fileReader);

String line = null;
//挨行打印出数据

while((line = reader.readLine())!= null)
{
        System.out.println(line);
}

文件读出的过程中，使用 BufferedReader去链接 FileReader，使得接收更有效率。

---------------------------------------

以下是一个对象序列化 ,反序列化以及文件 IO的例子 ,以后可以翻阅

class CashCheck implements Serializable
{
        private static final long serialVersionUID = -8872155900725314694L;

        private String cashCheckID;

        private int cashAmout;

        public CashCheck()
        {
        }

        public String getCashCheckID()
        {
                return cashCheckID;
        }

        public void setCashCheckID(String cashCheckID)
        {
                this.cashCheckID = cashCheckID;
        }

        public int getCashAmout()
        {
                return cashAmout;
        }

        public void setCashAmout(int cashAmout)
        {
                this.cashAmout = cashAmout;
        }
}

public class SerializeDemo01
{
        public static void main(String[] args)
        {
                CashCheck check = new CashCheck();
                check.setCashAmout(10000);
                check.setCashCheckID("notifier");

                /*
                 * 序列化对象

                 */
                try
                {
                        // 1.创建文件输出流
,负责将字节写入文件

                        FileOutputStream fs = new FileOutputStream(
                                        new File(
                                                        "C://Documents and Settings//Administrator//桌面
//notifier.file"));

                        // 2.创建对象输出流
,负责将对象转为字节

                        ObjectOutputStream os = new ObjectOutputStream(fs);

                        // 3.写入对象

                        os.writeObject(check);

                        // 4.关闭对象输出流

                        os.close();
                } catch (FileNotFoundException e)
                {
                        e.printStackTrace();
                } catch (IOException e)
                {
                        e.printStackTrace();
                }

                /*
                 * 解序列化对象

                 */
                try
                {
                        // 1.创建文件输入流
,负责将文件转为字节

                        FileInputStream fi = new FileInputStream(
                                        "C://Documents and Settings//Administrator//桌面
//notifier.file");

                        // 2.创建对象输入流
,负责将字节写入对象

                        ObjectInputStream oi = new ObjectInputStream(fi);

                        // 3.读出对象

                        Object o1 = oi.readObject();
                        if (o1 instanceof CashCheck)
                        {
                                CashCheck check1 = (CashCheck) o1;
                                System.out.println(check1.getCashCheckID());
                                System.out.println(check1.getCashAmout());
                        }

                        // 4.关闭对象输入流

                        oi.close();
                } catch (FileNotFoundException e)
                {
                        e.printStackTrace();
                } catch (IOException e)
                {
                        e.printStackTrace();
                } catch (ClassNotFoundException e)
                {
                        e.printStackTrace();
                }

                /*
                 * 以文件的形式读出序列化文件
,是乱码

                 */
                try
                {
                        FileReader fr = new FileReader(
                                        new File(
                                                        "C://Documents and Settings//Administrator//桌面
//notifier.file"));
                        BufferedReader br = new BufferedReader(fr);

                        String line = null;
                        while ((line = br.readLine()) != null)
                        {
                                System.out.println(line);
                        }
                } catch (FileNotFoundException e)
                {
                        e.printStackTrace();
                } catch (IOException e)
                {
                        e.printStackTrace();
                }
        }
}