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

各位好!!我又来了!!今天遇见了一个小问题!!IO流里的对象读取总是出错!各种报错!!神烦啊!!百思不得其解啊!然后就上网百度!找了好久终于让我找到了!下面就让我来说一说!当你用IO流里的对象流写

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

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 }

只听到从山间传来架构君的声音:
当日袜尘何处去,溪楼。有谁来对上联或下联?

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

此代码由Java架构师必看网-架构君整理
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架构师必看的立场,转载请标明来源出处:https://javajgs.com/archives/42483
0

发表评论