JAVA基础知识之IO——Java IO体系及常用类

Java IO体系

个人觉得可以用“字节流操作类和字符流操作类组成了Java IO体系”来高度概括Java IO体系。借用几张网络图片来说明(图片来自 http://blog.csdn.net/zhangerqing/article/details/8466532 ) 基于字节的IO操作
 基于字符的IO操作
  从上图可以看到，整个Java IO体系都是基于字符流(InputStream/OutputStream) 和 字节流(Reader/Writer)作为基类，根据不同的数据载体或功能派生出来的。

IO常用类

文件流：FileInputStream/FileOutputStream， FileReader/FileWriter
这四个类是专门操作文件流的，用法高度相似，区别在于前面两个是操作字节流，后面两个是操作字符流。它们都会直接操作文件流，直接与OS底层交互。因此他们也被称为节点流。注意使用这几个流的对象之后，需要关闭流对象，因为java垃圾回收器不会主动回收。不过在Java7之后，可以在 try() 括号中打开流，最后程序会自动关闭流对象，不再需要显示地close。下面演示这四个流对象的基本用法，按 Ctrl+C 复制代码按 Ctrl+C 复制代码 包装流：PrintStream/PrintWriter/Scanner
PrintStream可以封装（包装）直接与文件交互的节点流对象OutputStream, 使得编程人员可以忽略设备底层的差异，进行一致的IO操作。因此这种流也称为处理流或者包装流。PrintWriter除了可以包装字节流OutputStream之外，还能包装字符流WriterScanner可以包装键盘输入，方便地将键盘输入的内容转换成我们想要的数据类型。字符串流：StringReader/StringWriter
这两个操作的是专门操作String字符串的流，其中StringReader能从String中方便地读取数据并保存到char数组，而StringWriter则将字符串类型的数据写入到StringBuffer中（因为String不可写）。转换流：InputStreamReader/OutputStreamReader
这两个类可以将字节流转换成字符流，被称为字节流与字符流之间的桥梁。我们经常在读取键盘输入(System.in)或网络通信的时候，需要使用这两个类缓冲流：BufferedReader/BufferedWriter ， BufferedInputStream/BufferedOutputStream
Oracle官方的描述：Most of the examples we've seen so far use unbuffered I/O. This means each read or write request is handled directly by the underlying OS. This can make a program much less efficient.Buffered input streams read data from a memory area known as a buffer; the native input API is called only when the buffer is empty. Similarly, buffered output streams write data to a buffer, and the native output API is called only when the buffer is full.即，没有经过Buffered处理的IO， 意味着每一次读和写的请求都会由OS底层直接处理，这会导致非常低效的问题。经过Buffered处理过的输入流将会从一个buffer内存区域读取数据，本地API只会在buffer空了之后才会被调用（可能一次调用会填充很多数据进buffer）。经过Buffered处理过的输出流将会把数据写入到buffer中，本地API只会在buffer满了之后才会被调用。 BufferedReader/BufferedWriter可以将字符流(Reader)包装成缓冲流，这是最常见用的做法。另外，BufferedReader提供一个readLine()可以方便地读取一行，而FileInputStream和FileReader只能读取一个字节或者一个字符，因此BufferedReader也被称为行读取器 下面演示上面提到的常见类，

1 package io;
2
3 import java.io.BufferedReader;
4 import java.io.FileInputStream;
5 import java.io.FileNotFoundException;
6 import java.io.FileOutputStream;
7 import java.io.FileReader;
8 import java.io.IOException;
9 import java.io.InputStreamReader;
10 import java.io.PrintStream;
11 import java.io.PushbackReader;
12 import java.io.StringReader;
13 import java.io.StringWriter;
14
15 public class TestIO {
16     public static void printStream() throws FileNotFoundException, IOException {
17         try (
18                 FileOutputStream fos = new FileOutputStream("tmp.txt");
19                 PrintStream ps = new PrintStream(fos)) {
20             ps.println("普通字符串\n");
21             //输出对象
22             ps.println(new TestIO());
23         } catch (IOException e) {
24             e.printStackTrace();
25         }
26         System.out.println("输出完成");
27
28     }
29     public static void stringNode() throws IOException {
30         String str = "天王盖地虎\n"
31                 + "宝塔镇河妖\n";
32         char[] buf = new char[32];
33         int hasRead = 0;
34         //StringReader将以String字符串为节点读取数据
35         try (StringReader sr = new StringReader(str)) {
36             while ((hasRead = sr.read(buf)) > 0) {
37                 System.out.print(new String(buf, 0, hasRead));
38             }
39         } catch (IOException e) {
40             e.printStackTrace();
41         }
42
43         //由于String是一个不可变类，因此创建StringWriter时，实际上是以一个StringBuffer作为输出节点
44         try (StringWriter sw = new StringWriter()) {
45             sw.write("黑夜给了我黑色的眼睛\n");
46             sw.write("我却用它寻找光明\n");
47             //toString()返回sw节点内的数据
48             System.out.println(sw.toString());
49         } catch (IOException e) {
50             e.printStackTrace();
51         }
52     }
53
54     public static void keyIn() throws IOException {
55         try (
56                 //InputStreamReader是从byte转成char的桥梁
57                 InputStreamReader reader = new InputStreamReader(System.in);
58                 //BufferedReader(Reader in)是char类型输入的包装类
59                 BufferedReader br = new BufferedReader(reader);
60                 ) {
61             String line = null;
62             while ((line = br.readLine()) != null) {
63                 if (line.equals("exit")) {
64                     //System.exit(1);
65                     break;
66                 }
67                 System.out.println(line);
68             }
69         } catch (IOException e) {
70             e.printStackTrace();
71         }
72     }
73
74     public static void pushback() throws FileNotFoundException, IOException {
75         try (PushbackReader pr = new PushbackReader(new FileReader("C:/PROJECT/JavaBasic/PROJECT_JavaBasic/src/io/TestIO.java"),64)) {
76             char[] buf = new char[32];
77             String lastContent = "";
78             int hasRead = 0;
79             while ((hasRead = pr.read(buf)) > 0) {
80                 String content = new String(buf, 0, hasRead);
81                 int targetIndex = 0;
82                 if ((targetIndex = (lastContent + content).indexOf("targetIndex = (lastContent + content)")) > 0) {
83                     pr.unread((lastContent + content).toCharArray());
84                     if (targetIndex > 32) {
85                         buf = new char[targetIndex];
86                     }
87                     pr.read(buf , 0 , targetIndex);
88                     System.out.println(new String(buf, 0 , targetIndex));
89                     System.exit(0);
90                 } else {
91                     System.out.println(lastContent);
92                     lastContent = content;
93                 }
94             }
95         } catch (IOException e) {
96             e.printStackTrace();
97         }
98     }
99
100     public static void main(String[] args) throws IOException {
101         printStream();
102         //stringNode();
103         //keyIn();
104         //pushback();
105     }
106 }

  总结上面几种流的应用场景：FileInputStream/FileOutputStream  需要逐个字节处理原始二进制流的时候使用，效率低下
FileReader/FileWriter 需要组个字符处理的时候使用
StringReader/StringWriter 需要处理字符串的时候，可以将字符串保存为字符数组
PrintStream/PrintWriter 用来包装FileOutputStream 对象，方便直接将String字符串写入文件 
Scanner　用来包装System.in流，很方便地将输入的String字符串转换成需要的数据类型
InputStreamReader/OutputStreamReader ,  字节和字符的转换桥梁，在网络通信或者处理键盘输入的时候用
BufferedReader/BufferedWriter ， BufferedInputStream/BufferedOutputStream ， 缓冲流用来包装字节流后者字符流，提升IO性能，BufferedReader还可以方便地读取一行，简化编程。