jdk 源码分析（18）java io包分析

java.io包里定义输入与输出的关系， 输入和输出两种方式，这里只分析输入就可以，输出与输入相似。

1）第一个抽象类：InputStream

可以说IO里面一半与这个类直接或者间接相关，其余类要么是实现，要么是封装。

2）第一个封装接口：DataInput ，用来直接从输入流中读取数据。

DataInput 主要是将InputStream封装， 比如  DataInputStream， readInt，需要读4个字节，应为inputStream只能读1个字节。所以读四次就行。但是 InputStream的实现类不同， DataInput的不同实现类也是有差别的。

1. public final int readInt() throws IOException {
2. int ch1 = in.read();
3. int ch2 = in.read();
4. int ch3 = in.read();
5. int ch4 = in.read();
6.     //确保每次都能读到数据
7. if ((ch1 | ch2 | ch3 | ch4) < 0)
8. throw new EOFException();
9.         //合成为int
10. return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
11. }

3）Reader：用于将字节流转换成字符流。所以中间需要一个转码器。

主要实现InputStreamReader,以及FileReader

public int read() throws IOException {
    return sd.read();
}

buffer读因为是对字符层面的读写，所有可以获取到line的标志了。而且通过不同解码可以读取到中文和英文。

1. String readLine(boolean ignoreLF) throws IOException {
2. StringBuffer s = null;
3. int startChar;
5. synchronized (lock) {
6. ensureOpen();
7. boolean omitLF = ignoreLF || skipLF;
9. bufferLoop:
10. for (;;) {
12. if (nextChar >= nChars)
13. fill();
14. if (nextChar >= nChars) { /* EOF */
15. if (s != null && s.length() > 0)
16. return s.toString();
17. else
18. return null;
19. }
20. boolean eol = false;
21. char c = 0;
22. int i;
24.         //标准为行结束
25. /* Skip a leftover '\n', if necessary */
26. if (omitLF && (cb[nextChar] == '\n'))
27. nextChar++;
28. skipLF = false;
29. omitLF = false;
31. charLoop:
32. for (i = nextChar; i < nChars; i++) {
33. c = cb[i];
34. if ((c == '\n') || (c == '\r')) {
35. eol = true;
36. break charLoop;
37. }
38. }
40. startChar = nextChar;
41. nextChar = i;
43. if (eol) {
44. String str;
45. if (s == null) {
46. str = new String(cb, startChar, i - startChar);
47. } else {
48. s.append(cb, startChar, i - startChar);
49. str = s.toString();
50. }
51. nextChar++;
52. if (c == '\r') {
53. skipLF = true;
54. }
55. return str;
56. }
58. if (s == null)
59. s = new StringBuffer(defaultExpectedLineLength);
60. s.append(cb, startChar, i - startChar);
61. }
62. }
63. }

4）ObjectInput 这个是继承了DataInput，主要进一步将读的数据合并成对象。

主要实现ObjectInputStream。里面涉及到序列化，反序类化。

5)缓存读BufferedInputStream和 BufferedReader

这个主要是可以通过用户自定长度来读。可以设置一个buffer byte 来存储数据，从inputStream读到这个buffer里。 相应的BufferedReader 是对其他字符流的一种限制。比如readLine

正式因为有了上面不同的包装才有了不同的文件读写。

1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容

4、随机读取文件内容 

1. public static void main(String[] args) throws IOException {
2. File file = new File("c:");
3. FileReader reader = new FileReader(file);
4. BufferedReader bufferedReader = new BufferedReader(reader);
5. String line = bufferedReader.readLine();
9. FileInputStream in = new FileInputStream(file);
10. int c = 0;
11. while((c =in.read())!=-1){
12. System.out.println(c);
13. }
14. in.read();
15. }

文件系统不好写，内容太多了。写的比较乱。

总结：io分为读output和写input，同时通过解码可以分为字符流Reader和字节流InputStream。通过组装DataInput可以读取int,long和float和short等。 通过ObjectInputStream序列化和反射可以直接读成对象readUTF等。