java中IO

亦凉 2022-09-29 10:58 232阅读 0赞

[http://blog.csdn.net/zhangerqing/article/details/8466532][http_blog.csdn.net_zhangerqing_article_details_8466532]

**一、简介**

IO操作面临很多问题，信息量的巨大，网络的环境等等，因为IO不仅仅是对本地文件、目录的操作，有时对二进制流、还有一部分是网络方面的资源，所以多种原因直接造成IO操作无疑是耗时且复杂多变的。Java对IO的支持是个不断的演变过程，经过了很多的优化，直到JDK1.4以后，才趋于稳定，在JDK1.4中，加入了nio类，解决了很多性能问题，虽然我们有足够的理由不去了解关于Java IO以前的情况，但是为了学好现在的类，我们还是打算去研究下，通过掌握类的优化情况来彻底理解IO的机制！Java IO主要主要在java.io包下，分为四大块近80个类：

1、基于字节操作的I/O接口：InputStream和OutputStream

2、基于字符操作的I/O接口：Writer和Reader

3、基于磁盘操作的I/O接口：File

4、基于网络操作的I/O接口：Socket（不在java.io包下）

影响IO性能的无非就是两大因素：数据的格式及存储的方式，前两类主要是数据格式方面的，后两个类是存储方式方面的：本地和网络。所以策划好这两个方面的活动，有助于我们合理使用IO。

**二、基于字节的I/O操作(InputStream和OutputStream)**

我们先来看看类图：

![1357309985_3442.png][]

图1

![1357310062_5816.png][]

图2

二者类似，我只详细讲解InputStream类，OutputStream留给大家自己去学习。InputStream类是个抽象类，里面核心的方法就是read()、read(byte b\[\])、read(byte b\[\], int off, int len)，这三个方法是用于读取数据的底层的方法，他们可以用来读取一下这些类型的数据：

A. 字节数组

B. String对象

C. 文件

D. 管道，从一端进入，从另一端输出

E. 流

F. internet资源

每一种数据源都有相应的InputStream子类，因为InputStream是个处于顶层的类，用来处理各种数据源的类都继承了InputStream类，我们来看看这些类：

ByteArrayInputStream：处理字节数组的类，允许将内存的缓冲区当做InputStream使用。

StringBufferInputStream：将String转换成InputStream，内部实现用的是StringBuffer。

FileInputStream：从文件中读取数据。

PipedInputStream：用于从管道中读取数据。

SequenceInputStream：将多个流对象转化成一个InputStream。

FilterInputStream：装饰器类，为其它InputStream类提供功能。

做过关于IO操作的读者知道，我们很少单独使用哪个类来实现IO操作，平时都是几个类合起来使用，这其实体现了一种装饰器模式（详见：http://blog.csdn.net/zhangerqing）的思想，在后面的分析中我们会详细的分析。从上面的图1中我们可以看出，FilterInputStream虽说是Inputstream的子类，但它依然是BufferedInputStream、DataInputStream、LineNumberInputStream、PushbackInputStream类的父类，这四个类分别提供了最贴近我们程序员使用的方法，如：readInt() 、readInt()、readInt()等等。对于IO操作，不管是磁盘还是网络，最终都是对字节的操作，而我们平时写的程序都是字符形式的，所以在传输的过程中需要进行转换。在字符到字节的转换过程中，我们需要用到一个类：InputStreamReader。

**三、基于字符的I/O操作(Writer和Reader)**

![1357310154_6858.png][]

图3

![1357310183_6062.png][]

图4

Writer和Reader操作的目的就是操作字符和不是字节，和InputStream和OutputStream配合增加IO效果。通过InputStreamReader和OutputStreamReader可以进行字节和字符的转换，设计Writer和Reader的目的是国际化，使IO操作支持16位的Unicode。我把它们单独的画出来，因为要是全画的话，太大了放不下，有兴趣的TX可以在rational rose中导入其带的JDK类图看看，很过瘾的！

**四、基于磁盘的I/O操作(File)**

**五、基于网络的I/O操作(Socket)**

**六、NIO**

四-六部分由于时间关系，还没有整理完，后续会补出来！

**七、经典IO操作**

1、缓冲输入文件。

**\[java\]** [view plain][] [copy][view plain]

1.  **import** java.io.BufferedReader; 
2.  **import** java.io.FileReader; 
3.  
4.  **public****class** InputStreamTest \{ 
5.  
6.  **public****static** String read(String filename) **throws** Exception \{ 
7.   BufferedReader br = **new** BufferedReader(**new** FileReader(filename)); 
8.   String s; 
9.   StringBuffer sb = **new** StringBuffer(); 
10. **while** ((s = br.readLine()) != **null**) \{ 
11.  sb.append(s + "\\n"); 
12.  \} 
13.  br.close(); 
14. **return** sb.toString(); 
15.  \} 
16. 
17. **public****static****void** main(String\[\] args) **throws** Exception \{ 
18.  System.out.println(read("src/InputStreamTest.java")); 
19.  \} 
20. 　\}

这段代码是从磁盘读入InputStreamTest.java文件，然后转换成字符串。输出就是将源文件原样输出。

2、从内存中读取。

**\[java\]** [view plain][] [copy][view plain]

1.  **import** java.io.StringReader; 
2.  
3.  **public****class** MemoryInput \{ 
4.  
5.  **public****static****void** main(String\[\] args) **throws** Exception \{ 
6.   StringReader in = **new** StringReader( 
7.   InputStreamTest.read("src/MemoryInput.java")); 
8.  **int** c; 
9.  **while** ((c = in.read()) != -1) 
10.  System.out.println((**char**) c); 
11.  \} 
12. 
13. \}

read返回的是int类型的数据，所以在输出语句中用char做了强类型转换。该程序将一个一个的输出字符。

3、基本的文件输出。

**\[java\]** [view plain][] [copy][view plain]

1.  **import** java.io.BufferedReader; 
2.  **import** java.io.BufferedWriter; 
3.  **import** java.io.FileWriter; 
4.  **import** java.io.PrintWriter; 
5.  **import** java.io.StringReader; 
6.  
7.  **public****class** BasicFileOutput \{ 
8.  
9.  **static** String file = "basie.out"; 
10. 
11. **public****static****void** main(String\[\] args) **throws** Exception \{ 
12.  BufferedReader in = **new** BufferedReader(**new** StringReader( 
13.  InputStreamTest.read("src/BasicFileOutput.java"))); 
14.  PrintWriter out = **new** PrintWriter(**new** BufferedWriter(**new** FileWriter( 
15.  file))); 
16. **int** lineCount = 1; 
17.  String s; 
18. **while** ((s = in.readLine()) != **null**) \{ 
19.  out.println(lineCount++ + ": " \+ s); 
20.  \} 
21.  out.close(); 
22.  System.out.println(InputStreamTest.read(file)); 
23.  \} 
24. \}

输出：

1: import java.io.BufferedReader;

2: import java.io.BufferedWriter;

3: import java.io.FileWriter;

…

4、RandomAccessFile

RandomAccessFile被我们称为”自我独立的类”，因为它独立于我们前面说的IO类，与InputStream和OutputStream没什么关系，除了实现了DataOutput, DataInput两个接口外。所有方法都是重新编写，而且很多都是native方法，我们来看个例子，了解下这个类：

5、管道流

**八、标准I/O**

就是我们最原始的使用的从控制台输入或者输出的那些类和方法，如System.in、System.out等。

**\[java\]** [view plain][] [copy][view plain]

1.  **public****class** StandardIO \{ 
2.  
3.  **public****static****void** main(String\[\] args) **throws** IOException \{ 
4.   BufferedReader in = **new** BufferedReader(**new** InputStreamReader(System.in)); 
5.   String s; 
6.  **while** ((s = in.readLine()) != **null** && s.length() != 0) 
7.   System.out.println(s); 
8.   \} 
9.  \}

System.in返回的是未经包装的InputStream对象，所以需要进行装饰，经InputStreamReader转换为Reader对象，放入BufferedReader的构造方法中。除此之外，System.out和System.err都是直接的PriintStream对象，可直接使用。我们也可以使用java.util包下的Scanner类来代替上述程序：

**\[java\]** [view plain][] [copy][view plain]

1.  **public****class** StandardIO \{ 
2.  
3.  **public****static****void** main(String\[\] args) **throws** IOException \{ 
4.   Scanner in = **new** Scanner(System.in); 
5.   String s; 
6.  **while**((s = in.next()) != **null** && s.length() != 0)\{ 
7.   System.out.println(s); 
8.   \} 
9.   \} 
10. \}

**九、性能分析及总结**

1、一个文件读写工具类。

**\[java\]** [view plain][] [copy][view plain]

1.  **import** java.io.BufferedReader; 
2.  **import** java.io.File; 
3.  **import** java.io.FileReader; 
4.  **import** java.io.IOException; 
5.  **import** java.io.PrintWriter; 
6.  **import** java.util.ArrayList; 
7.  **import** java.util.Arrays; 
8.  
9.  /\*\*
10.  \* 一个非常实用的文件操作类 . 2012-12-19
11.  \* 
12.  \* @author Bruce Eckel , edited by erqing
13.  \* 
14.  \*/
15. **public****class** TextFile **extends** ArrayList<String> \{ 
16. 
17. **private****static****final****long** serialVersionUID = -1942855619975438512L; 
18. 
19. // Read a file as a String
20. **public****static** String read(String filename) \{ 
21.  StringBuilder sb = **new** StringBuilder(); 
22. **try** \{ 
23.  BufferedReader in = **new** BufferedReader(**new** FileReader(**new** File( 
24.  filename).getAbsoluteFile())); 
25.  String s; 
26. **try** \{ 
27. **while** ((s = in.readLine()) != **null**) \{ 
28.  sb.append(s); 
29.  sb.append("\\n"); 
30.  \} 
31.  \} **finally** \{ 
32.  in.close(); 
33.  \} 
34. 
35.  \} **catch** (IOException e) \{ 
36. **throw****new** RuntimeException(e); 
37.  \} 
38. **return** sb.toString(); 
39.  \} 
40. 
41. // Write a single file in one method call
42. **public****static****void** write(String fileName, String text) \{ 
43. **try** \{ 
44.  PrintWriter out = **new** PrintWriter( 
45. **new** File(fileName).getAbsoluteFile()); 
46. **try** \{ 
47.  out.print(text); 
48.  \} **finally** \{ 
49.  out.close(); 
50.  \} 
51.  \} **catch** (IOException e) \{ 
52. **throw****new** RuntimeException(e); 
53.  \} 
54.  \} 
55. 
56. // Read a file,spilt by any regular expression
57. **public** TextFile(String fileName, String splitter) \{ 
58. **super**(Arrays.asList(read(fileName).split(splitter))); 
59. **if** (get(0).equals("")) 
60.  remove(0); 
61.  \} 
62. 
63. // Normally read by lines
64. **public** TextFile(String fileName) \{ 
65. **this**(fileName, "\\n"); 
66.  \} 
67. 
68. **public****void** write(String fileName) \{ 
69. **try** \{ 
70.  PrintWriter out = **new** PrintWriter( 
71. **new** File(fileName).getAbsoluteFile()); 
72. **try** \{ 
73. **for** (String item : **this**) 
74.  out.println(item); 
75.  \} **finally** \{ 
76.  out.close(); 
77.  \} 
78. 
79.  \} **catch** (IOException e) \{ 
80. **throw****new** RuntimeException(e); 
81.  \} 
82. 
83.  \} 
84. 
85. // test,I have generated a file named data.d at the root
86. **public****static****void** main(String\[\] args) \{ 
87. 
88. /\* read() test \*/
89.  System.out.println(read("data.d")); // testing is OK!
90. 
91. /\* write() test \*/
92.  write("out.d", "helloworld\\negg"); // testing is OK!
93. 
94. /\* constractor test \*/
95.  TextFile tf = **new** TextFile("data.d"); // testing is OK!
96. 
97.  \} 
98. 
99. \}

2、读取二进制文件。

**\[java\]** [view plain][] [copy][view plain]

1.  **import** java.io.BufferedInputStream; 
2.  **import** java.io.File; 
3.  **import** java.io.FileInputStream; 
4.  **import** java.io.IOException; 
5.  
6.  /\*\*
7.   \* to read the binary file
8.   \* 
9.   \* @author erqing
10.  \* 
11.  \*/
12. **public****class** BinaryFile \{ 
13. 
14. /\* the parametre is a file \*/
15. **public****static****byte**\[\] read(File file) **throws** IOException \{ 
16.  BufferedInputStream bf = **new** BufferedInputStream(**new** FileInputStream( 
17.  file)); 
18. **try** \{ 
19. **byte**\[\] data = **new****byte**\[bf.available()\]; 
20.  bf.read(data); 
21. **return** data; 
22.  \} **finally** \{ 
23.  bf.close(); 
24.  \} 
25.  \} 
26. 
27. /\* the param is the path of a file \*/
28. **public****static****byte**\[\] read(String file) **throws** IOException \{ 
29. **return** read(**new** File(file).getAbsoluteFile()); 
30.  \} 
31. \}

[http_blog.csdn.net_zhangerqing_article_details_8466532]: http://blog.csdn.net/zhangerqing/article/details/8466532
[1357309985_3442.png]: https://img-my.csdn.net/uploads/201301/04/1357309985_3442.png
[1357310062_5816.png]: https://img-my.csdn.net/uploads/201301/04/1357310062_5816.png
[1357310154_6858.png]: https://img-my.csdn.net/uploads/201301/04/1357310154_6858.png
[1357310183_6062.png]: https://img-my.csdn.net/uploads/201301/04/1357310183_6062.png
[view plain]: http://blog.csdn.net/zhangerqing/article/details/8466532#