p5 节点流和处理流

节点流 和 处理流


目录

• 节点流 和 处理流
  
  
  
  • 
    
    
    
    • 一、基本介绍
      
    • 二、节点流 和 处理流 的区别和联系
      
    • 三、处理流的功能主要体现在以下两个方面：
      
    • 四、处理流 — BufferedReader和BufferedWriter
      
    
    
  
  

• 节点流和处理流一览图：
  

​                【图片来源】http://t.csdn.cn/d52a1
一、基本介绍

• 节点流：节点流可以从一个特定的数据源读写数据，如FIleReader、FileWriter
  
  
  
• 处理流：处理流（也叫包装流）是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter。使用了修饰器设计模式。就是面向对象的封装思想，消除不同数据之间的差异性，仅对外暴露接口。
  
  

二、节点流 和 处理流 的区别和联系

• 节点流是底层流/低级流，直接跟数据源相接。
  
• 处理流（包装流）包装结点流，即可以消除不同节点的实现差异，也可以提供更方便的方法来完成输入输出。
  
• 处理流（也叫包装流）对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连
  1. /**
  2. * @author
  3. * @version 1.0
  4. * 模拟修饰器设计模式
  5. */
  6. public class Test_ {
  7.     public static void main(String[] args) {
  8.         BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
  9.         bufferedReader_.readFiles(10);
  11.         //希望通过BufferedReader_ 多次读取字符串
  12.         BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
  13.         bufferedReader_1.readStrings(5);
  14.     }
  15. }
  16. abstract class Reader_ {
  17.     public void readFile_(){}
  18.     public void readString_(){}
  20.     //在Reader_抽象类，使用read方法统一管理
  21. //    public abstract void read();
  22.     //后面在调用时就，利于对象动态绑定机制，绑定到对应的实现子类即可。
  23. }
  25. // 模拟节点流
  26. class FileReader_ extends Reader_{
  27.     public void readFile_(){
  28.         System.out.println("对文件进行读取……");
  29.     }
  30. //    public void read(){
  31. //        System.out.println("对文件进行读取……");
  32. //    }
  33. }
  35. //模拟节点流
  36. class StringReader_ extends Reader_{
  37.     public void readString_(){
  38.         System.out.println("读取字符串……");
  39.     }
  40. //    public void read(){
  41. //        System.out.println("读取字符串……");
  42. //    }
  43. }
  46. //模拟处理流/包装流
  47. class BufferedReader_ extends Reader_{
  48.     //注意装饰器模式中，装饰类和被装饰类（约定俗成，而非必须）继承自同一个父类。
  49.     private Reader_ reader_;//属性是 Reader_
  51.     //接收Reader_子类对象
  52.     public BufferedReader_(Reader_ reader_) {
  53.         this.reader_ = reader_;
  54.     }
  56.     public void readFile(){
  57.         reader_.readFile_();
  58.     }
  60.     //让方法更灵活，多次读取文件，或者加缓冲char[]....
  61.     public void readFiles(int num){
  62.         for (int i = 0; i < num; i++) {
  63.             reader_.readFile_();
  64.         }
  65.     }
  67.     //扩展 readString，批量处理字符串数据
  68.     public void readStrings(int num){
  69.         for (int i = 0; i < num; i++) {
  70.             reader_.readString_();
  71.         }
  72.     }
  73. }

  复制代码

三、处理流的功能主要体现在以下两个方面：

• 性能的提高：主要以增加缓冲的方式来提高输入和输出的效率。
  
• 操作的便捷：处理流提供了一系列便捷的方法来一次输入输出大批量的数据就，使用更加灵活方便。
  

四、处理流 — BufferedReader和BufferedWriter

• BufferedReader 和 BufferedWriter属于字符流，是按照字符来读取数据的；
  
• 关闭处理流，只需关闭外层流即可，关闭外层流（包装流）时会自动关闭包装的节点流；
  
• BufferedReader 和 BufferedWriter 是安装字符操作，不要去操作二进制文件，可能造成文件损坏；
  

• BufferedReader
  
  
  
  
  
  • 构造方法摘要
    Constructor and DescriptionBufferedReader(Reader in)创建使用默认大小的输入缓冲区的缓冲字符输入流。BufferedReader(Reader in, int sz)创建使用指定大小的输入缓冲区的缓冲字符输入流。
    
  • 方法摘要
    Modifier and TypeMethod and Descriptionvoidclose()关闭流并释放与之相关联的任何系统资源。Streamlines()返回一个 Stream ，其元素是从这个 BufferedReader读取的行。voidmark(int readAheadLimit)标记流中的当前位置。booleanmarkSupported()告诉这个流是否支持mark（）操作。intread()读一个字符intread(char[] cbuf, int off, int len)将字符读入数组的一部分。StringreadLine()读一行文字。booleanready()告诉这个流是否准备好被读取。voidreset()将流重置为最近的标记。longskip(long n)跳过字符
    
  • 代码演示：
    1. import java.io.BufferedReader;
    2. import java.io.FileNotFoundException;
    3. import java.io.FileReader;
    4. import java.io.IOException;
    6. /**
    7. * @author
    8. * @version 1.0
    9. * 演示BufferedReader的使用
    10. */
    11. public class BufferedReader_ {
    12.     public static void main(String[] args) throws IOException {
    13.         String filePath = "e:\\a.java";
    14.         //创建BufferedReader对象
    15.         BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
    16.         //读取
    17.         String line;//按行读取，效率高
    18.         //1. bufferedReader.readLine() 是按行读取文件
    19.         //2. 当返回null时，表示文件读取完毕
    20.         while((line = bufferedReader.readLine()) != null){
    21.             System.out.println(line);
    22.         }
    24.         //关闭流
    25.         //这里注意，只需关闭 BufferedReader(外层流)，因为底层会自动的去关闭节点流 FileReader
    26.         /**
    27.          * public void close() throws IOException {
    28.          *         synchronized (lock) {
    29.          *             if (in == null)
    30.          *                 return;
    31.          *             try {
    32.          *                 in.close();
    33.          *             } finally {
    34.          *                 in = null;// in 就是我们传入的 new FileReader(filePath)，关闭了
    35.          *                 cb = null;
    36.          *             }
    37.          *         }
    38.          *     }
    39.          */
    40.         bufferedReader.close();
    41.     }
    42. }

    复制代码
  
  
  • BufferedWriter
    
    
    
    
    
    • 构造方法摘要
      Constructor and DescriptionBufferedWriter(Writer out)创建使用默认大小的输出缓冲区的缓冲字符输出流。BufferedWriter(Writer out, int sz)创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
      
    • 方法摘要
      Modifier and TypeMethod and Descriptionvoidclose()关闭流，先刷新。voidflush()刷新流。voidnewLine()写一行行分隔符。voidwrite(char[] cbuf, int off, int len)写入字符数组的一部分。voidwrite(int c)写一个字符voidwrite(String s, int off, int len)写一个字符串的一部分。
      
    • 代码演示：
      1. import java.io.BufferedWriter;
      2. import java.io.FileWriter;
      3. import java.io.IOException;
      5. public class BufferedWriter_ {
      6.     public static void main(String[] args) throws IOException {
      7.         String filePath = "e:\\BufferedWriter_.java";
      8.         BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath, true));
      9.         bufferedWriter.write("hello, 你好");
      10.         //插入一个和系统 相关的换行
      11.         bufferedWriter.newLine();
      12. //        bufferedWriter.write("\r\n");
      13.         bufferedWriter.write("hello, 你好");
      14.         //关闭外层流即可，传入的节点流会自动关闭
      15.         bufferedWriter.close();
      17.     }
      18. }

      复制代码
    
    
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！