JAVA自学教程之IO流（三）：缓冲区2 & 装饰设计模式



JAVA自学教程之IO流（三）：缓冲区2 & 装饰设计模式。

一、模拟BufferedReader

自定义MyBuffereaReader

对于缓冲区而言，里面其实就是封装一个数组，对外提供方法对数组的操作，这些方法最终操作的都是数组的角标

原理：从源中取出数据存入缓冲区，再从缓冲区不断的取出数据，取完后，继续从源中继续取数据，进缓冲区，直至源中的数据取完，用-1做为结束标记

 

  1. import java.io.*;
  2. class MyBufferedReader {
  3.     private FileReader fr;
  5.     //定义数组作为缓冲区
  6.     private char[] ch = new char[1024];
  7.     //定义一个指针用于对数组的操作，当操作数组的最后一个元素后，指针归零
  8.     private int pos = 0;
  9.     //定义一个计数器，当缓冲区的数据减至0后，继续从源中取数据加到缓冲区中
  10.     private int count = 0;
  12.     MyBufferedReader(FileReader fr) {
  13.         this.fr = fr;
  14.     }
  15.     public int Myread() throws IOException{
  16.         //从源中获取一批数据到缓冲区中,先判断count是否是0
  17.         if(count==0) {
  18.             count = fr.read(ch);
  19.             pos = 0;
  20.         }
  21.             if (count<0)
  22.                 return -1;
  24.             char temp = ch[pos++];
  25.             count–;
  26.             return temp;
  27.     }
  28.     public String MyReadLine() throws IOException{
  30.         //将读取的数据存储到缓冲区中
  31.         StringBuilder sb = new StringBuilder();
  32.         int ch = 0;
  33.         while((ch = Myread())!=-1){
  35.             if(ch==’\r’)
  36.                 continue;
  37.             if(ch==’\n’)
  38.                 return sb.toString();
  40.             sb.append((char)ch);
  41.         }
  42.         if(sb.length()!=0)
  43.             return sb.toString();
  44.         return null;
  45.     }
  46.     public void myClose() throws IOException{
  47.         fr.close();
  48.     }
  49. }
  50. public class Main
  51. {
  52.     public static void main(String[] args) throws IOException {
  54.         FileReader fr = new FileReader(“ACM.txt”);
  55.         MyBufferedReader msb = new MyBufferedReader(fr);
  57.         String str = null;
  59.     while((str = msb.MyReadLine())!=null){
  61.             System.out.println(str);
  62.         }
  63.         msb.myClose();
  65.     }
  66. }

 

二、装饰设计模式

当对一组对象的功能进行增强时，就可以使用该模式进行问题的解决，上述的自定义MyBufferedReader类就是很好的体现，对于FileReader类比原来的功能简便，当然上述代码写的比较简单

 

  1. class Room{
  2.     public void show(){
  3.         System.out.println(“房子”);
  4.     }
  5. }
  6. class NewRoom
  7. {
  8.     private Room or;
  9.     public NewRoom(OldRoom or) {
  10.         // TODO Auto-generated constructor stub
  11.         this.or = or;
  12.     }
  13.     public void show(){
  14.         or.show();
  15.         System.out.println(“平房”);
  16.     }
  17. }

一定要避免的是修改源代码，当然继承也可以实现功能的增强。

 

但是继承的话，会让继承体系复杂且麻烦

 


装饰设计模式和继承的区别：

继承：如果为了增强功能，就要继续写子类，只是为了一个新的NewRoom，就要创建一个子类，NewRoom后出现别墅呢，又要创建子类，逐渐的，导致继承体系越来越臃肿

装饰设计模式：无论NewRoom还是别墅，都是Room的一种，都保持着房子的基本属性

所以，利用装饰设计模式，只需要把被装饰的对象传入即可，可以将缓冲技术单独抽取进行封装，要缓冲区谁将谁和缓冲相关联即可，这样的设计的相对体系会变的简单。

 

三、LineNumberReader

API文档解释：跟踪行号的缓冲字符输入流。此类定义了方法setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。

 

  1. import java.io.*;
  3. public class Main
  4. {
  5.     public static void main(String[] args) throws IOException {
  7.         FileReader fr = new FileReader(“ACM.txt”);
  8.         LineNumberReader lr = new LineNumberReader(fr);
  10.         String str = null;
  12.         lr.setLineNumber(10);//设置行号从10开始
  13.         while((str = lr.readLine())!=null){
  14.             System.out.println(str+” line : ”+lr.getLineNumber());
  15.         }
  16.         lr.close();
  17.     }
  18. }

此类用的地方不是很多，知道怎么用即可。

 

 

四、练习

一定要用字节流文件复制媒体文件

 

  1. import java.io.*;
  3. public class Main
  4. {
  5.     public static void main(String[] args) throws IOException {
  6.         //copy_mp3_1();
  7.         //copy_mp3_2();//开发建议使用这种
  8.         copy_mp3_3();
  9.     }
  11.     public static void copy_mp3_3() throws IOException {
  12.         // TODO Auto-generated method stub
  13.         FileInputStream fis = new FileInputStream(“D:\\盛夏光年.mp3″);
  14.         FileOutputStream fos = new FileOutputStream(“D:\\盛夏光年3.mp3″);
  16.         byte[] by = new byte[fis.available()];//局限：文件过大，就不行了
  18.         fis.read(by);
  19.         fos.write(by);
  21.         fos.close();
  22.         fis.close();
  23.     }
  25.     public static void copy_mp3_2() throws IOException {
  26.         // TODO Auto-generated method stub
  27.         FileInputStream fis = new FileInputStream(“D:\\盛夏光年.mp3″);
  28.         BufferedInputStream br = new BufferedInputStream(fis);
  30.         FileOutputStream fos = new FileOutputStream(“D:\\盛夏光年2.mp3″);
  31.         BufferedOutputStream bw = new BufferedOutputStream(fos);
  33.         int len = 0;
  34.         while((len = br.read())!=-1){
  35.                 bw.write(len);
  36.                 bw.flush();
  37.         }
  38.         br.close();
  39.         bw.close();
  40.     }
  42.     public static void copy_mp3_1() throws IOException {
  43.         // TODO Auto-generated method stub
  44.         FileInputStream fis = new FileInputStream(“D:\\盛夏光年.mp3″);
  45.         FileOutputStream fos = new FileOutputStream(“D:\\盛夏光年1.mp3″);
  47.         byte[] by = new byte[1024];//注意Mp3文件的字节数，这个数组越接近效率越块
  48.         int len = 0;
  49.         while((len = fis.read(by))!=-1){
  50.                 fos.write(len);
  51.                 fos.flush();
  52.         }
  53.         fos.close();
  54.         fis.close();
  55.     }
  56. }