Java里的IO流里的 ObjectInputStream 的读取\写入！

各位好！！我又来了！！今天遇见了一个小问题！！

IO流里的对象读取总是出错！各种报错！！神烦啊！！百思不得其解啊！然后就上网百度！找了好久终于让我找到了！下面就让我来说一说！

当你用IO流里的对象流写入的时候，ObjectOutputStream会在文件中的开头和结尾进行一个标识AC/DC，ObjectInputStream会严格的根据开头和结尾来进行读取，当读取不到的时候就会进行报错！！

ObjectOutputStream无法将上一次的对象的结尾的DC消除，所以千万不要用FileOutPutStream（“文件地址”，true）来添加；

当想要向文件中再次添加对象的时候，必须先进行读取文件中的对象并添加在集合中完毕后并关闭资源，然后遍历集合进行添加对象完毕并关闭资源！-----》先读取后添加！

代码中的注意点有一点是橘色的，这个很重要！当进行close的时候结尾（DC）也会随之而添加上！

我这个人比较倾向于实战！可以直接将我的代码复制到各位的eclipse中或其他的什么！代码中有详细的解释和一些被我注释掉的代码！那些也是正确可以运行的！各位也可以进行比较一下哪种方法好！

如果有错误的话，请指正！！！

 import java.io.EOFException;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.util.ArrayList;
 //想要序列化对象必须接口Serializable，否则不能被序列化
 class Car implements Serializable{

     /**
      * 给对象添加一个唯一的ID,便于以后增删成员变量！
      */
     private static final long serialVersionUID = 1L;
     String brand;
     transient String owner;//添加transient  防止此成员变量被泄露！
     public Car(String brand,String owner){
         this.brand = brand;
         this.owner = owner;
     }

 }

 public class ObjectOutAndIn {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         /**
          * ********写入方法**********
          */
         /*(1)*///writerIn();
         /**
          * ********读取方法**********
          */
         /*(2)*///readerOut();
         /**
          * ****读取/写入多个对象的方法****
          * 建议将步骤一和二注释掉！
          */
         /*(3)*/writerInAndreaderOut();
     }

     public static void writerInAndreaderOut(){
         /**
          * 当想写入多个对象时，有两种方法！
          * 方法一：（1）创建一个集合将对象添加进该集合，然后将集合的对象写入文件中；
          *           （2）等到用的时候直接读取集合对象，从集合中获取对象
          * 方法二：（1）创建一个集合将对象添加进该集合，然后遍历集合对象
          *            （2）用同一个对象写入流来写入对象
          * 对象写入注意：（1）当写入对象的时候，对象写入流会在开头和结尾添加AC/DC
          *                 （2）必须用同一个对象写入流写入，因为在对象写入流close的时候会添加DC
          *                 ，再次写入另外一些对象的时候DC也不会消失，所以当读取的时候就会出现错误！
          *                 （3）以上是我自己的见解，如果出错的话请留言各位！！
          */

         //创建一个集合对象
         ArrayList<Car> arr = new ArrayList<Car>();
         arr.add(new Car("兰博基尼", "刘能"));
         arr.add(new Car("劳斯莱斯", "赵四"));

         /**
          * 方式一：
          */
         /**
          * 写入集合对象
          */
         /*try {
             //创建一个写入通道
             FileOutputStream out = new FileOutputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
             try {
                 //创建一个对象写入通达！
                 ObjectOutputStream objOut = new ObjectOutputStream(out);
                 //开始写入集合对象
                 objOut.writeObject(arr);
                 //关闭写入资源
                 objOut.close();
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }*/
         /**
          * 读取集合对象
          */
         /*try {
             //创建一个写入通道
             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
             try {
                 //创建一个对象读取通达！
                 ObjectInputStream objIn = new ObjectInputStream(in);
                 try {
                     //读取对象，返回的是一个Object类型的对象（需强转）
                     ArrayList<Car> readArray = (ArrayList<Car>)objIn.readObject();
                     //遍历读取到的readAraay集合！
                     for(Car c:readArray){
                         System.out.println(c.brand+c.owner);
                     }
                     //关闭读取资源
                     objIn.close();
                 } catch (ClassNotFoundException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }*/

         /**
          * 方式二：
          */
         /**
          * 写入集合对象
          */
         /*try {
             //创建一个写入通道
             FileOutputStream out = new FileOutputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
             try {
                 //创建一个对象写入通达！
                 ObjectOutputStream objOut = new ObjectOutputStream(out);
                 //利用for循环来写入Car对象！
                 for(Car c:arr){
                     objOut.writeObject(c);
                 }
                 //关闭写入资源！
                 objOut.close();
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }*/
         /**
          * 读取集合对象
          */
         try {
             //创建一个写入通道
             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
             try {
                 //创建一个对象读取通达！
                 ObjectInputStream objIn = new ObjectInputStream(in);
                 try {
                     try {
                         //while循环读取对象并打印！
                         while(true){
                             Car c = (Car)objIn.readObject();
                             System.out.println(c.brand+c.owner);
                         }
                     } catch (ClassNotFoundException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                 } catch (EOFException e) {
                     //当while循环完毕后会爆出---》 java.io.EOFException》代表打印完毕！
                     System.out.println("打印完毕！！");
                 }finally{
                     //关闭读取资源
                     objIn.close();
                 }
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

     public static void readerOut(){
         try {
             //创建一个写出通道
             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\List.txt");
             try {
                 //创建一个写出对象的通道!
                 ObjectInputStream objIn = new ObjectInputStream(in);
                 try {
                     //读取对象，返回的是一个Object类型的对象（需强转）
                     Car car = (Car)objIn.readObject();
                     //打印一下，看是否是步骤一写入的对象！---->由于owner是被transient修饰的所以显示为null
                     System.out.println(car.brand + car.owner);
                 } catch (ClassNotFoundException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

     public static void writerIn(){
                 try {
                     //创建一个写入通道！
                     FileOutputStream out = new FileOutputStream("C:\\Users\\wang\\Desktop\\List.txt");
                     try {
                         //创建一个写入对象的通道!
                         ObjectOutputStream objOut = new ObjectOutputStream(out);
                         //创建一个对象
                         Car car = new Car("奔驰", "张三");
                         //写入对象
                         objOut.writeObject(car);
                         //关闭写入资源
                         objOut.close();
                         /**
                          * ********在此时写入完成！********
                          */
                     } catch (IOException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                 } catch (FileNotFoundException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
     }

 }

在接下来的代码中可以读取/写入---->覆盖原有对象并添加新对象！

 public static void writerInOrReaderOut(){

         ArrayList<Car> arr = new ArrayList<Car>();
         try {
             //创建读取的通道
             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
             try {
                 //创建对象读取通道！
                 ObjectInputStream objIn = new ObjectInputStream(in);
                 try {
                     try {
                         //开始读取
                         while(true){
                             try {
                                 Car c = (Car) objIn.readObject();
                                 //向集合中添加对象
                                 arr.add(c);
                             } catch (ClassNotFoundException e) {
                                 // TODO Auto-generated catch block
                                 e.printStackTrace();
                             }

                         }
                     } catch (EOFException e) {
                         // TODO Auto-generated catch block
                         System.out.println("添加完了！");
                     }
                 }finally{
                     objIn.close();
                 }

             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         try {
             //创建输出通道！
             FileOutputStream out = new FileOutputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
             try {
                 //创建对象输出通道！
                 ObjectOutputStream objOut = new ObjectOutputStream(out);
                 //for循环遍历
                 for(Car c:arr){
                     objOut.writeObject(c);
                 }
                 //在这里添加某个对象
                 objOut.writeObject(new Car("兰博基尼", "纷纷"));
                 //关闭资源
                 objOut.close();
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

         try {
             //创建读取的通道
             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
             try {
                 //创建对象读取通道！
                 ObjectInputStream objIn = new ObjectInputStream(in);
                 try {
                     try {
                         //开始读取
                         while(true){
                             try {
                                 //读取对象！
                                 Car c = (Car) objIn.readObject();
                                 //打印对象！
                                 System.out.println(c.brand+c.owner);
                             } catch (ClassNotFoundException e) {
                                 // TODO Auto-generated catch block
                                 e.printStackTrace();
                             }
                         }
                     } catch (EOFException e) {
                         // TODO Auto-generated catch block
                         System.out.println("打印完了！");
                     }
                 }finally{
                     //关闭资源！
                     objIn.close();
                 }

             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }