简述

  1. 节点流:可以从一个特定的数据源读写数据(FileRead等)。
  2. 处理流:在节点流的基础上，为程序提供更加强大的读写功能(BufferedReader等)，
  3. 可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。
  4. 例如处理流BufferedWrite(Writer w)可以封装Write的任意子类对象，更加灵活。
  5. 修饰器模式。
  6. 节点流:可以从一个特定的数据源读写数据(FileRead等)。
  7. 处理流:在节点流的基础上，为程序提供更加强大的读写功能(BufferedReader等)。

BufferedReader

  1. BufferedReader
  2. 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
  3. 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
  4. 构造方法:
  5. 1.BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
  6. 2.BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
  7. 成员方法:
  8. 1.read() 读取单个字符。
  9. 2.read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。
  10. 3.readLine()  读取一个文本行。
  11. 4.close() 关闭该流并释放与之关联的所有资源。
  1. public static void main(String[] args) {
  2.     BufferedReader br = null;
  3.     try {
  4.         String filePath = "C:\\Users\\ms674\\Desktop\\File\\file1.txt";
  5.         //创建BufferedReader对象封装FileReader对象实现增强
  6.         br = new BufferedReader(new FileReader(filePath));
  7.         //按行读取效率高
  8.         String line;
  9.         while ((line = br.readLine()) != null) {
  10.             System.out.println(line);
  11.         }
  12.         System.err.println("文件读取完毕...");
  13.     } catch (Exception e) {
  14.         e.printStackTrace();
  15.     } finally {
  16.         //只需要关闭处理流，底层会自动关闭节点流
  17.         if (br != null) {
  18.             try {
  19.                 br.close();
  20.             } catch (IOException e) {
  21.                 e.printStackTrace();
  22.             }
  23.         }
  24.     }
  25. }

BufferedWriter

  1. BufferedWriter
  2. 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
  3. 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
  4. 构造方法:
  5. 1.BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
  6. 2.BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
  7. 成员方法:
  8. 1.write(int c) 写入单个字符。
  9. 2.write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
  10. 3.write(String s, int off, int len) 写入字符串的某一部分。
  11. 4.newLine() 写入一个行分隔符。
  12. 5.flush() 刷新该流的缓冲，将缓冲区的内容写入本地磁盘。
  13. 6.close() 关闭此流，但要先刷新它。
  1. public static void main(String[] args) {
  2.     String filePath = "C:\\Users\\ms674\\Desktop\\File\\buffered-w1.txt";
  3.     BufferedWriter bw = null;
  4.     try {
  5.         bw = new BufferedWriter(new FileWriter(filePath,true));
  6.         bw.write("你好，Java！");
  7.         bw.newLine();//换行
  8.         bw.write("你好，Python！");
  9.     } catch (IOException e) {
  10.         e.printStackTrace();
  11.     } finally {
  12.         if (bw != null) {
  13.             try {
  14.                 bw.close();
  15.             } catch (IOException e) {
  16.                 e.printStackTrace();
  17.             }
  18.         }
  19.     }
  20. }

BufferedInputStream

  1. BufferedInputStream
  2. BufferedInputStream为另一个输入流添加一些功能，即缓冲输入以及支持mark和reset 方法的能力。
  3. 在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，
  4. 可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。
  5. 构造方法:
  6. 1.BufferedInputStream(InputStream in) 创建一个BufferedInputStream并保存其参数，封装增强in。
  7. 成员方法:
  8. 1.read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个byte 数组中。
  9. 2.close() 关闭此输入流并释放与该流关联的所有系统资源。

BufferedOutputStream

  1. BufferedOutputStream
  2. 该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，
  3. 而不必针对每次字节写入调用底层系统。
  4. 构造方法:
  5. 1.BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
  6. 成员方法:
  7. 1.write(int b) 将指定的字节写入此缓冲的输出流，b为字符ASCII码。
  8. 2.write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
  9. 3.flush() 刷新此缓冲的输出流，将缓冲区数据写入本地磁盘。
  10. 4.close() 关闭流，关闭前默认执行一次缓冲区刷新。

二进制文本拷贝案例

  1. public static void main(String[] args) {
  2.     //BufferedInputStream封装InputStream子类对象实现增强，会创建内部缓冲区数组
  3.     BufferedInputStream bis = null;
  4.     BufferedOutputStream bos = null;
  5.     try {
  6.         String filePath = "C:\\Users\\ms674\\Desktop\\File\\img1.png";
  7.         String copyPath = "C:\\Users\\ms674\\Desktop\\File\\DDD\\copy-img1.png";
  8.         bis = new BufferedInputStream(new FileInputStream(new File(filePath)));
  9.         bos = new BufferedOutputStream(new FileOutputStream(new File(copyPath)));
  10.         int len;
  11.         byte[] bs = new byte[1024];
  12.         while ((len = bis.read(bs)) != -1) {
  13.             bos.write(bs,0,len);
  14.         }
  15.         System.out.println("拷贝成功");
  16.     } catch (Exception e) {
  17.         e.printStackTrace();
  18.     } finally {
  19.         if (bos != null) {
  20.             try {
  21.                 bos.close();
  22.             } catch (IOException e) {
  23.                 e.printStackTrace();
  24.             }
  25.         }
  26.         if (bis != null) {
  27.             try {
  28.                 bis.close();
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.     }
  34. }