IO流-数据流、对象流(序列化与反序列化)、打印流

数据流:DataOutputStream

1. public class TestDataStream 
2. { 
3.     public void writeData() 
4.     { 
5.         double[] arrays = new double[1000]; 
6.         Arrays.fill(arrays, Math.PI); 
7.          
8.         String fileName = "F:/java/test2.txt"; 
9.         FileOutputStream out; 
10.         DataOutputStream dos = null; 
11.         try 
12.         { 
13.             out = new FileOutputStream(fileName); 
14.             dos = new DataOutputStream(out); 
15.             for (int i = 0; i < arrays.length; i++) 
16.             { 
17.                 dos.writeDouble(arrays[i]); 
18.             } 
19. //            dos.write(123); 
20. //            dos.writeBoolean(true); 
21. //            dos.writeChar('Z'); 
22. //            dos.writeDouble(Math.PI); 
23.             dos.flush(); 
24.         } 
25.         catch (FileNotFoundException e) 
26.         { 
27.             e.printStackTrace(); 
28.         } 
29.         catch (IOException e) 
30.         { 
31.             e.printStackTrace(); 
32.         } 
33.         finally 
34.         { 
35.             if (dos != null) 
36.             { 
37.                 try 
38.                 { 
39.                     dos.close(); 
40.                 } 
41.                 catch (IOException e) 
42.                 { 
43.                     e.printStackTrace(); 
44.                 } 
45.             } 
46.         } 
47.     } 
48.      
49.     public static void main(String[] args) 
50.     { 
51.         TestDataStream tds = new TestDataStream(); 
52.         tds.writeData();      
53.     } 
54.      
55. } 

 

数据流:DataInputStream

1. public class TestDataInputStream 
2. { 
3.     public static void main(String[] args) 
4.     { 
5.         String fileName = "F:/java/test2.txt"; 
6.         FileInputStream in = null; 
7.         DataInputStream dis = null; 
8.         try 
9.         { 
10.             in = new FileInputStream(fileName); 
11.             dis = new DataInputStream(in); 
12.             for (int i = 0; i < 1000; i++) 
13.             { 
14.                 System.out.println(dis.readDouble() + "i: " + i); 
15.             } 
16. //            System.out.println(dis.read()); 
17. //            System.out.println(dis.readBoolean()); 
18. //            System.out.println(dis.readChar()); 
19. //            System.out.println(dis.readDouble()); 
20.         } 
21.         catch (FileNotFoundException e) 
22.         { 
23.             e.printStackTrace(); 
24.         } 
25.         catch (IOException e) 
26.         { 
27.             e.printStackTrace(); 
28.         } 
29.         finally 
30.         { 
31.             if (dis != null) 
32.             { 
33.                 try 
34.                 { 
35.                     dis.close(); 
36.                 } 
37.                 catch (IOException e) 
38.                 { 
39.                     e.printStackTrace(); 
40.                 } 
41.             } 
42.         } 
43.     } 
44. } 

 

对象流：ObjectOutputStream（unserializable）、ObjectInputStream（serializable）

1. public class TestSerializable 
2. { 
3.     public static void main(String[] args) 
4.     { 
5.         TestSerializable ts = new TestSerializable(); 
6.         ts.serializable(); 
7.         ts.unserializable(); 
8.     } 
9.     public void serializable()//序列化，写入 
10.     { 
11.         String filename = "F:/java/stu.txt"; 
12.         Student s1 = new Student("haoyouduo",1987); 
13.          
14.         FileOutputStream fis =null; 
15.         ObjectOutputStream ois = null; 
16.         try 
17.         { 
18.             fis = new FileOutputStream(filename); 
19.             ois = new ObjectOutputStream(fis); 
20.             ois.writeObject(s1); 
21.             ois.flush(); 
22.         } 
23.         catch (FileNotFoundException e) 
24.         { 
25.             e.printStackTrace(); 
26.         } 
27.         catch (IOException e) 
28.         { 
29.             e.printStackTrace(); 
30.         } 
31.         finally 
32.         { 
33.             if(null != ois) 
34.             { 
35.                 try 
36.                 { 
37.                     ois.close(); 
38.                 } 
39.                 catch (IOException e) 
40.                 { 
41.                     e.printStackTrace(); 
42.                 } 
43.             } 
44.         } 
45.          
46.     } 
47.     public void unserializable()//反序列化，读取 
48.     { 
49.         String filename = "F:/java/stu.txt"; 
50.         FileInputStream fis = null; 
51.         ObjectInputStream ois = null; 
52.         try 
53.         { 
54.             fis = new FileInputStream(filename); 
55.             ois = new ObjectInputStream(fis); 
56.             Student s = (Student)ois.readObject(); 
57.             System.out.println(s); 
58.              
59.         } 
60.         catch (FileNotFoundException e) 
61.         { 
62.             e.printStackTrace(); 
63.         } 
64.         catch (IOException e) 
65.         { 
66.             e.printStackTrace(); 
67.         } 
68.         catch (ClassNotFoundException e) 
69.         { 
70.             e.printStackTrace(); 
71.         } 
72.         finally 
73.         { 
74.             if(ois != null) 
75.             { 
76.                 try 
77.                 { 
78.                     ois.close(); 
79.                 } 
80.                 catch (IOException e) 
81.                 { 
82.                     e.printStackTrace(); 
83.                 } 
84.             } 
85.         } 
86.          
87.     } 
88. } 
89.  
90. class Student implements Serializable//对象类必须实现可序列化的 
91. { 
92.     String name; 
93.     int age; 
94.     public Student(String name,int age) 
95.     { 
96.         this.name = name; 
97.         this.age = age; 
98.     } 
99.     @Override 
100.     public String toString() 
101.     { 
102.         return "Student [name=" + name + ", age=" + age + "]"; 
103.     } 
104.  
105.      
106. } 

 

打印流:PrintStream

1. public class Test 
2. { 
3.     public static void main(String[] args) 
4.     { 
5.         boolean flag = 2 > 1; 
6.         if (flag) 
7.         { 
8.             System.out.println("sss"); 
9.         } 
10.         else 
11.         { 
12.             System.out.println("aaa"); 
13.         } 
14.          
15.         System.out.println("使用printStream之前"); 
16.  
17.         /** 
18.          * 上面部分的内容将打印在控制台里 
19.          * 下面部分的内容不会打印在控制台里，而是文件里 
20.          */ 
21.          
22.         String filename = "f:/java/log.txt"; 
23.         FileOutputStream fos; 
24.         PrintStream ps = null; 
25.         try 
26.         { 
27.             fos = new FileOutputStream(filename); 
28.             ps = new PrintStream(fos); 
29.             System.setOut(ps); 
30.             System.out.println("这将打印在文件里"); 
31.             System.out.println("使用printStream之后"); 
32.         } 
33.         catch (FileNotFoundException e) 
34.         { 
35.             e.printStackTrace(); 
36.         } 
37.         finally 
38.         { 
39.             if (ps != null) 
40.             { 
41.                 ps.close(); 
42.             } 
43.         } 
44.     } 
45. } 

 

本文转自 glblong 51CTO博客，原文链接：http://blog.51cto.com/glblong/1191874，如需转载请自行联系原作者