首页 > 代码库 > Java里的IO流里的 ObjectInputStream 的读取\写入！

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

2024-08-25 23:35:18   223人阅读

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

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

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

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

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

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

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

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

  1 import java.io.EOFException;
  2 import java.io.FileInputStream;
  3 import java.io.FileNotFoundException;
  4 import java.io.FileOutputStream;
  5 import java.io.IOException;
  6 import java.io.ObjectInputStream;
  7 import java.io.ObjectOutputStream;
  8 import java.io.Serializable;
  9 import java.util.ArrayList;
 10 //想要序列化对象必须接口Serializable，否则不能被序列化
 11 class Car implements Serializable{
 12 
 13     /**
 14      * 给对象添加一个唯一的ID,便于以后增删成员变量！
 15      */
 16     private static final long serialVersionUID = 1L;
 17     String brand;
 18     transient String owner;//添加transient  防止此成员变量被泄露！
 19     public Car(String brand,String owner){
 20         this.brand = brand;
 21         this.owner = owner;
 22     }
 23     
 24 }
 25 
 26 public class ObjectOutAndIn {
 27 
 28     /**
 29      * @param args
 30      */
 31     public static void main(String[] args) {
 32         // TODO Auto-generated method stub
 33         /**
 34          * ********写入方法**********
 35          */
 36         /*(1)*///writerIn();
 37         /**
 38          * ********读取方法**********
 39          */
 40         /*(2)*///readerOut();
 41         /**
 42          * ****读取/写入多个对象的方法****
 43          * 建议将步骤一和二注释掉！
 44          */
 45         /*(3)*/writerInAndreaderOut();
 46     }
 47     
 48     public static void writerInAndreaderOut(){
 49         /**
 50          * 当想写入多个对象时，有两种方法！
 51          * 方法一：（1）创建一个集合将对象添加进该集合，然后将集合的对象写入文件中；
 52          *           （2）等到用的时候直接读取集合对象，从集合中获取对象
 53          * 方法二：（1）创建一个集合将对象添加进该集合，然后遍历集合对象
 54          *            （2）用同一个对象写入流来写入对象
 55          * 对象写入注意：（1）当写入对象的时候，对象写入流会在开头和结尾添加AC/DC
 56          *                 （2）必须用同一个对象写入流写入，因为在对象写入流close的时候会添加DC
 57          *                 ，再次写入另外一些对象的时候DC也不会消失，所以当读取的时候就会出现错误！
 58          *                 （3）以上是我自己的见解，如果出错的话请留言各位！！
 59          */
 60         
 61         //创建一个集合对象
 62         ArrayList<Car> arr = new ArrayList<Car>();
 63         arr.add(new Car("兰博基尼", "刘能"));
 64         arr.add(new Car("劳斯莱斯", "赵四"));
 65         
 66         /**
 67          * 方式一：
 68          */
 69         /**
 70          * 写入集合对象
 71          */
 72         /*try {
 73             //创建一个写入通道
 74             FileOutputStream out = new FileOutputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
 75             try {
 76                 //创建一个对象写入通达！
 77                 ObjectOutputStream objOut = new ObjectOutputStream(out);
 78                 //开始写入集合对象
 79                 objOut.writeObject(arr);
 80                 //关闭写入资源
 81                 objOut.close();
 82             } catch (IOException e) {
 83                 // TODO Auto-generated catch block
 84                 e.printStackTrace();
 85             }
 86         } catch (FileNotFoundException e) {
 87             // TODO Auto-generated catch block
 88             e.printStackTrace();
 89         }*/
 90         /**
 91          * 读取集合对象
 92          */
 93         /*try {
 94             //创建一个写入通道
 95             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
 96             try {
 97                 //创建一个对象读取通达！
 98                 ObjectInputStream objIn = new ObjectInputStream(in);
 99                 try {
100                     //读取对象，返回的是一个Object类型的对象（需强转）
101                     ArrayList<Car> readArray = (ArrayList<Car>)objIn.readObject();
102                     //遍历读取到的readAraay集合！
103                     for(Car c:readArray){
104                         System.out.println(c.brand+c.owner);
105                     }
106                     //关闭读取资源
107                     objIn.close();
108                 } catch (ClassNotFoundException e) {
109                     // TODO Auto-generated catch block
110                     e.printStackTrace();
111                 }
112             } catch (IOException e) {
113                 // TODO Auto-generated catch block
114                 e.printStackTrace();
115             }
116             
117         } catch (FileNotFoundException e) {
118             // TODO Auto-generated catch block
119             e.printStackTrace();
120         }*/
121         
122         /**
123          * 方式二：
124          */
125         /**
126          * 写入集合对象
127          */
128         /*try {
129             //创建一个写入通道
130             FileOutputStream out = new FileOutputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
131             try {
132                 //创建一个对象写入通达！
133                 ObjectOutputStream objOut = new ObjectOutputStream(out);
134                 //利用for循环来写入Car对象！
135                 for(Car c:arr){
136                     objOut.writeObject(c);
137                 }
138                 //关闭写入资源！
139                 objOut.close();
140             } catch (IOException e) {
141                 // TODO Auto-generated catch block
142                 e.printStackTrace();
143             }
144         } catch (FileNotFoundException e) {
145             // TODO Auto-generated catch block
146             e.printStackTrace();
147         }*/
148         /**
149          * 读取集合对象
150          */
151         try {
152             //创建一个写入通道
153             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
154             try {
155                 //创建一个对象读取通达！
156                 ObjectInputStream objIn = new ObjectInputStream(in);
157                 try {
158                     try {
159                         //while循环读取对象并打印！
160                         while(true){
161                             Car c = (Car)objIn.readObject();
162                             System.out.println(c.brand+c.owner);
163                         }
164                     } catch (ClassNotFoundException e) {
165                         // TODO Auto-generated catch block
166                         e.printStackTrace();
167                     }
168                 } catch (EOFException e) {
169                     //当while循环完毕后会爆出---》 java.io.EOFException》代表打印完毕！
170                     System.out.println("打印完毕！！");
171                 }finally{
172                     //关闭读取资源
173                     objIn.close();
174                 }
175             } catch (IOException e) {
176                 // TODO Auto-generated catch block
177                 e.printStackTrace();
178             }
179             
180         } catch (FileNotFoundException e) {
181             // TODO Auto-generated catch block
182             e.printStackTrace();
183         }
184     }
185     
186     public static void readerOut(){
187         try {
188             //创建一个写出通道
189             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\List.txt");
190             try {
191                 //创建一个写出对象的通道!
192                 ObjectInputStream objIn = new ObjectInputStream(in);
193                 try {
194                     //读取对象，返回的是一个Object类型的对象（需强转）
195                     Car car = (Car)objIn.readObject();
196                     //打印一下，看是否是步骤一写入的对象！---->由于owner是被transient修饰的所以显示为null
197                     System.out.println(car.brand + car.owner);
198                 } catch (ClassNotFoundException e) {
199                     // TODO Auto-generated catch block
200                     e.printStackTrace();
201                 }
202             } catch (IOException e) {
203                 // TODO Auto-generated catch block
204                 e.printStackTrace();
205             }
206         } catch (FileNotFoundException e) {
207             // TODO Auto-generated catch block
208             e.printStackTrace();
209         }
210     }
211     
212     public static void writerIn(){
213                 try {
214                     //创建一个写入通道！
215                     FileOutputStream out = new FileOutputStream("C:\\Users\\wang\\Desktop\\List.txt");
216                     try {
217                         //创建一个写入对象的通道!
218                         ObjectOutputStream objOut = new ObjectOutputStream(out);
219                         //创建一个对象
220                         Car car = new Car("奔驰", "张三");
221                         //写入对象
222                         objOut.writeObject(car);
223                         //关闭写入资源
224                         objOut.close();
225                         /**
226                          * ********在此时写入完成！********
227                          */
228                     } catch (IOException e) {
229                         // TODO Auto-generated catch block
230                         e.printStackTrace();
231                     }
232                 } catch (FileNotFoundException e) {
233                     // TODO Auto-generated catch block
234                     e.printStackTrace();
235                 }
236     }
237 
238 }

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

  1 public static void writerInOrReaderOut(){
  2         
  3         ArrayList<Car> arr = new ArrayList<Car>();
  4         try {
  5             //创建读取的通道
  6             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
  7             try {
  8                 //创建对象读取通道！
  9                 ObjectInputStream objIn = new ObjectInputStream(in);
 10                 try {
 11                     try {
 12                         //开始读取 
 13                         while(true){    
 14                             try {
 15                                 Car c = (Car) objIn.readObject();
 16                                 //向集合中添加对象
 17                                 arr.add(c);
 18                             } catch (ClassNotFoundException e) {
 19                                 // TODO Auto-generated catch block
 20                                 e.printStackTrace();
 21                             }
 22                             
 23                         }
 24                     } catch (EOFException e) {
 25                         // TODO Auto-generated catch block
 26                         System.out.println("添加完了！");
 27                     }
 28                 }finally{
 29                     objIn.close();
 30                 }
 31                 
 32             } catch (IOException e) {
 33                 // TODO Auto-generated catch block
 34                 e.printStackTrace();
 35             }
 36         } catch (FileNotFoundException e) {
 37             // TODO Auto-generated catch block
 38             e.printStackTrace();
 39         }
 40         try {
 41             //创建输出通道！
 42             FileOutputStream out = new FileOutputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
 43             try {
 44                 //创建对象输出通道！
 45                 ObjectOutputStream objOut = new ObjectOutputStream(out);
 46                 //for循环遍历
 47                 for(Car c:arr){
 48                     objOut.writeObject(c);
 49                 }
 50                 //在这里添加某个对象
 51                 objOut.writeObject(new Car("兰博基尼", "纷纷"));
 52                 //关闭资源
 53                 objOut.close();
 54             } catch (IOException e) {
 55                 // TODO Auto-generated catch block
 56                 e.printStackTrace();
 57             }
 58         } catch (FileNotFoundException e) {
 59             // TODO Auto-generated catch block
 60             e.printStackTrace();
 61         }
 62         
 63         try {
 64             //创建读取的通道
 65             FileInputStream in = new FileInputStream("C:\\Users\\wang\\Desktop\\ArrayList.txt");
 66             try {
 67                 //创建对象读取通道！
 68                 ObjectInputStream objIn = new ObjectInputStream(in);
 69                 try {
 70                     try {
 71                         //开始读取 
 72                         while(true){    
 73                             try {
 74                                 //读取对象！
 75                                 Car c = (Car) objIn.readObject();
 76                                 //打印对象！
 77                                 System.out.println(c.brand+c.owner);
 78                             } catch (ClassNotFoundException e) {
 79                                 // TODO Auto-generated catch block
 80                                 e.printStackTrace();
 81                             }    
 82                         }
 83                     } catch (EOFException e) {
 84                         // TODO Auto-generated catch block
 85                         System.out.println("打印完了！");
 86                     }
 87                 }finally{
 88                     //关闭资源！
 89                     objIn.close();
 90                 }
 91                 
 92             } catch (IOException e) {
 93                 // TODO Auto-generated catch block
 94                 e.printStackTrace();
 95             }
 96         } catch (FileNotFoundException e) {
 97             // TODO Auto-generated catch block
 98             e.printStackTrace();
 99         }
100         
101         
102     }

 

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


联系
我们