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. class FireWriterDemo {
2. public static void main(String[] args) throws IOException {             //需要对IO异常进行处理
3. //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
4. //而且该文件会被创建到指定目录下。如果该目录有同名文件，那么该文件将被覆盖。
5. FileWriter fw = new FileWriter("F:\\1.txt");//目的是明确数据要存放的目的地。
6. //调用write的方法将字符串写到流中
7. fw.write("hello world!");
8. //刷新流对象缓冲中的数据，将数据刷到目的地中
9. fw.flush();
10. //关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候，必须close();
11. fw.write("first_test");
12. fw.close();
13. //flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。
14. }
15. }

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

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

1. class FileReaderDemo {
2. public static void main(String[] args) {
3. characters();
4. }
5. /*****************字符数组进行读取*********************/
6. private static void characters() {
7. try {
8. FileReader fr = new FileReader("Demo.txt");
9. char []  buf = new char[6];
10. //将Denmo中的文件读取到buf数组中。
11. int num = 0;
12. while((num = fr.read(buf))!=-1) {
13. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
14. sop(new String(buf,0,num));
15. }
16. sop(‘\n‘);
17. fr.close();
18. }
19. catch (IOException e) {
20. sop(e.toString());
21. }
22. }
23. /*****************单个字母读取*************************/
24. private static void singleReader() {
25. try {
26. //创建一个文件读取流对象，和指定名称的文件关联。
27. //要保证文件已经存在，否则会发生异常：FileNotFoundException
28. FileReader fr = new FileReader("Demo.txt");
29. //如何调用读取流对象的read方法？
30. //read()方法，一次读取一个字符，并且自动往下读。如果到达末尾则返回-1
31. int ch = 0;
32. while ((ch=fr.read())!=-1) {
33. sop((char)ch);
34. }
35. sop(‘\n‘);
36. fr.close();
37. /*int ch = fr.read();
38. sop("ch=" + (char)ch);
39. int ch2 = fr.read();
40. sop("ch2=" + (char)ch2);
41. //使用结束注意关闭流
42. fr.close(); */
43. }
44. catch (IOException e) {
45. sop(e.toString());
46. }
47. }
48. /**********************Println************************/
49. private static void sop(Object obj) {
50. System.out.print(obj);
51. }
52. }

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

1. import java.io.*;
2. class  FileWriterDemo3 {
3. public static void main(String[] args) {
4. try {
5. //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写
6. FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);
7. fw.write(" is charactor table?");
8. fw.close();
9. }
10. catch (IOException e) {
11. sop(e.toString());
12. }
13. }
14. /**********************Println************************/
15. private static void sop(Object obj)
16. {
17. System.out.println(obj);
18. }
19. }

练习：

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

思考：

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

步骤：

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

源码：

1. import java.io.*;
2. import java.util.Scanner;
3. class CopyText {
4. public static void main(String[] args) throws IOException {
5. sop("请输入要拷贝的文件的路径:");
6. Scanner in = new Scanner(System.in);
7. String source = in.next();
8. sop("请输入需要拷贝到那个位置的路径以及生成的文件名:");
9. String destination = in.next();
10. in.close();
11. CopyTextDemo(source,destination);
12. }
13. /*****************文件Copy*********************/
14. private static void CopyTextDemo(String source,String destination) {
15. try {
16. FileWriter fw = new FileWriter(destination);
17. FileReader fr = new FileReader(source);
18. char []  buf = new char[1024];
19. //将Denmo中的文件读取到buf数组中。
20. int num = 0;
21. while((num = fr.read(buf))!=-1) {
22. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
23. fw.write(new String(buf,0,num));
24. }
25. fr.close();
26. fw.close();
27. }
28. catch (IOException e) {
29. sop(e.toString());
30. }
31. }
32. /**********************Println************************/
33. private static void sop(Object obj) {
34. System.out.println(obj);
35. }
36. }

三、缓冲区

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

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

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

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

BufferedReader示例：

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

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

1. import java.io.*;
2. class BufferedReaderDemo {
3. public static void main(String[] args)  throws IOException {
4. //创建一个字符读取流流对象，和文件关联
5. FileReader rw = new FileReader("buf.txt");
6. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
7. BufferedReader brw = new BufferedReader(rw);
8. for(;;) {
9. String s = brw.readLine();
10. if(s==null) break;
11. System.out.println(s);
12. }
13. brw.close();//关闭输入流对象
14. }
15. }

BufferedWriter示例：

1. import java.io.*;
2. class BufferedWriterDemo {
3. public static void main(String[] args)  throws IOException {
4. //创建一个字符写入流对象
5. FileWriter fw = new FileWriter("buf.txt");
6. //为了提高字符写入效率，加入了缓冲技术。
7. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
8. BufferedWriter bfw = new BufferedWriter(fw);
9. //bfw.write("abc\r\nde");
10. //bfw.newLine();               这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符
11. //用到缓冲区就必须要刷新
12. for(int x = 1; x < 5; x++) {
13. bfw.write("abc");
14. bfw.newLine();                  //java提供了一个跨平台的换行符newLine();
15. bfw.flush();
16. }
17. bfw.flush();                                                //刷新缓冲区
18. bfw.close();                                                //关闭缓冲区，但是必须要先刷新
19. //注意，关闭缓冲区就是在关闭缓冲中的流对象
20. fw.close();                                                 //关闭输入流对象
21. }
22. }

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. class MyBufferedReader1  extends Reader{
2. private Reader r;
3. MyBufferedReader1(Reader r){
4. this.r  = r;
5. }
6. //一次读一行数据的方法
7. public String myReaderline()  throws IOException {
8. //定义一个临时容器，原BufferReader封装的是字符数组。
9. //为了演示方便。定义一个StringBuilder容器。最终要将数据变成字符串
10. StringBuilder sb = new StringBuilder();
11. int ch = 0;
12. while((ch = r.read()) != -1)
13. {
14. if(ch == ‘\r‘)
15. continue;
16. if(ch == ‘\n‘)                    //遇到换行符\n,返回字符串
17. return sb.toString();
18. else
19. sb.append((char)ch);
20. }
21. if(sb.length()!=0)                    //当最后一行不是以\n结束时候，这里需要判断
22. return sb.toString();
23. return null;
24. }
25. /*
26. 需要覆盖Reader中的抽象方法close()，read();
27. */
28. public void close()throws IOException {
29. r.close();
30. }
31. public int read(char[] cbuf,int off, int len)throws IOException {   //覆盖read方法
32. return r.read(cbuf,off,len);
33. }
34. public void myClose() throws IOException{
35. r.close();
36. }
37. }

原文地址：https://www.cnblogs.com/lswlsw/p/8412535.html