javase_13(字符流)

 

IO(Input OutPut)流

IO流用来处理设备之间的数据传输

JAVA对数据的操作是通过流的方式

JAVA用于操作流的对象都在IO包中

流按操作对象分为两种: 字节流,字符流

流按流向分为: 输入流,输出流.

 其它的内容还是比较简单的,注意的是以下这几个自定义包装类:

实现1.

MyBufferedReader.class

 

package com.javami.kudy.Code13;
 import java.io.IOException;
 import java.io.Reader;  //读取字符流的抽象类
 import java.io.IOException;
 /*
  * 自定义MyBufferedReader包装Reader,提供了一个缓冲区的功能.提供了ReadLine功能.
  * 1.用一个次组合,拿到被包装的Reader对象
  * 2.定义一个字符数组作为缓冲区
  * 3.实现一个read方法,填充缓冲区,从缓冲区那里返回一个字符
  * 4.定义一个readLine方法,内部调用read方法,循环读取一行,进行返回
  * 5.定义一个close方法,关闭地底层所包装的流
  */
 public class MyBufferedReader  extends Reader{
     private Reader r;
     char[] buf = new char[1024];
     int len =0;
     int pos = 0;
     public MyBufferedReader(Reader r)
     {
         this.r = r;
     }
     /*
      * 实现read()方法,实现缓存的功能
      * 分析:
      * 1.当别人第一次调用该方法的时,一次性的去填充缓冲区
      * 2.定义一个len变量记住缓冲区的可用字符的数量
      * 3.将数组的第一个元素返回
      * 4.当别人第二次调用的时,将数组的二个元素返回
      * 5.每次返回元素 len --
      * 6.当len为零时,说明数组没有可用字符啦,那么这时候返回一个-1
      * 
      * 思路:
      * 1.定义两个成员变量,len记住可用字符数量,pos记住当前字符的角标
      * 2.判断len是否为0,如果为零要填充缓冲区.并且pos为零
      * 3.判断len,如果为-1,则返回-1
      * 4.将pos位置的元素返回.pos++
      */
     public int read() throws IOException
     {
         if(len ==0)
         {
             len = r.read(buf);
             pos = 0;
         }
         if(len==-1)
             return -1;
         len--;
         return buf[pos++];
     }
     
     /*
      * 实现readLine方法,实现读一行的功能,
      * 1.循环调用自己的方法的read方法,读取字符
      * 2.知道回车的字符,方法就结束
      */ 
     public String readLine() throws IOException
     {
         StringBuilder sb = new StringBuilder();
         int ch;
         while((ch=read())!=-1)
         {
             if(ch=='\r')
                 continue;
             if(ch=='\n')
                 break;
             sb.append((char)ch);
             if(ch==-1&&sb.length()==0)
                 return null;
         }
         return sb.toString(); //转换成字符串
     }
     @Override
     public void close() throws IOException {
         r.close();
     }
 
     @Override
     public int read(char[] cbuf, int off, int len) throws IOException {
         int count=0;
         for(int i=0; i<off+len; i++)
         {
             int ch = read();
             if(ch==-1)
                 break;
             count++;
             buf[i] = (char)ch;
         }
         return count;
     }
 
     
     
 }

 MyBufferedWriter.class  这个主要是写入

 

package com.javami.kudy.Code13;
 import java.io.IOException;
 import java.io.Writer;
 
 public class MyBufferedWriter  extends Writer{
     
     private Writer w;
     private char[] buf = new char[1024];
     private int pos = 0;
     
     public MyBufferedWriter(Writer w)
     {
         this.w = w;
     }
     /*
      * 定义Writer方法,实现写一个字符,实现缓存的功能
      * 1.定义一个变量pos记住当前的写入位置
      * 2.每次调用都使用这个方法都会传入一个字符,将字符缓存到数组pos位置里面去
      * 3.pos++
      * 4.每次上来就判断,如果pos =1024,刷新缓冲区 ,pos = 0
      */
     public void Writer(int ch)throws IOException
     {
         if(pos == 1024)
         {
             flush(); //刷新一下缓冲区.并且初始化为零
             pos = 0;
         }
         buf[pos++] = (char)ch;
     }
     @Override
     public void close() throws IOException {
         flush();
         w.close();
     }
 
     @Override
     public void flush() throws IOException { 
         w.write(buf,0,pos); //把buf0-pos位置的内容写入进去
     }
     public void writer(String data)throws IOException
     {
         char[] chars = data.toCharArray(); //转换成字符
         for(char c : chars)
             write(c);
     }
     public void newline()throws IOException
     {
         write("\r\n"); //所谓的换行就是一个
     }
     @Override
     public void write(char[] cbuf, int off, int len) throws IOException {
         for(int i=0; i<off+len; i++)
         {
             w.write(buf[i]);
         }
         
     }
 
 }

 由于每次都要关闭流啊~~无奈.只好使用一个类来实现它们

CloseUtil.class

 

package com.javami.kudy.Code13;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.Writer;
 public class CloseUtil {
     private CloseUtil(){}
     public static void close(Reader r,Writer w)throws IOException
     {
         try
         {
             if(r!=null)
                 r.close();
         }
         finally
         {
             if(w!=null)
             w.close();
         }
     }
 }

 

 

一个简单的测试类:

 

package com.javami.kudy.Code13;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 
 public abstract class BufferedTest {
 
     /**
      * @param args
      */
     public static void main(String[] args)
     {
         MyBufferedReader mr = null;
         MyBufferedWriter mw = null;
         try
         {
             mr = new MyBufferedReader(new FileReader("src/a.txt"));
             mw = new MyBufferedWriter(new FileWriter("src/b.txt"));
             int len;
             while((len=mr.read())!=-1)
             {
                 mw.Writer(len);
             }
         }
         catch(IOException e)
         {
             e.printStackTrace();
         }
         finally
         {
             try
             {
                 CloseUtil.close(mr, mw);
             }
             catch(IOException e)
             {
         }
         }
     }
 }

 

 

BufferedReader 与 BufferedWriter 的存储图:

 以上这几个都是比较难理解的..~~

 

加油啦..