[java 笔记] 流的总结

[java 笔记] 流的总结

一、流的工作原理

　　C语言中用于描述一个文件的叫文件描述符，而向文件中读写数据都要通过这个文件描述符。而java中的叫流，但是java中的流功能更强大。流是用于从文件、内存、网络上读写数据的工具；将我们的文件比作为水桶，数据比作为水的话，那么流就是我们用来向桶中注入水、从桶中取水的"管道"(非操作系统的管道)。

二、流的分类

　　流按不同分类方法可以分不同的类型：

    　　① 按数据的流动方向可分为输入流和输出流。(注意:站在不同的角度，流的方向是不同，对于java中的流来说都是站在程序的角度，向程序中写入数据的流叫做输入流，从程序中读取数据的流叫做输出流)。

　　　 ② 按处理数据的单位可以分为字节流和字符流。(字节流是指每次读或写的字节数为1，而字符流每次读或写的字节数为2.而我们中文的一个字是由两个字节组成的，所以当要将一个包含中文的数据集通过流来打印到屏幕时，要使用字符流。注意如果是将含中文的数据集写出到文件，则不一定要使用字符流，因为字节流写出的东西，虽然是一个一个字节写出的，但是使用其他软件打开时，它按GBK编码来显示的话，中文还是能够显示出来的。而屏幕是本来两个字节的东西，拆成两个一字节的东西分别显示，从而显示不了中文)。

　　　 ③按功能的不同分为节点流和处理流。(节点流指的是直接从数据源读写数据的流，比如我们直接从文件读取数据的FileInputStream、FileReader，直接从内存读取的CharArrayReader、StringReader等。而处理流指的是“套接”在已经存在的流之上，进行读写的流)。

三、流总体结构

　　java.io包中包含了java中所有的流类，这些流的祖先分别是InputStream、OutputStream、Reader和Writer，这四个类都是抽象类。所有的类中以Stream结尾的是字节流，而像含有Reader和Writer的为字符流。含有input、Reader的一般为输入流，含有output、Writer的一般为输出流。具体四个抽象类的子类图为

　

　　其中深色的是节点流，浅色的为处理流。

四、节点流和处理流的具体情况

　　节点流

　　　　①File(文件节点流)：主要用于向一个文件中写入数据或从文件中读取数据

　　　　　　FileReader和FileWriter(字符流)      FileInputStream 和FileOutputStream(字节流)

　　　　②Memory Array(内存数组)：主要是在内存中开辟了一个数组，可以向这个数组中输入数据或从该内存数组中读取数据

　　　　　　CharArrayReader和CharArrayWriter(字符流)   ByteArrayInputStream和ByteArrayOutputStream(字节流)

　　　　③Memory String：同MemoryArray，但是它不是开辟一个数组，而是字符串

　　　　　　StringReader和StringWriter(字符流)   无对应的字节流

　　　　④Pipe(管道流)：向一个管道中写数据或从一个管道中读数据

　　　　　　PipedReader和PipedWriter(字符流)     PipedInputStream和PipedOutputStream(字节流)

　　处理流

　　　　①缓冲流:“套接”在相应的节点流上，对读写的数据提供缓冲的功能，减少了读写次数，提高了读写效率。

　　　　　　BuferedReader和BufferedWriter(字符流)     BufferedInputStream和BufferedOutputStream(字节流)

　　　　②转换流:用于将字节流转换成字符流(字符流没有必要转换为字节流，也没有这样的转换流).

　　　　　　InputStreamReader 和 OutputStreamWriter

　　　　③数据流：其他语言中有格式化的输入输出，而java中没有，所以如果想从屏幕中读入一个int型的数据时，很难办到。而数据流就是用于处理这种java基本类型的读写的。

　　　　　　DataInputStream和DataOutputSteam(字节流)

　　　　④打印流(Print流)：注意打印打印，说明只有输出流，没有输入流。打印流主要用于将数据打印到屏幕、文件或其他。

　　　　　　PrintStream(字节流)    PrintWriter(字符流)

　　　　⑤对象流(Object流):前面的流，操作的都是一个个的数据，而Object流，操作的是对象，它每次读或写的都是对象。而我们知道DataInputStream 和 DataOutputStream操作的基本数据类型，当往文件中写的顺序是int、long、float、int四个数据时，往回读的时候，类型一定要一样，否则读出来的与写入会不同。但是如果这四个数据时一个类的四个成员变量的话，那么使用对象流，可以一次将这个四个数据写入文件，往回读也是，只要readObject一些就能够将该对象读回，值不会变。当然这个类要实现Serializable这个接口。

　　　　　　ObjectInputStream 和 ObjectOutputStream(字节流)

五、用例代码

1 /*****************************************************
2 * 测试字节流
3 * ***************************************************/
4 public static void testFileInputStream() {
5 int temp,num = 0;
6 FileInputStream in = null;
7 FileReader fr = null;
8 try {
9 in = new FileInputStream("G:\\program\\java\\workspace\\ShangXue_java.io\\src\\com\\firefly727\\java\\testMain.java");
10 } catch (FileNotFoundException e) {
11 //
12 System.out.println("FileInputStream 创建出错");
13 e.printStackTrace();
14 System.exit(-1);
15 }
16 try {
17 while((temp = in.read()) != -1) {
18 System.out.print((char)temp);
19 num++;
20 }
21 // 下面这一句在执行时，能够输出中文，但是在FileInputStream进行read时不能够读取成中文.
22 System.out.println("共读取了"+num+"个字节");
23 in.close();
24 } catch (IOException e) {
25 System.out.println("文件读取出错！");
26 e.printStackTrace();
27 System.exit(-1);
28 }
29 num = 0;
30 try {
31 fr = new FileReader("G:\\program\\java\\workspace\\ShangXue_java.io\\src\\com\\firefly727\\java\\testMain.java");
32 } catch (FileNotFoundException e) {
33 //
34 System.out.println("FileReader 创建出错");
35 e.printStackTrace();
36 }
37 try {
38 while((temp = fr.read()) != -1) {
39 System.out.print((char)temp);
40 num++;
41 }
42 System.out.println("共读取了"+num+"个字符");
43 fr.close();
44 } catch (IOException e) {
45 //
46 System.out.println("文件读取出错！");
47 e.printStackTrace();
48 System.exit(-1);
49 }
50
51 }
52 public static void testFileOutputStream() {
53 FileInputStream fis = null;
54 FileOutputStream fos = null;
55 int num = 0,temp;
56
57 try {
58 fis = new FileInputStream("G:\\program\\java\\workspace\\ShangXue_java.io\\src\\com\\firefly727\\java\\testMain.java");
59 fos = new FileOutputStream("G:\\program\\java\\workspace\\ShangXue_java.io\\src\\com\\firefly727\\java\\test.java");
60 } catch (FileNotFoundException e) {
61 //
62 System.out.println("FileInputStream or FileOutputStream 创建出错");
63 e.printStackTrace();
64 System.exit(-1);
65 }
66 try {
67 while((temp = fis.read()) != -1) {
68 fos.write(temp);
69 num++;
70 }
71 // 下面这一句在执行时，能够输出中文，但是在FileInputStream进行read时不能够读取成中文.
72 System.out.println("共复制"+num+"个字节");
73 fis.close();
74 fos.close();
75 } catch (IOException e) {
76 System.out.println("文件读写出错！");
77 e.printStackTrace();
78 System.exit(-1);
79 }
80 }
81 public static void testFileWriter() {
82
83 FileWriter fw = null;
84 int temp;
85
86 try {
87 fw = new FileWriter("G:\\program\\java\\workspace\\ShangXue_java.io\\src\\com\\firefly727\\java\\temp.txt");
88 } catch (IOException e) {
89 //
90 e.printStackTrace();
91 System.exit(-1);
92 }
93 int i=0;
94 try {
95 for(i=0;i < 50000; i++) {
96 fw.write(i);
97 }
98 fw.close();
99 } catch (IOException e) {
100 //
101 e.printStackTrace();
102 }
103 }
104 public static void testFileReaderWriter() {
105 FileReader fr = null;
106 FileWriter fw = null;
107 int temp;
108 try {
109 fr = new FileReader("G:\\program\\java\\workspace\\ShangXue_java.io\\src\\com\\firefly727\\java\\testMain.java");
110 try {
111 fw = new FileWriter("G:\\program\\java\\workspace\\ShangXue_java.io\\src\\com\\firefly727\\java\\test2.java");
112 } catch (IOException e) {
113 //
114 e.printStackTrace();
115 }
116 } catch (FileNotFoundException e) {
117 //
118 e.printStackTrace();
119 System.exit(-1);
120 }
121 try {
122 while((temp = fr.read()) != -1) {
123 fw.write(temp);
124 }
125 fr.close();
126 fw.close();
127 System.out.println("复制完成");
128 } catch (IOException e) {
129 //
130 e.printStackTrace();
131 }
132 }

1 /*****************************************************
2 * 测试处理流-----1、缓冲流
3 * ***************************************************/
4 public static void testBufferedReader() {
5 BufferedReader br = null;
6 FileReader fr = null;
7 int i=0;
8 try {
9 fr = new FileReader("G:\\program\\java\\workspace\\Shan" +
10 "gXue_java.io\\src\\com\\firefly727\\java\\testMain.java");
11 br = new BufferedReader(fr);
12 } catch (FileNotFoundException e) {
13 //
14 e.printStackTrace();
15 System.exit(-1);
16 }
17 String str = null;
18 try {
19 while((str = br.readLine()) != null) {
20 System.out.println(i + " " + str);
21 i++;
22 }
23
24 br.close();
25 fr.close();
26 } catch (IOException e) {
27 e.printStackTrace();
28 System.exit(-1);
29 }
30
31 }
32 public static void testBufferedReaderWriter() {
33 FileWriter fw = null;
34 BufferedWriter bw = null;
35 FileReader fr = null;
36 BufferedReader br = null;
37 try {
38 fr = new FileReader("G:\\program\\java\\workspace\\Shan" +
39 "gXue_java.io\\src\\com\\firefly727\\java\\testMain.java");
40 br = new BufferedReader(fr);
41
42 fw = new FileWriter("G:\\program\\java\\workspace\\Shan" +
43 "gXue_java.io\\src\\com\\firefly727\\java\\tst.txt");
44 bw = new BufferedWriter(fw);
45 } catch (IOException e) {
46 //
47 e.printStackTrace();
48 System.exit(-1);
49 }
50 String str = null;
51 try {
52 while((str = br.readLine()) != null) {
53 bw.write("\n" + str);
54 }
55 br.close();
56 bw.close();
57 fr.close();
58 fw.close();
59 } catch (IOException e) {
60 //
61 e.printStackTrace();
62 System.exit(-1);
63 }
64 }
65 public static void testBufferedInputStream() {
66 //为什么这样复制是不对的！BufferedOutputStream流的write函数有什么问题吗？
67 FileInputStream fis = null;
68 BufferedInputStream bis = null;
69 FileOutputStream fos = null;
70 BufferedOutputStream bos = null;
71 int temp;
72 try {
73 fis = new FileInputStream("G:\\program\\java\\workspace\\Shan" +
74 "gXue_java.io\\src\\com\\firefly727\\java\\testMain.java");
75 bis = new BufferedInputStream(fis);
76 fos = new FileOutputStream("G:\\program\\java\\workspace\\Shan" +
77 "gXue_java.io\\src\\com\\firefly727\\java\\tt.txt");
78 bos = new BufferedOutputStream(fos);
79
80 } catch (FileNotFoundException e) {
81 //
82 e.printStackTrace();
83 System.exit(-1);
84 }
85
86 try {
87
88 while((temp = bis.read()) != -1) {
89 System.out.print((char)temp);
90 bos.write((char)temp);
91 }
92 } catch (IOException e) {
93 //
94 e.printStackTrace();
95 System.exit(-1);
96 }
97 }
98 public static void testBufferedOutputStream() {
99 FileOutputStream fos = null;
100 BufferedOutputStream bos = null;
101 try {
102 fos = new FileOutputStream("G:\\program\\java\\workspace\\Shan" +
103 "gXue_java.io\\src\\com\\firefly727\\java\\t.txt");
104 bos = new BufferedOutputStream(fos);
105 } catch (FileNotFoundException e) {
106 //
107 e.printStackTrace();
108 System.exit(-1);
109 }
110 for(int i=0; i<50000; i++) {
111 try {
112 bos.write((char)i);
113 } catch (IOException e) {
114 //
115 e.printStackTrace();
116 System.exit(-1);
117 }
118 }
119 }

1 /*****************************************************
2 * 测试处理流-----2、转换流
3 * ***************************************************/
4 public static void testInputStreamReader() {
5 InputStreamReader isr = null;
6
7 isr = new InputStreamReader(System.in);
8 BufferedReader br = new BufferedReader(isr);
9 String str = null;
10 try {
11 while((str = br.readLine()) != null) {
12 if(str.equalsIgnoreCase("exit")) break;
13 System.out.println(str);
14 }
15 } catch (IOException e) {
16 //
17 e.printStackTrace();
18 System.exit(-1);
19 }
20 }
21 public static void testOutputStreamWriter() {
22 FileOutputStream fos = null;
23 OutputStreamWriter osw = null;
24 try {
25 fos = new FileOutputStream("G:\\program\\java\\workspace\\Shan" +
26 "gXue_java.io\\src\\com\\firefly727\\java\\testOutputStreamWriter.txt");
27 osw = new OutputStreamWriter(fos);
28 } catch (FileNotFoundException e) {
29 //
30 e.printStackTrace();
31 System.exit(-1);
32 }
33
34 try {
35 osw.write("hello, my name is firefly727");
36 System.out.println(osw.getEncoding());
37 osw.close();
38 } catch (IOException e) {
39 //
40 e.printStackTrace();
41 }
42 try {
43 osw = new OutputStreamWriter(new FileOutputStream("G:\\program\\java\\workspace\\Shan" +
44 "gXue_java.io\\src\\com\\firefly727\\java\\testOutputStreamWriter.txt",true),"ISO8859-1");
45
46 } catch (FileNotFoundException e) {
47 //
48 e.printStackTrace();
49 System.exit(-1);
50 }catch(UnsupportedEncodingException e) {
51 e.printStackTrace();
52 System.exit(-1);
53 }
54 try {
55
56 osw.write(" hello, I changed my name ,now my name is Firefly");
57 System.out.println(osw.getEncoding());
58 osw.close();
59 } catch (IOException e) {
60 //
61 e.printStackTrace();
62 System.exit(-1);
63 }
64 }

1 /*****************************************************
2 * 测试处理流-----3、数据流
3 * ***************************************************/
4 public static void testDataInputStream() {
5
6 ByteArrayOutputStream baos = new ByteArrayOutputStream();
7 DataOutputStream dos = new DataOutputStream(baos);
8 double temp = 0;
9
10 try {
11 temp = Math.random();
12 dos.writeDouble(temp);
13 dos.writeBoolean(true);
14 System.out.println(temp);
15 } catch (IOException e) {
16 //
17 e.printStackTrace();
18 System.exit(-1);
19 }
20
21 ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
22 DataInputStream dis = new DataInputStream(bais);
23 try {
24 // 写入字符数组中的数据是先进先出的，要按顺序来读，虽然不按顺序读的时候，可以读，但是可能结果会不一样
25 // 但是系统不会报错。
26 System.out.println(dis.available());
27 System.out.println(dis.readDouble());
28 System.out.println(dis.readBoolean());
29
30 } catch (IOException e) {
31 //
32 e.printStackTrace();
33 System.exit(-1);
34 }
35
36 }

1 /*****************************************************
2 * 测试处理流-----4、打印流
3 * ***************************************************/
4 public static void testPrintStream() {
5 FileOutputStream fos = null;
6 PrintStream ps = null;
7 try {
8 fos = new FileOutputStream("G:\\program\\java\\workspace\\Shan" +
9 "gXue_java.io\\src\\com\\firefly727\\java\\testPrintStream.txt");
10 } catch (FileNotFoundException e) {
11 //
12 e.printStackTrace();
13 System.exit(-1);
14 }
15 ps = new PrintStream(fos);
16
17 if(ps != null) {
18 System.setOut(ps);
19 }
20 ps.println("hello, PrintStream!");
21 ps.println(123456789);
22 }
23 public static void testPrintStream2(String fileName, PrintStream ps) {
24 FileReader fr = null;
25 BufferedReader br = null;
26 try {
27 fr = new FileReader(fileName);
28 br = new BufferedReader(fr);
29 } catch (FileNotFoundException e) {
30 //
31 e.printStackTrace();
32 System.exit(-1);
33 }
34 String str = null;
35 try {
36 while((str = br.readLine()) != null) {
37 ps.println(str);
38 }
39 ps.flush();
40 ps.close();
41 br.close();
42 fr.close();
43 } catch (IOException e) {
44 //
45 e.printStackTrace();
46 System.exit(-1);
47 }
48 }
49 public static void testPrintWriter() {
50 String str = null;
51 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
52 PrintWriter log = null;
53 try {
54 log = new PrintWriter(new FileWriter("G:\\program\\java\\workspace\\Shan" +
55 "gXue_java.io\\src\\com\\firefly727\\java\\testPrintWriter.txt",true));
56 } catch (IOException e) {
57 //
58 e.printStackTrace();
59 System.exit(-1);
60 }
61 try {
62
63 while((str = br.readLine()) != null) {
64 if(str.equalsIgnoreCase("exit")) break;
65 log.println("-------------");
66 log.println(str);
67 log.flush();
68 }
69
70 log.println("====="+new Date()+"=====");
71 log.flush();
72 log.close();
73 } catch (IOException e) {
74 //
75 e.printStackTrace();
76 System.exit(-1);
77 }
78 }

1 public static void main(String[] args) {
2 //
3 testFileInputStream();
4 testFileOutputStream();
5 testFileReaderWriter();
6 testFileWriter();
7 testBufferedReader();
8 testBufferedReaderWriter();
9 testBufferedInputStream();
10 testBufferedOutputStream();
11 testInputStreamReader();
12 testOutputStreamWriter();
13 testDataInputStream();
14 testPrintStream();
15 String str = args[0];
16 if(str != null) testPrintStream2(str, System.out);
17 testPrintWriter();
18 }
相关阅读:
Navicat破解安装
 jrebel and xrebel
JMTER连接数据库
 jmter参数化
 JMTER逻辑控制器
 JMter定时器和聚合报告
 Jmter文件上传
 npm安装教程
 adb调试工具
 Jmter前/后置处理器
原文地址：https://www.cnblogs.com/Firefly727/p/2101405.html