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();
        }
        
        
    }