------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
java.io在jdk中的定义：为系统提供输入和输出通过数据流，序列化以及文件系统。
在学习IO体系的时候，我们可以遵循这样的规律：
看父类的共性功能，用子类的对象。
而且，IO体系的好处在于：
每个子类的后缀名都是所属体系的父类的名称，很容易区分所属的体系；而且每个子类前缀名都是该子类对象的功能体系。
Java IO体系：
|--字节流抽象基类
|--OutputStream
|--InputStream
常用的字节型的节点流有：
- 文件：FileInputStream，FileOutputStream
- 内存（数组）：ByteArrayInputStream，ByteArrayOutputStream
- 管道：PipedInputStream，PipedOutputStream
|--字符流抽象基类
|--Reader
|--Writer
常用的字符型的节点流有：
- 文件：FileReader， FileWriter
- 内存（数组）：CharArrayReader，CharArrayWriter
- 内存（字符串）：StringReader，StringWriter
- 管道：PipedReader，PipedWriter
下面先讲解FileWriter
示例：将一段文字数据写入到硬盘上
1 import java.io.FileWriter;
2 import java.io.IOException;
3
4 public class FileWriterDemo {
5 public static void main(String[] args) throws IOException {
6 /*
7 //需求：将一个段文字数据写入到硬盘上.
8 思路：
9 1，一段文字就是字符串数据。
10 2，写到硬盘上，从哪到哪呢？字符串数据在内存中，写到硬盘上——将内存中的数据搞到硬盘上，
11 这就涉及到了设备之间的数据处理。就要用到IO技术。
12 既然是从内存到硬盘，应该是输出流。
13 3，对于文字而言，io中提供了便捷的操作，比如字符流。
14 4，结合两者，需要输出流，需要字符流，可以使用字符输出流。Writer
15 5，具体用哪个子类对象呢？硬盘上用于存储数据的体现：文件。在这个体系中有对象FileWriter 。
16 */
17
18
19 //1，通过FileWriter创建流对象。构造时，必须明确写入数据需要存储的位置。
20 /*
21 * 该对象一创建，目的文件就会被创建。
22 * 如果该文件已经存在，会被覆盖。
23 * 做了什么事呢？在堆内存中创建一个对象。同时调用了系统的资源。
24 */
25 FileWriter fw = new FileWriter("demo.txt");
26
27 //2，使用字符输出流对象将字符串进行写入。调用写入方法。
28 //数据没有直接写入到目的文件中，而是写入到了临时缓冲中。
29 fw.write("abcdef");
30
31 //3，怎么把数据弄到文件中呢？发现Writer类中有一个flush()方法。刷新缓冲区，将缓冲的数据立即写入到目标中。
32 fw.flush();
33
34 fw.write("haha");
35 //4，关闭此流，关闭资源。在关闭之前，先刷一次缓冲，将数据都写入到目的中。
36 fw.close();
37
38 /*
39 * flush()和close()有什么区别？
40 * flush():仅将缓冲中的数据刷新到目的地。流对象可以继续使用。可以使用多次。
41 * close():将缓冲中的数据刷到目的地后，直接关闭流资源，流无法继续使用。只能使用一次。
42 * 在close()方法当中其实在关闭之前都会调用一次flush();
43 *
44 */
45 }
46 }
示例展示了FileWriter的基本流程，但是在程序中的很多地方都会发生异常，因此，有必要了解Java中IO体系的异常处理规范。
示例二：IO异常处理
1 import java.io.FileWriter;
2 import java.io.IOException;
3 public class FileWriterDemo3 {
4
5 public static void main(String[] args) {
6 /*
7 * IO异常的处理规范。
8 * 创建流对象—————— 在try外创建流对象的引用。 在try内对流对象进行初始化。
9 */
10 FileWriter fw = null;
11 try {
12 fw = new FileWriter("k:\\demo3.txt");
13
14 fw.write("abcde");
15 fw.flush();
16
17 } catch (IOException e) {
18
19 System.out.println(e.toString());
20 } finally {
21 //在关闭之间必须得判断这个流是否存在，是否被创建。
22 if (fw != null)
23 try {
24 fw.close();
25 } catch (IOException e) {
26
27 // 相关的代码处理。比如说，将关闭失败的信息记录到日志文件中。
28 throw new RuntimeException("关闭失败");
29 }
30 }
31 }
32 }
FileReader主要用于读取，读取方式的不同也必然导致效率的不同。
1. 读取单个字符：读取单个字符，在字符可用、发生I/O错误或者已到达流的末尾前，此方法一直阻塞。返回值为读取到的字符数，如果已到达流的末尾，则返回-1.
2. 读取字符数组：将读取到的字符存储到字符数组里面，并且返回字符数组的长度。如果到达流的末尾，返回-1.
1 import java.io.FileNotFoundException;
2 import java.io.FileReader;
3 import java.io.IOException;
4
5 public class FileReaderTest {
6
7 public static void main(String[] args) throws IOException {
8 // TODO Auto-generated method stub
9 FileReader fr = new FileReader("IO流.txt");
10
11 //演示读取单个字符
12 long time = System.currentTimeMillis();
13 readChar(fr);
14 long timereadChar = System.currentTimeMillis();
15
16 System.out.println("time Read char is = " + (timereadChar-time));
17 //演示读取字符到缓冲区中。
18
19 long time2 = System.currentTimeMillis();
20 readToBuf(fr);
21 long timeReadBuf = System.currentTimeMillis();
22 System.out.println("time Read to Buf is = " + (timeReadBuf-time2));
23
24
25 }
26 private static void readToBuf(FileReader fr) throws IOException {
27 //定义一个字符缓冲区，用于存放读到的字符。
28 char[] buf = new char[50];
29 //设刚开始读到的字符为0
30 int len = 0 ;
31 //一直循环读取字符到缓冲区中，直到读到流的末尾。
32 while((len = fr.read(buf)) != -1){
33 //将每次读满的缓冲区中的字符，变成字符串打印出来。
34 System.out.println(new String(buf , 0 , len));
35 }
36 }
37 private static void readChar(FileReader fr) throws IOException {
38 //设每个读取到的字符整数值为ch.
39 int ch = 0;
40 //循环读取字符，直到流的末尾
41 while((ch = fr.read()) != -1){
42 //将读取到的字符，强制转换为 char
43 System.out.print((char) ch);
44 }
45 }
46 }
缓冲区：
流对象的read()：是从目的地一次读取一个。
缓冲区的read()：是通过流对象的read将一批数据读取到缓数组，然后再从数组中一次取一个，所以内存操作要比硬盘操作要高效。
在Java中，为了提高程序的效率，为我们提供了对应的类：BufferedReader和BufferedWriter。
示例三：
1 import java.io.BufferedWriter;
2 import java.io.FileWriter;
3 import java.io.IOException;
4
5 public class BufferedWriterDemo {
6
7 public static void main(String[] args) throws IOException {
8
9 //创建一个流对象。
10 FileWriter fw = new FileWriter("buf.txt");
11
12 //为了提高效率。创建缓冲区对象，并和要被提高效率的流相关联。
13 BufferedWriter bufw = new BufferedWriter(fw);
14
15 for(int x=0;x<4; x++){
16 bufw.write(x+"--hahaha");
17 //写入一个换行符。
18 bufw.newLine();
19 //要对缓冲区进行刷新。记住：一般只要使用了缓冲区，就一定要刷新。
20 bufw.flush();
21 }
22
23 //关闭缓冲区。
24 bufw.close();//问：还用关闭fw.close()?不用，因为关闭缓冲区，其实就是在关闭缓冲区关联的流。
25
26 }
27 }
示例四：
1 import java.io.BufferedReader;
2 import java.io.FileReader;
3 import java.io.IOException;
4
5 public class BuffereReaderDemo {
6
7 public static void main(String[] args) throws IOException {
8 /**
9 * 演示：BufferedReader
10 * 1. 先有字符读取流；
11 * 2. 该类有一个特有方法。readLine(). 一次读一行。
12 */
13 //创建读取流对象 和 文件相关联。
14 FileReader fr = new FileReader("Demo.txt");
15
16 //创建读取缓冲区对象 和 流对象关联对其进行高效 操作；
17 BufferedReader bufr = new BufferedReader(fr);
18 //简写形式：
19 //BufferedReader bufr = new BufferedReader(new FileReader("Demo.txt"));
20
21 String line = null ;
22 while((line = bufr.readLine()) != null){
23 System.out.println(line);
24 }
25 bufr.close();
26 }
27 }
时间： 2024-08-28 03:39:10