Java IO流学习总结

蔚落 2022-05-24 02:25 235阅读 0赞

（转自：[https://blog.csdn.net/du\_minchao/article/details/49045421][https_blog.csdn.net_du_minchao_article_details_49045421]）

Java中的流，可以从不同的角度进行分类。

按流的方向分：输入流和输出流。

按处理数据单位分：字节流和字符流。

按实现功能分：节点流和处理流。

输出流：

![0_1332493808Gv0r.gif][]

输入流：

![0_1332493796QEdV.gif][]

字节流：一次读入或读出是8位二进制。

字符流：一次读入或读出是16位二进制。

字节流和字符流的原理是相同的，只不过处理的单位不同而已。后缀是Stream是字节流，而后缀是Reader，Writer是字符流。

字节流：处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。

节点流：直接与数据源相连，读入或读出。

![0_1332494121hUHK.gif][]

直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。

处理流：与节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。

![0_1332494112YBmp.gif][]

下面是java IO流的结构示意图：

![SouthEast][]

字符流：

Reader：用于读取字符流的抽象类。

|---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大 多数情况下，默认值就足够大了。

|---LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法setLineNumber(int)和getLineNumbner()，它们可分别用于设置和获取当前行号。

|---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

|---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

Writer：写入字符流的抽象类。

|---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

|---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的 [charset][] 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

|---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

字节流：

InputStream：是表示字节输入流的所有类的超类。

|--- FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。

|--- FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。

|--- BufferedInputStream：该类实现缓冲的输入流。

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

OutputStream：此抽象类是表示输出字节流的所有类的超类。

|--- FileOutputStream：文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。

|--- FilterOutputStream：此类是过滤输出流的所有类的超类。

|--- BufferedOutputStream：该类实现缓冲的输出流。

流的操作规律：

1、明确源和目的。

数据源：就是需要读取，可以使用两个体系：InputStream、Reader；

数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；

2、操作的数据是否是纯文本数据？

如果是：数据源：Reader

数据汇：Writer

如果不是：数据源：InputStream

数据汇：OutputStream

3、虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？

明确操作的数据设备。

数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)

数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。

4、需要在基本操作上附加其他功能吗？比如缓冲。

如果需要就进行装饰。

/记住，只要一读取键盘录入，就用这句话。

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

下面是一个应用的例子：

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

1.  <span style="color:\#000000;">**import** java.io.\*;  
2.  **import** java.nio.CharBuffer;  
3.  **import** java.util.Scanner;  
4.    
5.  **import** org.junit.Test;  
6.    
7.  **public** **class** Test1 \{  
8.      @Test  
9.      **public** **void** testFile() **throws** IOException \{  
10.   
11.         File file1 = **new** File("D:/test");  
12.         file1.mkdir(); // 在D盘下创建test目录  
13.         File\[\] fileArr = file1.listFiles(); // 获取目录下的所有文件  
14.         **for** (File f : fileArr) \{ // 输出目录下的文件名  
15.             System.out.println(f.getName());  
16.         \}  
17.           
18.         String str;  
19.         System.out.println("请输入需要复制的文件名：");  
20.         BufferedReader buf=**new** BufferedReader(**new** InputStreamReader(System.in));  
21.             str = buf.readLine();  
22.         **if**(str.equals("1.txt"))\{  
23.             **new** copyFile().copyTxt();  
24.         \}  
25.         **if**(str.equals("1.jpg"))\{  
26.             **new** copyFile().copyJpg();  
27.         \}  
28.           
29.         buf.close();  
30.         File\[\] fileArr2 = file1.listFiles(); // 获取目录下的所有文件  
31.         **for** (File f : fileArr2) \{ // 输出目录下的文件名  
32.             System.out.println(f.getName());  
33.         \}  
34.           
35.   
36.     \}  
37.   
38. \}  
39.   
40. **class** copyFile \{  
41.     **public** **void** copyTxt() **throws** IOException \{  
42.         **int** number = 0;  
43.         File file1 = **new** File("D:/test/1.txt");  
44.         File file2 = **new** File("D:/test/2.txt");  
45.         BufferedReader bfRead;  
46.         BufferedWriter bfWrite;  
47.         bfWrite = **new** BufferedWriter(**new** FileWriter(file2));  
48.         **char**\[\] arry = **new** **char**\[1024\];  
49.         FileReader fRead = **new** FileReader(file1);  
50.         bfRead = **new** BufferedReader(fRead);  
51.   
52.         **while** ((number = bfRead.read(arry)) != -1) \{  
53.             bfWrite.write(arry, 0, number);  
54.         \}  
55.   
56.         bfWrite.close();  
57.         bfRead.close();  
58.   
59.     \}  
60.   
61.     **public** **void** copyJpg() **throws** IOException  \{  
62.               
63.         File file1=  **new** File("D:/test/1.jpg");  
64.         File file2= **new** File("D:/test/2.jpg");  
65.         FileInputStream bfRead=**new** FileInputStream(file1);;  
66.         FileOutputStream bfWrite=**new** FileOutputStream(file2);  
67.         **try** \{  
68.             **byte**\[\] arry = **new** **byte**\[1024\]; // 定义数组，传递流之间的数据  
69.             **int** count = 0;  
70.   
71.             **while**((count = bfRead.read(arry)) != -1) \{  
72.                 bfWrite.write(arry, 0, count);  
73.             \}  
74.   
75.               
76.         \} **catch** (FileNotFoundException e) \{  
77.             System.out.println("filenotfound");  
78.         \} **catch** (IOException e) \{  
79.             System.out.println("IoException");  
80.         \}  
81.         bfWrite.close();  
82.         bfRead.close();  
83.   
84.     \}  
85. \}  
86. </span>  
87.

[https_blog.csdn.net_du_minchao_article_details_49045421]: https://blog.csdn.net/du_minchao/article/details/49045421
[0_1332493808Gv0r.gif]: /images/20220524/ef909b8c09614d1badc1b53166fdd43a.png
[0_1332493796QEdV.gif]: /images/20220524/9508cad3194a491b8e4dbf2a3908b2ed.png
[0_1332494121hUHK.gif]: /images/20220524/f0df75c1753a4d4dab5203ee76351c0b.png
[0_1332494112YBmp.gif]: /images/20220524/a3c0f953c5464efd81aee8f36d87c453.png
[SouthEast]: /images/20220524/546acdb6b4504eb9abcd6b7791001054.png
[charset]: http://blog.csdn.net/du_minchao/article/details/49025201
[view plain]: https://blog.csdn.net/du_minchao/article/details/49045421#