1 /*
 2  * 需求：将一个对象序列化，并从硬盘中读取序列化的对象
 3  * 
 4  */
 5 import java.io.*;
 6 //创建Person类，实现Seriallizable接口
 7 class Person implements Serializable{
 8 //    定义一个serializable的版本号
 9     public final static long serialVersionUID=32l;
10     
11     private String name;
12     private int age;
13     transient String id;//表示不能被序列化，不能改变
14     static String country="Cn";//也是不能被改变
15     
16     Person(String name,int age,String id,String country){
17         this.name=name;
18         this.age=age;
19         this.id=id;
20         this.country=country;
21     }
22     public String toString(){
23         return name+":"+age+":"+id+":"+country;
24     }
25 }
26 
27 //序列化
28 public class ObjDemo {
29     public static void main(String[] args)throws Exception{
30         File file=new File("obj.txt");
31         Person p=new Person("zs",56,"shenm","US");
32 //        序列化人对象并写入file
33         writerObj(p,file);
34 //        读取序列
35         readObj(file);
36     }
37 //读取
38     private static void readObj(File file)throws Exception {
39         ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));
40         
41         Person p=(Person)ois.readObject();
42         
43         System.out.println(p);
44         
45         ois.close();
46         
47     }
48 
49     private static void writerObj(Person p, File file)throws Exception {
50 //        船舰序列流写入file
51         ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file));
52         oos.writeObject(p);
53         oos.close();
54         
55     }
56 }

 1 import java.io.*;
 2 //读取线程
 3 class Read implements Runnable{
 4     private PipedInputStream in;
 5     Read(PipedInputStream in){
 6         this.in=in;
 7     }
 8 //    覆盖run
 9     public void run(){
10         byte[] buf=new byte[1024];
11         System.out.println("读取前++没有数据阻塞");
12         int len;
13         try {
14             len = in.read(buf);
15             String s=new String(buf,0,len);
16             System.out.println(s);
17             
18         } catch (IOException e) {
19             // TODO Auto-generated catch block
20             e.printStackTrace();
21         }finally{
22             try {
23                 if(in!=null)
24                 in.close();    
25             } catch (Exception e2) {
26                 throw new RuntimeException();
27             }
28         }        
29     }
30     
31 }
32 //写入数据
33 class Write implements Runnable{
34     private PipedOutputStream out=null;
35     Write(PipedOutputStream out){
36         this.out=out;
37     }
38     
39     public void run() {
40         try {
41             System.out.println("开始希尔数据--");
42             Thread.sleep(30);
43             
44             out.write("PP是什么".getBytes());
45         } catch (Exception e) {
46             // TODO: handle exception
47         }finally{
48             try {
49                 if(out!=null)
50                     out.close();
51             } catch (Exception e2) {
52                 throw new RuntimeException("失败管理");
53             }
54         }
55         
56     }
57     
58 }
59 
60 public class PPStreamDemo {
61     public static void main(String [] args){
62         
63             
64         try {
65             PipedInputStream in=new PipedInputStream();
66             PipedOutputStream out=new PipedOutputStream();
67             in.connect(out);
68             
69             new Thread(new Read(in)).start();
70             new Thread(new Write(out)).start();
71         } catch (IOException e) {
72             throw new RuntimeException("关流失败");
73         }
74         
75     }
76 }