IO流上：概述、字符流、缓冲区

一、IO流概述

概述：

IO流简单来说就是Input和Output流，IO流主要是用来处理设备之间的数据传输，java对于数据的操作都是通过流实现，而java用于操作流的对象都在IO包中。

分类：

按操作数据分为：字节流和字符流。 如：Reader和InpurStream

按流向分：输入流和输出流。如：InputStream和OutputStream

IO流常用的基类：

* InputStream ， OutputStream

字符流的抽象基类：

* Reader ， Writer

由上面四个类派生的子类名称都是以其父类名作为子类的后缀：

如：FileReader和FileInputStream

二、字符流

1. 字符流简介：

* 字符流中的对象融合了编码表，也就是系统默认的编码表。我们的系统一般都是GBK编码。

* 字符流只用来处理文本数据，字节流用来处理媒体数据。

* 数据最常见的表现方式是文件，字符流用于操作文件的子类一般是FileReader和FileWriter。

2.字符流读写：

注意事项：

* 写入文件后必须要用flush()刷新。

* 用完流后记得要关闭流

* 使用流对象要抛出IO异常

*定义文件路径时，可以用“/”或者“\\”。

*在创建一个文件时，如果目录下有同名文件将被覆盖。

*在读取文件时，必须保证该文件已存在，否则出异常

示例1：在硬盘上创建一个文件,并写入一些文字数据

1. classFireWriterDemo{
2. publicstaticvoidmain(String[]args)throwsIOException{//需要对IO异常进行处理
4. //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
5. //而且该文件会被创建到指定目录下。如果该目录有同名文件，那么该文件将被覆盖。
7. FileWriterfw=newFileWriter("F:\\1.txt");//目的是明确数据要存放的目的地。
9. //调用write的方法将字符串写到流中
10. fw.write("helloworld!");
12. //刷新流对象缓冲中的数据，将数据刷到目的地中
13. fw.flush();
15. //关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候，必须close();
16. fw.write("first_test");
17. fw.close();
18. //flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。
20. }
21. }

示例2：FileReader的reade()方法.

要求：用单个字符和字符数组进行分别读取

1. classFileReaderDemo{
2. publicstaticvoidmain(String[]args){
3. characters();
4. }
7. /*****************字符数组进行读取*********************/
8. privatestaticvoidcharacters(){
10. try{
12. FileReaderfr=newFileReader("Demo.txt");
13. char[]buf=newchar[6];
14. //将Denmo中的文件读取到buf数组中。
15. intnum=0;
16. while((num=fr.read(buf))!=-1){
18. //String(char[]value,intoffest,intcount)分配一个新的String,包含从offest开始的count个字符
19. sop(newString(buf,0,num));
20. }
21. sop('\n');
22. fr.close();
23. }
24. catch(IOExceptione){
25. sop(e.toString());
26. }
27. }
30. /*****************单个字母读取*************************/
31. privatestaticvoidsingleReader(){
33. try{
35. //创建一个文件读取流对象，和指定名称的文件关联。
36. //要保证文件已经存在，否则会发生异常：FileNotFoundException
37. FileReaderfr=newFileReader("Demo.txt");
40. //如何调用读取流对象的read方法？
41. //read()方法，一次读取一个字符，并且自动往下读。如果到达末尾则返回-1
42. intch=0;
43. while((ch=fr.read())!=-1){
44. sop((char)ch);
45. }
46. sop('\n');
47. fr.close();
50. /*intch=fr.read();
51. sop("ch="+(char)ch);
53. intch2=fr.read();
54. sop("ch2="+(char)ch2);
56. //使用结束注意关闭流
57. fr.close();*/
61. }
62. catch(IOExceptione){
63. sop(e.toString());
64. }
66. }
69. /**********************Println************************/
70. privatestaticvoidsop(Objectobj){
71. System.out.print(obj);
72. }
74. }

示例3：对已有文件的数据进行续写

1. importjava.io.*;
3. classFileWriterDemo3{
4. publicstaticvoidmain(String[]args){
6. try{
7. //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写
8. FileWriterfw=newFileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);
9. fw.write("ischaractortable?");
10. fw.close();
11. }
12. catch(IOExceptione){
13. sop(e.toString());
14. }
16. }
18. /**********************Println************************/
19. privatestaticvoidsop(Objectobj)
20. {
21. System.out.println(obj);
22. }
23. }

练习：

将F盘的一个文件复制到E盘。

思考：

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

步骤：

1.在D盘创建一个文件，存储F盘中文件的数据。
2.定义读取流和F：盘文件关联。
3.通过不断读写完成数据存储。
4.关闭资源。

源码：

1. importjava.io.*;
2. importjava.util.Scanner;
4. classCopyText{
5. publicstaticvoidmain(String[]args)throwsIOException{
6. sop("请输入要拷贝的文件的路径:");
7. Scannerin=newScanner(System.in);
8. Stringsource=in.next();
9. sop("请输入需要拷贝到那个位置的路径以及生成的文件名:");
10. Stringdestination=in.next();
11. in.close();
12. CopyTextDemo(source,destination);
14. }
16. /*****************文件Copy*********************/
17. privatestaticvoidCopyTextDemo(Stringsource,Stringdestination){
19. try{
20. FileWriterfw=newFileWriter(destination);
21. FileReaderfr=newFileReader(source);
22. char[]buf=newchar[1024];
23. //将Denmo中的文件读取到buf数组中。
24. intnum=0;
25. while((num=fr.read(buf))!=-1){
26. //String(char[]value,intoffest,intcount)分配一个新的String,包含从offest开始的count个字符
27. fw.write(newString(buf,0,num));
28. }
29. fr.close();
30. fw.close();
31. }
32. catch(IOExceptione){
33. sop(e.toString());
34. }
35. }
39. /**********************Println************************/
40. privatestaticvoidsop(Objectobj){
41. System.out.println(obj);
42. }
43. }

三、缓冲区

1. 字符流的缓冲区：BufferedReader和BufferedWreiter

* 缓冲区的出现时为了提高流的操作效率而出现的.

* 需要被提高效率的流作为参数传递给缓冲区的构造函数

* 在缓冲区中封装了一个数组，存入数据后一次取出

BufferedReader示例：

读取流缓冲区提供了一个一次读一行的方法readline，方便对文本数据的获取。
readline()只返回回车符前面的字符，不返回回车符。如果是复制的话，必须加入newLine()，写入回车符

newLine()是java提供的多平台换行符写入方法。

1. importjava.io.*;
4. classBufferedReaderDemo{
5. publicstaticvoidmain(String[]args)throwsIOException{
7. //创建一个字符读取流流对象，和文件关联
8. FileReaderrw=newFileReader("buf.txt");
10. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
11. BufferedReaderbrw=newBufferedReader(rw);
14. for(;;){
15. Strings=brw.readLine();
16. if(s==null)break;
17. System.out.println(s);
18. }
20. brw.close();//关闭输入流对象
22. }
23. }

BufferedWriter示例：

1. importjava.io.*;
4. classBufferedWriterDemo{
5. publicstaticvoidmain(String[]args)throwsIOException{
7. //创建一个字符写入流对象
8. FileWriterfw=newFileWriter("buf.txt");
10. //为了提高字符写入效率，加入了缓冲技术。
11. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
12. BufferedWriterbfw=newBufferedWriter(fw);
14. //bfw.write("abc\r\nde");
15. //bfw.newLine();这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符
16. //用到缓冲区就必须要刷新
17. for(intx=1;x<5;x++){
18. bfw.write("abc");
19. bfw.newLine();//java提供了一个跨平台的换行符newLine();
20. bfw.flush();
21. }
25. bfw.flush();//刷新缓冲区
26. bfw.close();//关闭缓冲区，但是必须要先刷新
28. //注意，关闭缓冲区就是在关闭缓冲中的流对象
29. fw.close();//关闭输入流对象
31. }
32. }

2.装饰设计模式

装饰设计模式：：：：

要求：自定义一些Reader类，读取不同的数据(装饰和继承的区别)
MyReader //专门用于读取数据的类
|--MyTextReader
|--MyBufferTextReader
|--MyMediaReader
|--MyBufferMediaReader
|--MyDataReader
|--MyBufferDataReader

如果将他们抽取出来，设计一个MyBufferReader，可以根据传入的类型进行增强
class MyBufferReader {

MyBufferReader (MyTextReader text) {}
MyBufferReader (MyMediaReader media) {}
MyBufferReader (MyDataReader data) {}
}

但是上面的类拓展性很差。找到其参数的共同类型，通过多态的形式，可以提高拓展性

class MyBufferReader extends MyReader{
private MyReader r; //从继承变为了组成模式 装饰设计模式
MyBufferReader(MyReader r) {}
}

优化后的体系：
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader //增强上面三个。装饰模式比继承灵活，
避免继承体系的臃肿。降低类与类之间的耦合性

装饰类只能增强已有的对象，具备的功能是相同的。所以装饰类和被装饰类属于同一个体系

MyBuffereReader类： 自己写一个MyBuffereReader类，功能与BuffereReader相同

1. 1. classMyBufferedReader1extendsReader{
   2. privateReaderr;
   3. MyBufferedReader1(Readerr){
   4. this.r=r;
   5. }
   7. //一次读一行数据的方法
   8. publicStringmyReaderline()throwsIOException{
   9. //定义一个临时容器，原BufferReader封装的是字符数组。
   10. //为了演示方便。定义一个StringBuilder容器。最终要将数据变成字符串
   11. StringBuildersb=newStringBuilder();
   12. intch=0;
   13. while((ch=r.read())!=-1)
   14. {
   15. if(ch=='\r')
   16. continue;
   17. if(ch=='\n')//遇到换行符\n,返回字符串
   18. returnsb.toString();
   19. else
   20. sb.append((char)ch);
   21. }
   22. if(sb.length()!=0)//当最后一行不是以\n结束时候，这里需要判断
   23. returnsb.toString();
   24. returnnull;
   25. }
   26. /*
   27. 需要覆盖Reader中的抽象方法close()，read();
   28. */
   29. publicvoidclose()throwsIOException{
   30. r.close();
   31. }
   33. publicintread(char[]cbuf,intoff,intlen)throwsIOException{//覆盖read方法
   34. returnr.read(cbuf,off,len);
   35. }
   37. publicvoidmyClose()throwsIOException{
   38. r.close();
   39. }
   42. }