黑马程序员_十四 【IO流认识】【字符流】

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------

1 IO流认识

概述：
1、IO流：即Input Output的缩写。
2、特点：
1）IO流用来处理设备间的数据传输。
2）Java对数据的操作是通过流的方式。
3）Java用于操作流的对象都在IO包中。
4）流按操作数据分为两种：字节流和字符流。
5）流按流向分为：输入流和输出流。
注意：流只能操作数据，而不能操作文件。
3、IO流的常用基类：
1）字节流的抽象基流：InputStream和OutputStream
2）字符流的抽象基流：Reader和Writer
注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如InputStream子类FileInputStream和Reader子类FileReader
如下图是IO体系：



2 字符流

简述：
1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。
2、字符流Writer,Reader只是用于处理文字数据，而字节流InputStream，OutputStream可以处理媒体数据，像图片，音频和视频等。
3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。专门用于操作文件的Writer子类对象：FileWriter ---> 后缀名为父类名，前缀名为流对象的功能。
字符流的读写：
1、写入字符流：
1）创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步就是在明确数据要存放的目的地。
2）调用write(String s)方法，将字符串写入到流中。
3）调用flush()方法，刷新该流的缓冲，将数据刷新到目的地中。
4）调用close()方法，是关闭流资源。但是关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。
特别要注意几点：
①close()和flush()区别：flush()刷新后，流可以继续使用；而close()刷新后，将会关闭流，不可再写入字符流。
②其实java自身不能写入数据，而是调用系统内部方式完成数据的书写，使用系统资源后，一定要关闭资源。
③数据的续写是通过构造函数 FileWriter(String s,boolean append)，根据给定文件名及指示是否附加写入数据的boolean值来构造FileWriter对象。
2、读取字符流：
1）创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，若不存在，将会发生异常FileNotFoundException。
2）调用读取流对象的read()方法。read()：一次读一个字符，且会继续往下读。
第一种方式：读取单个字符。第二种方式：通过字符数组进行读取。
3）读取后要将流资源关闭。
举例说明一下：
[java] view plaincopy

1 /*
2 那么先以操作文件为主来演示
3
4 需求：在硬盘上，创建一个文件，并写入文字数据。
5
6 找到一个专门用于操作文件的Writer子类对象。FileWriter 后缀名是父类名，前缀名是该流对象的功能
7 */
8 import java.io.*;
9 class FileWriteDemo
10 {
11 public static void main(String []args) throws IOException
12 {
13 //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件
14 //而且该文件会被创建到指定的目录下。如果该目录下已有同名文件，将被覆盖
15 //其实该步就是在明确数据要存放的目的地。
16 FileWriter fw =new FileWriter("C:/demo.txt");
17
18 fw.write("abcde");
19 //刷新流对象中缓冲中的数据
20 //将数据刷到目的地中
21 fw.flush();
22
23 fw.write("分工哈哈哈哈");
24 //将数据刷到目的地中
25 fw.flush();
26
27 //关闭流资源，但是关闭之前会刷新一次缓冲中的数据
28 //讲数据刷到目的地中，flush刷新后，流可以继续使用，close刷新后，会将流关闭。
29 fw.close();
30 }
31
32 }

IO异常的处理方式：

凡是与设备上的数据发生关系的，进行处理的都会发生IO异常，无论读还是写
异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。 Java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。基本过程是用try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理；还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常，然后在方法内部通过throw抛出异常对象。异常中要记得在finally中判断流对象是否为空，并在使用完后关闭所有的流对象。
举例说明：
[java] view plaincopy

33 import java.io.*;
34
35 class FileWriteDemo2
36 {
37 public static void main(String []args)
38 {
39 //在外面建立引用，在try内初始化
40 FileWriter fw=null;
41 try{
42
43 //try里面定义的变量在外面访问不到
44 //FileWriter fw=new FileWriter("demo.txt");
45
46 //向磁盘中写入文件
47 fw=new FileWriter("c:\\demo.txt");
48 //向文件中写入内容
49 fw.write("abcdefg");
50
51
52 }catch(IOException e)
53 {
54 System.out.println("catch:"+e.toString());
55 //finally内关闭资源，一定会被执行的代码往里面放入
56 }finally{
57
58 try{
59 // 对流对象进行判断，如果不为空就关闭
60 if(fw!=null)
61 {
62 fw.close();
63 }
64
65
66 }catch(IOException e)
67 {
68 System.out.println(e.toString());
69 }
70
71 }
72
73 }
74 }
文件的续写：
[java] view plaincopy

75 /*
76 演示对已有文件的数据续写。
77 */
78 import java.io.*;
79
80 class FileWriteDemo3
81 {
82 public static void main(String []args)
83 {
84 //在外面建立引用，在try内初始化
85 FileWriter fw=null;
86 try{
87
88 //try里面定义的变量在外面访问不到
89 //FileWriter fw=new FileWriter("demo.txt");
90
91 //向磁盘中写入文件
92 //传递一个true参数，代表不覆盖已有的文件，并在已有文件的末尾处进行数据的续写
93 fw=new FileWriter("c:\\demo.txt",true);
94 //向文件中写入内容
95 fw.write("nihao\r\nxiexie");
96
97
98 }catch(IOException e)
99 {
100 System.out.println("catch:"+e.toString());
101 //finally内关闭资源，一定会被执行的代码往里面放入
102 }finally{
103
104 try{
105 // 对流对象进行判断，如果不为空就关闭
106 if(fw!=null)
107 {
108 fw.close();
109 }
110
111
112 }catch(IOException e)
113 {
114 System.out.println(e.toString());
115 }
116
117 }
118
119 }
120 }

文本文件读取方式：

[java] view plaincopy

121 /*第一种方式：一次读取一个字符*/import java.io.*;
122
123 class FileReaderDemo
124 {
125 public static void main(String []args) throws IOException
126 {
127 //创建一个文件读流对象，和指定名称的文件相关联
128 //要保证该文件时已经存在的，如果不存在，会发生异常FileNotFoundException
129 FileReader fr=new FileReader("C:/demo.txt");
130 //调用读取流对象的read方法
131 //raed()方法一次读入一个字符，而且会自动往下读。
132 /*
133 int ch=fr.read();
134
135 System.out.println("ch="+(char)ch);
136
137 int ch1=fr.read();
138
139 System.out.println("ch="+(char)ch1);
140
141 */
142 //read方法作为整数读取的字符，范围在0到65535之间，如果达到流的末尾，则返回-1
143
144 /*
145 while(true)
146 {
147 int ch=fr.read();
148 if(ch==-1)
149 break;
150 System.out.println("ch="+(char)ch);
151 }
152 fr.close();
153 */
154 int ch=0;
155
156 while((ch=fr.read())!=-1)
157 {
158 System.out.println("ch="+(char)ch);
159 }
160 }
161 }

[java] view plaincopy

162 /*
163 第二种方式，通过字符数组进行读取。
164
165 这种读取方式最有效
166 */
167
168 import java.io.*;
169
170 class FileReaderDemo2
171 {
172 public static void main(String []args) throws IOException
173 {
174 FileReader fr=new FileReader("C:/demo.txt");
175
176 //定义一个字符数组。用于存储读到字符
177 //该read(char[])返回的是读到的字符个数
178
179 char [] buf=new char[1024];
180 /*
181 int num=fr.read(buf);
182
183 System.out.println("num="+num+"..."+new String(buf));
184
185 int num1=fr.read(buf);
186
187 System.out.println("num1="+num1+"..."+new String(buf));
188
189 int num2=fr.read(buf);
190
191 System.out.println("num2="+num2+"..."+new String(buf,0,1));
192 */
193 int num=0;
194 while((num=fr.read(buf))!=-1)
195 {
196 System.out.println(new String(buf,0,num));
197 }
198 fr.close();
199 }
200 }

拷贝文本文件：将C盘一个文本文件复制到D盘。

复制的原理：

其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：

1，在D盘创建一个文件。用于存储C盘文件中的数据。

2，定义读取流和C盘文件关联。

3，通过不断的读写完成数据存储。
方式一：读取一个字符，存入一个字符

方式二：先将读取的数据存入到内存中，再将存入的字符取出写入D盘

4，关闭资源：输入流资源和输出流资源。

举例：
[java] view plaincopy

201 import java.io.*;
202
203 class CopyText
204 {
205 public static void main(String[] args) throws IOException
206 {
207 copy_2();
208 }
209
210
211 public static void copy_2()
212 {
213 FileWriter fw = null;
214 FileReader fr = null;
215 try
216 {
217 fw = new FileWriter("SystemDemo_copy.txt");
218 fr = new FileReader("SystemDemo.java");
219
220 char[] buf = new char[1024];
221
222 int len = 0;
223 while((len=fr.read(buf))!=-1)
224 {
225 fw.write(buf,0,len);
226 }
227 }
228 catch (IOException e)
229 {
230 throw new RuntimeException("读写失败");
231
232 }
233 finally
234 {
235 if(fr!=null)
236 try
237 {
238 fr.close();
239 }
240 catch (IOException e)
241 {
242 }
243 if(fw!=null)
244 try
245 {
246 fw.close();
247 }
248 catch (IOException e)
249 {
250 }
251 }
252 }
253
254 //从C盘读一个字符，就往D盘写一个字符。
255 public static void copy_1()throws IOException
256 {
257 //创建目的地。
258 FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");
259
260 //与已有文件关联。
261 FileReader fr = new FileReader("RuntimeDemo.java");
262
263 int ch = 0;
264
265 while((ch=fr.read())!=-1)
266 {
267 fw.write(ch);
268 }
269
270 fw.close();
271 fr.close();
272
273 }
274 }
示意图:



缓冲区，BufferedWriter
缓存区的作用？
字符流缓冲区对应那两个类？
缓冲区必须结合什么来使用？
缓冲区对应的类为什么没有空构造函数？
跨平台的换行方法是？
关闭缓冲区本质是什么？关闭后还需要关闭数据流吗？
缓冲区要记得做什么？
Buffer.newLine()方法只能适用于什么对象？
缓冲区的作用：提高对数据读写效率。
缓冲区的出现是为了提高流的操作效率而出现的，要结合流才能使用。所以在创建缓冲区之前，必须要先有流对象。
缓冲区的原理就是内部封装数组，先存入在取出.
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。当返回null时，表示读到文件末尾。
readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。
一般方法命名后缀都是父类，前缀都是功能
public BufferedWriter(Writer out)，BufferedWriter没有空构造函数，必须有对象。原因是这个函数的作用就是为了提高流的操作效率，如果没有流的话无法使用。所以必须有流的对象——BufferedWriter要结合流才能使用。
该缓冲区中提供了一个跨平台的换行符。
newLine();注意：只有在缓冲区中才能使用这个方法，别的地方没有！
演示代码：
import java.io.*;
class BufferedWriterDemo
{
public static void main(String[] args) throws IOException
{
//创建一个字符写入流对象
FileWriter fw = new FileWriter ("buf.txt");
//为了提高字符写入流效率，加入了缓冲技术.
//只要将需要被调高效率的流对象作为参数传递给缓冲区的构造函数即可。
BufferedWriter bufw = new BufferedWriter (fw);
bufw.write("abcdefg");
bufw.newLine();//快平台换行方法，可以在任意系统下都执行换行操作。原理就是windows下封装\r\n,linux下封装的是\n，不容系统调用相对应的换行操作符
//bufw.write("abcd\r\nefg");windows下的换行操作
for(int x=1; x<5; x++)
{
bufw.write("abcd"+x);
bufw.newLine();//调用newLine()打印进行换行，并刷新缓冲流
bufw.flush();//可以把刷新操作放在for循环外面，但是这样如果中途遇到停电会倒是数据没有实时写入文件，所以为了保险，写一次刷新一次
}
//记住：只要用到缓冲区，就要记得刷新
//bufw.flush();缓冲区刷新方法
bufw.close();//关上缓冲区的方法
//fw。close();关上缓冲区就是在关闭缓冲区的流对象了。
}
}
BufferedReader
读取缓冲区为什么没有构造函数？如何读取？
将缓冲流中的内容全读出来的方法？代码？
字符读取缓冲流
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
注意：BufferedReader的对象是一个Reader，BufferedWriter的对象是一个Writer
的
BufferedReader特有方法是可以读一行字符串，ReaderLine().
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾。该方法读完不返回回车符，需要自行添加回车符。
演示代码：
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
//创建一个读取流对象和文件相关联。
FileReader fr = new FileReader("buf.txt");//建立一个流对象fr，将他与源对象buf相关联
//为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
BufferedReader bufr = new BufferedReader(fr);//建立一个字符串读取缓冲区bufr，对象为fr
//String s1 = bufr.readLine();//执行bufr的readLine()函数，注意这个函数中的L是大写，将读取的第一行以字符串的形式返回给s1
//继续执行此语句，将会继续向下读写。为了读取全部内容，建立循环语句。
//查表得知：readLine()返回为：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。
String line = null ;//建立一个空字符串line
while ((line=bufr.readLine())!=null)//当bufr读取到那一行不为null时，就把值返回给line，然后执行下面的操作。
{
System.out.println("line="+line);//输出
}
bufr.close();
}
}
通过缓冲区复制文本文件
Readline()会读行休止符吗？
怎么copy文件？代码？
Readline()返回的是什么内容？
Readline()原理是？

readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。
两个流直接没有什么关系，需要中转站来进行中转读写文件
import java.io.*;
class CopyTestByBuf
{
public static void main(String[] args)
{
BufferedReader bufr = null;//建立读写缓冲区，分别为bufr和buwr，值都是null。把这个缓冲区引用建立在try外面，在try里面进行初始化，这样就可以使finally中也可以访问到bufr了。
BufferedWriter bufw = null;
try
{
bufr = new BufferedReader(newFileReader("BufferedWriterDemo.java"));//利用匿名函数建立源文件io流与BufferedWriterDemo.java对接，然后建立新的缓冲区并赋值给bufr
bufw = new BufferedWriter(newFileWriter("Buffered_copy.txt"));//利用匿名函数建立将要写入目的地文件Buffered_copy.txt，io流与此文件对象，然后建立新的缓冲区，对象为此文件，并赋值给bufw
String line = null;//line充当中转站的作用，将两个缓冲区通过中转站来进行交换数据
while ((line=bufr.readLine())!=null)//将源文件中的内容全部读出。
{
System.out.println("line="+line);//这个必须带有换行，因为readLine()返回值不带有任何 行返回符，所以输出的时候才能输出回车
bufw.write(line);//将line内的字符串同bufw缓冲区的write()函数，写入到line值中
bufw.newLine();//因为readLine()函数不返回行回车符，所以利用newLine()函数进行换行，读取一行就换行
bufw.flush();//刷新缓冲区，及时将line中的内容写入文件
}
}
catch (IOException e)//如果读写失败就抛出异常
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
readLine的原理图示例：
无论是读一行，获取读取多个字符。其实最终都是在硬盘上一个一个读取。最终使用的还是read方法一次读一个的方法。读完一行，存入一个数组中区，然后返回该数组的字符串，再读下一行
MyBufferedReader
代码怎么写？
import java.io.*;
class MyBufferedReader//建立一个类，可以实现BufferedReader的功能
{
private FileReader r;//私有化对象，方便本类可以读取
MyBufferedReader (FileReader r)//构造函数，每次调用MyBufferedReader的接受对象r。没有对象r，就是没有FileReader不能执行MyBufferedReader
{
this.r = r;//将对象r赋值给本类成员变量r
}
public String myReadLine()throws IOException//建立myReadLine()，实现可以一次读一行数据的方法。
{ //定义一个临时容器。原BufferReader封装的是字符数组。
//为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
StringBuilder sb = new StringBuilder();//建立一个Stringbuilder函数，对象为sb
int ch = 0;//int变量ch为0
while ((ch=r.read())!=-1)//当问及读取不为-1，即没有数据时，继续下面的指令，并且把值赋给ch
{
if (ch=='\r')
continue;//如果遇到\r，就不进行任何操作，继续下面
if (ch=='\n')
return sb.toString();//如果遇到了\n就将sb转换成字符串的形式返回。
else
sb.append((char)ch);//如果没有遇到\n那么就将ch转换成字符，使用append将字符添加到sb中。
}
if(sb.length()!=0)//因为上面遇到回车才会记录字符，如果最后一行没有回车就不会记录，所以这里，当运行完上面的指令后，sb的长度不为零，即sb内有字符串的话，就继续返回字符串
return sb.toString();
return null;
}
/*
覆盖Reader类中的抽象方法。将上面的FileReader修改为Reader，这样接收的对象就是Reader，继承Reader，再覆写
public int read(char[] cbuf, int off, int len) throwsIOException
{
return r.read(cbuf,off,len) ;
}
public void close()throws IOException
{
r.close();
}
*/
public void myClose()throws IOException
{
r.close();//将FileReader的对象r关闭即可。其实BufferedReader的close()函数的本质也是调用对象的close()函数
}
}
class MyBufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("buf.txt");//源文件与流关联
MyBufferedReader myBuf = new MyBufferedReader(fr);//使用自己的方法来读取fr
String line = null;
while ((line=myBuf.myReadLine())!=null)
{
System.out.println(line);
}
myBuf.myClose();//使用自己的函数关闭流
}
}
示意图：



MyBufferedReader(自定义BufferedReader)：原理：可根据BufferedReader类中特有发那个发readLine()的原理，自定义一个类中包含相同功能的方法
步骤：1.初始化自定义的类，加入流对象。
2.定义一个临时容器，原BufferedReader封装的是字符数组，此类中可定义一个StringBuilder的容器，最终可实现字符串的提取。
[java] view plaincopy

351 /*
352 明白了BufferedReader类中特有方法readLine的原理后，
353 可以自定义一个类中包含一个功能和readline一致的方法
354 来模拟一下BufferedReader
355 */
356 import java.io.*;
357
358 class MyBufferedReader extends Reader
359 {
360
361 //装饰设计模式
362 private Reader r=null;
363
364 MyBufferedReader(Reader r)
365 {
366 this.r=r;
367 }
368 //可以一次读一行数据的方法
369 public String myReadLine() throws IOException
370 {
371 //定义一个临时容器，员BufferedReader封装的是字符数组
372 //为了演示方便，定义一个StringBulilder容器，因为最终还是要将数据变成字符串。
373 StringBuilder sb=new StringBuilder();
374 int ch=0;
375 while((ch=r.read())!=-1)
376 {
377 if(ch=='\r')
378 continue;
379 if(ch=='\n')
380 return sb.toString();
381 else
382 sb.append((char)ch);
383 }
384 //如果没有遇到\n，sb中而且有数据的话也要返回
385 if(sb.length()!=0)
386 return sb.toString();
387 return null;
388 }
389 /*
390 覆盖类中的抽象方法
391 */
392 public int read(char[] cbuf,int off,int len)throws IOException
393 {
394 return r.read(cbuf,off,len);
395 }
396
397 public void close() throws IOException
398 {
399 r.close();
400 }
401
402 public void myClose() throws IOException
403 {
404 r.close();
405 }
406 }
407
408
409
410 class MyBufferedReaderDemo
411 {
412 public static void main(String[] args) throws IOException
413 {
414 FileReader fr=new FileReader("buf.txt");
415
416 MyBufferedReader myBuf=new MyBufferedReader(fr);
417
418 String line=null;
419
420 while((line=myBuf.myReadLine())!=null)
421 {
422 System.out.println(line);
423 }
424
425 myBuf.myClose();
426 }
427
428 }

简单总结：

字符输出流：Writer 从内存向硬盘中写数据

字符输入流：Reader 从硬盘中读取数据到内存

操作文字 优先考虑字符流。效率高

---------------------------------------------------

●FileWriter

构造方法：

|--FileWriter("文件名或绝对路径名")

|--覆盖源文件

|--FileWriter("文件名或绝对路径名",boolean)

|--可续写源文件，boolean为true时

--------------------

方法：

|--write 写入内容

|--flush 对缓冲进行摔性能，使内容写进文件

|--close 对流进行关闭操作，可自动刷新

●FileReader

构造方法：

|--FileReader("文件名")

方法：

|--read 读取文件内容

|--int read()读取单个字符，返回一个对应的整数

|--读取到最后再读取的话返回-1，可以把-1当做流的结束标记

|--连续使用read方法，会自动往下读

|--重载(int char[])

|--按照数组的长度进行读取，可重复使用数组，每次读取到的下一个字符 存储进数组将对应地覆盖数组中的字符元素

|--返回读取到的字符数，返回的是新都区到的字符数而不是数组内的字符 数。

|--当返回-1时结束

|--重载(char[],int off,int len) //将字符读入数组或读入数组的一部分

|--read为阻塞式方法

|--close 关闭读取流

★文本文件的复制：

方法1---（读取一个写入一个）：

|--创建输入输出流对象，参考try内外进行

|--while循环内读取一个写入一个，条件返回值ch！=-1

|--刷新 关闭流 结束

方法2---（读取全部后一次性写入）：

|--输入流读取

|--1 先读取文件，将文件内容保存到字符数组

|--2 将字符数组转成字符串，用字符串记录下来

|--输出流写出

|--1 将字符串转成字符数组

|--2 将字符数组作为文件内容写进输出流

-----------------------------------------------------------------

缓冲区

用于提高对数据的操作效率。所以首先要有数据流存在，用缓冲区构造方法接收流对象。

●BufferedWriter

字符输出流缓冲区 类，创建对象后，需要先进行刷新再进行关闭，不同于字符输出流，关闭后自动刷新。

分为三种操作：单个字符、字符数组和字符串。

特有方法： newLine() 换行，具有跨平台性，在windows下的换行是\r\n，在Linux下是\n，用这个方法在其平台下都可以，使用的是相应的系统的line.separator属性。

注意：

缓冲区记性关闭操作时，同时把流关闭了，底层代码其实就是关闭流操作，所以调用了缓冲区的关闭操作后，就不能再进行流的操作了。 缓冲区并没有操作文件，只是提高了数据的操作效率，和文件没有直接关系，真正操作文件的还是流。

●BufferedReader

字符输入缓冲区，将数据读入缓冲区中。

其方法对文件的操作有两三种:字符、数组和行。读取行是文本特有的特性。

方法：

|--String readLine 一次读取一行，返回一个字符串

|--读到结尾的结束标记 返回 null

|--是基于read方法的扩展，read到的数据存到另一容器(数组或者 StringBuilder..)中，读到\r或\n是就停止，返回数组中的数据，就是一 行的数据，格式为字符串。

|--int read 读取单个字符到缓冲区

|--int read(char[],int off,int len) 把字符读进字符数组中

缓冲区操作输入输出操作，虽然和流直接操作表面没有太大差别，内在的读取输出是不同的。流是在源中读取，而缓冲区的读取是在缓冲区中进行的。

流对象直接对硬盘内容进行操作。而缓冲区对象操作的是：内存中保存了硬盘文件内容的数组。 就是一次性的先把文件内容装进内存数组中，再从内存数组中获取数据。

本篇博文结束！

@感谢老师的辛苦批阅