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

灰太狼 2022-07-14 11:52 80阅读 0赞

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