13.序列化和IO流（存储恢复）

1.序列化

对象序列化

用来存储对象的状态。

将被序列化的对象写到文件中，然后可以让你的程序去文件中读取序列化的对象并把他们展开回到活生生的状态。

当对象被序列化时，该对象引用的实例变量也被序列化，且所有被引用的对象也被序列化。

 

如果要让类能够被序列化，实现Serializable，此接口没有任何方法需要实现，唯一目的就是是声明有实现它的类是可以被序列化。

objectOutputStream.writeObject(myBox)

任何放在此处的对象都必须实现序列化，否则执行期一定会出问题。

步骤：

1.创建出FileOutputStream
   FileOutputStream fileStream = new FileOutputStream("MyGame.ser");
2.创建ObjectOutputStream
   ObjectOutputStream os = new ObjectOutputStream(fileStream);
3.写入对象
  os.writeObject(characterOne);
4.关闭ObjectOutputStream
  os.close();

解序列化(Deserialization)

把对象恢复到存储时的状态。从第一个不可序列化的父类开始，全部都会重新初始状态。

步骤：

1.创建FileInputStream
  FileInputStream fileStream = new FileInputStream("MyGame.ser");
2.创建ObjectInputStream
 ObjectInputStream os = new ObjectInputStream(fileStream);
3.读取对象
 Object one = os.readObject();
4.转换对象类型，返回的是Object
 GameCharacter elf = (GameCharacter) one;
5.关闭ObjectInputStream
  Os.close();

如果某实例变量不能/不应该被序列化，应标记成transient

读取对象的顺序必须与写入的顺序相同。

2.IO流

从数据源当中读取数据，以及将数据写入到数据的目的地当中

数据的流向以java程序为参照物。

 

1.IO的分类方法

       分法一： 1.输入流；2.输出流；

       分法二： 1.字节流；2.字符流；

       分法三： 1.节点流(真正处理数据)；2.处理流(用来在节点流基础上对数据再加工)；

2.读取文件和写入文件方法

   2.1字节流

    1）核心类

    

     InputStream和OutputStream是抽象类，父类。

     这里有个trim方法：Stream的trim方法可以把首尾的空格和空字符去掉

     2）核心方法

     InputStream：

     int read(byte[] b,int off,int len)  字节数组

     读取数据

     off：偏移量从b的第几位开始。

     len读取一次最多读多少数据。   

     read方法的返回值为读的字节数。

 

     OutputStream:

     int write(byte[] b,int off,int len)   

     数据写到文件去

     byte[]：往文件里写的数据

     off：从第几位写

     len：总共写多少字节数据
     3)步骤

   1.导入类
     import java.io.*;
   2.加上try  catch，声明FileInputStream引用，用来指向其一个对象
     FileInputStream fis = null;
   3.生成代表输入流/输出流的对象
     fis = new FileInputStream("D:/workspace/java_src/from.txt");
   4.生成一个字节数据
     byte[] buffer = new byte[100];
   5.调用输入流对象的read方法，读取数据
     int temp = fis.read(buffer,0,buffer.length); 读完返回-1；
     读进来放进buffer，从第0个放，buffer.length这次读取长度数据。
   6.最后关闭IO流：对象.close()；　

1. //声明输入流
   FileInputStream fis =null;
   //声明输出流的引用
   FileOutputStream fos =null;
   try
   {
   //步骤三：生成代表输入流的对象
   fis =newFileInputStream("D:/workspace/java_src/from.txt");
   //生成代表输出流的对象
   fos =newFileOutputStream("D:/workspace/java_src/to.txt");
   //步骤四：生成一个字节数组
   byte[] buffer =newbyte[100];
   //步骤五：调用输入流对象的read方法，读取数据
   int temp = fis.read(buffer,0,buffer.length);
   fos.write(buffer,0,temp);
   // for(int i = 0;i < buffer.length;i++)
   // {
   // System.out.println(buffer[i]);
   // }
   //String s = new String(buffer);
   //调用一个Srting对象的trim方法将会取出掉字符串的首尾空格和空字符
   //s = s.trim();
   // System.out.println(s);
   }
   catch(Exception e)
   {
   System.out.println(e);
   }

   2.2字符流

        读写文件时，以字符为基础

        字节输入流：Reader<----FileReader两个子类。

        字节输出流：Writer<---FileWriter

        好比字节流中的FileInputStream和FileOutputStream

        核心方法：

           int read(char [] c,int off,int len)  字符数组

           void write(char [],int off,int len)

1. FileReader fr =null;
   FileWriter fw =null;
   try
   {
       fr =newFileReader("D:/workspace/java_src/from.txt");
       fw =newFileWriter("D:/workspace/java_src/to.txt");
       char[] buffer =newchar[100];
       int temp = fr.read(buffer,0,buffer.length);
       fw.write(buffer,0,temp);
   }
   catch(Exception e)
   {
       System.out.println(e);
   }
   finally
   {
       try
       {
          fr.close();
          fw.close();
       }
   catch(Exception e)
      {
         System.out.println(e);
      }
   }

   2.3处理流和节点流

        1)BufferReader用法

           有一个readline方法，并不是真的从文件读，而是从FileReader对象读取数据，传过去的，再用readline进一步处理。 

           生成对象：

           fileReader = new FileReader("D:/workspace/java_src/User.txt");

           bufferedReader = new BufferedReader(fileReader);

           读取文件中一行：

           String line = null;

           line = bufferedReader.readLine();

1. FileReader fileReader =null;
   BufferedReader bufferedReader =null;
   try
   {
       fileReader =newFileReader("D:/workspace/java_src/User.txt");
       bufferedReader =newBufferedReader(fileReader);
       String line =null;
       while(true)
      {
          line = bufferedReader.readLine();
          if(line ==null)
          {
           break;
          }
          System.out.println(line);
      }
   }
   catch(Exception e)
   {
      System.out.println(e);
   }
   finally
   {
     try
     {
       bufferedReader.close();
       fileReader.close();
      }
     catch(Exception e)
     {
       System.out.println(e);
     }
   }

       2)装饰者模式

           节点流是被装饰者，处理流是装饰者。装饰者是给被装饰者添加新的功能。

            被装饰着的对象作为参数传递到装饰者里。