IO流之对象流ObjectOutputStream和ObjectInputStream

我们可以使用java的IO流中的对象流ObjectOutputStream和ObjectInputStream来实现序列化和反序列化的操作。

     java对象序列化就是将对象转换为字节流，然后可以通过这些值再生成相同状态的对象。对象序列化是对象持久化的一种实现方法,它是将一个对象的属性和方法转化为一种序列化的格式以用于存储和传输,反序列化就是根据这些保存的信息重建对象的过程。

       序列化的实现：将需要被序列化的类实现Serializable接口，然后使用一个输出(如:FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。所以使用ObjectOutputStream类实现序列化，ObjectInputStream类实现反序列化。

 

首先定义一个Person类，并实现Serializable接口：

 

Java代码  

1. public class Person implements Serializable {  
2.   
3.     public String name;  
4.       
5.     public int age;  
6.       
7.     public Person(String name,int age){  
8.         this.name=name;  
9.         this.age=age;  
10.     }  
11.   
12.     @Override  
13.     public String toString() {  
14.         return "person [name=" + name + ", age=" + age + "]";  
15.     }  
16.       
17. }  

 

 

  上面代码来看我们没有实现任何Serializable接口的方法，其实Serializable接口是一个标记接口，用于启动其序列化功能，此接口没有定义任何方法，只是作为一个标记。如图

   

1.ObjectOutputStream实现序列化

 

示例代码

 

Java代码  

1. public static void main(String[] args) {  
2.        
3.     try {  
4.         //序列化文件輸出流  
5.         OutputStream outputStream=new FileOutputStream("L:\\myfile.tmp");  
6.         //构建缓冲流  
7.         BufferedOutputStream buf=new BufferedOutputStream(outputStream);  
8.         //构建字符输出的对象流  
9.         ObjectOutputStream obj=new ObjectOutputStream(buf);  
10.         //序列化数据写入  
11.                        obj.writeUTF("好好学习,天天向上");//字符串        
12.         obj.writeInt(18);//int类型  
13.           
14.             obj.writeObject(new Person("小明", 21));//Person对象  
15.         //关闭流  
16.         obj.close();  
17.         buf.close();  
18.         outputStream.close();  
19.           
20.     } catch (FileNotFoundException e) {  
21.         e.printStackTrace();  
22.     } catch (IOException e) {  
23.         e.printStackTrace();  
24.     }  
25.    }    

 运行结果：

 

 

       数据已经被序列化，无法正常显示出来。这个tmp的文件格式在我们很多应用程序中都可以看到。比如qq等,那怎么知道我们有没有序列化成功呢，我们来反序列化看看。

 

2.ObjectInputStream实现反序列化

 

示例代码：

 

Java代码  

1. public static void main(String[] args) {  
2.             
3.             try {  
4.                   
5.                 InputStream inputStream=new FileInputStream("L:\\myfile.tmp");  
6.                 //构建缓冲流  
7.                 BufferedInputStream buf=new BufferedInputStream(inputStream);  
8.                 //构建字符输入的对象流  
9.                 ObjectInputStream obj=new ObjectInputStream(buf);  
10.                 //数据读取--只能按存入的顺序读取    
11.                 String info=obj.readUTF();  
12.                   
13.                 int ok=obj.readInt();  
14.                   
15.                 Person tempPerson=(Person)obj.readObject();  
16.                   
17.                 System.out.println("str: "+info+"\n"+"整数为："+ok+"\n"+"Person对象为："+tempPerson);  
18.                   
19.                   
20.                 //关闭流  
21.                 obj.close();  
22.                 buf.close();  
23.                 inputStream.close();  
24.                   
25.             } catch (FileNotFoundException e) {  
26.                 e.printStackTrace();  
27.             } catch (IOException e) {  
28.                 e.printStackTrace();  
29.             } catch (ClassNotFoundException e) {  
30.                 e.printStackTrace();  
31.             }  
32.         }    

 

 

运行结果：

 

切记：读取的顺序要和写入的顺序一样，不然会读取出错，如把String info=obj.readUTF();和int ok=obj.readInt();换个位置就会出错

 

3.序列化一组对象

     上面的读取只能按照顺序读取，如果我们不知道有多少和对象需要读取，那么将无法读取出来，为了解决这问题，可以使用序列化一组对象，然后在反序列这一组对象出来。反序列也必须按顺序来读取

 

如：序列化一组对象

 

Java代码  

1. public static void main(String[] args) {  
2.             
3.         try {  
4.             //序列化文件輸出流  
5.             OutputStream outputStream=new FileOutputStream("L:\\myfile.tmp");  
6.             //构建缓冲流  
7.             BufferedOutputStream buf=new BufferedOutputStream(outputStream);  
8.             //构建字符输出的对象流  
9.             ObjectOutputStream obj=new ObjectOutputStream(buf);  
10.             //序列化数据写入     
11.               
12.             obj.writeInt(18);//int类型  
13.               
14.             Person []persons={new Person("小明", 21),new Person("小黑", 20),  
15.                        new Person("小红", 22),new Person("小白", 18)};  
16.             obj.writeObject(persons);//一组Person对象  
17.             //关闭流  
18.             obj.close();  
19.             buf.close();  
20.             outputStream.close();  
21.               
22.         } catch (FileNotFoundException e) {  
23.             e.printStackTrace();  
24.         } catch (IOException e) {  
25.             e.printStackTrace();  
26.         }  
27.     }    

 
 读取一组序列化，也要按顺序读取，要先读取int

 

 

Java代码  

1. public static void main(String[] args) {  
2.   
3.         try {  
4.   
5.             InputStream inputStream = new FileInputStream("L:\\myfile.tmp");  
6.             // 构建缓冲流  
7.             BufferedInputStream buf = new BufferedInputStream(inputStream);  
8.             // 构建字符输入的对象流  
9.             ObjectInputStream obj = new ObjectInputStream(buf);  
10.             // 数据读取--只能按存入的顺序读取  
11.             int ok = obj.readInt();  
12.   
13.             Person []tempPerson = (Person[]) obj.readObject();  
14.   
15.             System.out.println("整数为：" + ok );  
16.               
17.             for(int i=0;i<tempPerson.length;i++)  
18.                 System.out.println(tempPerson[i]);  
19.   
20.             // 关闭流  
21.             obj.close();  
22.             buf.close();  
23.             inputStream.close();  
24.   
25.         } catch (FileNotFoundException e) {  
26.             e.printStackTrace();  
27.         } catch (IOException e) {  
28.             e.printStackTrace();  
29.         } catch (ClassNotFoundException e) {  
30.             e.printStackTrace();  
31.         }  
32.     }  

 

 

运行结果：

 

4.关键字：transient

      如果把Person的age属性前面加上关键字transient，则Person的age属性将不会被序列化。即如果用transient声明一个变量，当对象存储时，它的值不需要维持。

    代码还是使用序列化和反序列化一组对象的代码，只是在Person类的age属性前加上关键字transient

 

 

运行结果：