Java：IO流之字符流缓冲区详解

字符流缓冲区：

1、缓冲区的出现提高了对数据的读写效率；

2、对应类：BufferedWriter、BufferedReader；

3、缓冲区要结合流才可以使用；

4、在流的基础上对流的功能进行了增强。

 

注意：缓冲区的出现是为了提高流的操作效率而出现的，所以在创建缓冲区之前必须现有流对象。

 

java.io 

类 BufferedReader:读入缓冲区

 

构造方法摘要 

BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。 

BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。 

主要方法摘要 

 void close() 关闭该流并释放与之关联的所有资源。  

 int read() 作为一个整数（其范围从0到65535(0x00-0xffff)读入的字符，如果已到达流末尾，则返回 -1,读取单个字符。 

 int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。 

 String readLine() //包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null ,读取一个文本行。 

//例子1：

import java.io.*;
class BufferedReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个字符读入流对象，和目的地文件相关联.
        FileReader fr = new FileReader("F:\\myfile\\buf.txt");
 
        //为了提高字符读入流效率，加入了缓冲技术，只需要将被提高效率的流对象作为参数
        //传递给缓冲区的构造函数即可。此时，缓冲区和流相关联.
        BufferedReader buf = new BufferedReader(fr);
        int num = 0;
        String line = null;
 
        /*
        while((line = buf.readLine())!=null) //此过程中，读入缓冲区一行一行的读取数据，效率高
        {
            System.out.println(line);
        }
        */
 
        while((num = buf.read())!=-1)
        {
         System.out.print((char)num);
        }
 
       //其实关闭缓冲区，就是关闭缓冲区中的流对象
        buf.close();
    }
}

readLine方法的原理：尽管是读取一行获取多个字符，其实最终都是在硬盘上一个一个地读取字符。所以最终使用的还是read方法一次读一个的方法。

明白了BufferedReader类中特有方法readLine的原理后，

可以自定义一个类中包含一个功能和readLine一致的方法，

来模拟一个BufferedReader

(该代码中的思想体现了装饰设计模式)

//例子2：

import java.io.*;
class MyBufferedReader extends Reader
{
    private Reader r;
    MyBufferedReader(Reader r)
    {
        this.r = r;
    }
    //可以一次读一行的方法
    public String MyreadLine() throws IOException
    {
     //定义一个临时容器。原BufferedReader封装的是字符数组。
     //为了演示方便，定义一个StringBuilder容器，因为最终还是要将数据变为字符串
      StringBuilder sb = new StringBuilder();
      int ch = 0;
      while((ch=r.read())!=-1)
      {
        if(ch=='\r')
            continue;
        if(ch=='\n')
            return sb.toString();
        else
            sb.append((char)ch);
      }
      if(sb.length()!=0)   //出现读取一行数据到了缓冲区，但是该字符串后面没有'\n',可是仍要把它读取出来。
            return sb.toString();
      return null;
    }
    //覆盖Reader中的抽象方法
    public int read(char[] cbuf, int off, int len) throws IOException
    {
        return r.(cbuf,off,len);
    }
    public void close()throws IOException
    {
        r.close();
    }
 
    public void Myclose()throws IOException
    {
        r.close();
    }
}
//测试类
class MyBufferedReaderTest
{
    public static void main(String[] args)
    {
        FileReader fr = null;
        MyBufferedReader mybuf = null;
        String line = null;
        try
        {
            mybuf = new MyBufferedReader(new FileReader("F:\\myfile\\buf.txt"));
            while((line = mybuf.MyreadLine())!=null)
            {
                System.out.println(line);
            }
        }
        catch(IOException e)
        {
            throw new RuntimeException("读入流异常");
        }
        finally
        {
            try
            {
                mybuf.Myclose();
            }
            catch(IOException e)
            {
                throw new RuntimeException("关闭流异常");
            }
        }
    }
}

自定义一个统计行号的类:MyLineNumberReader,可以设置复制得到的文件内容的行号

//例子3：

import java.io.*;
/*
class MyLineNumberReader extends MyBufferedReader
{
    private int linenumber;
    MyLineNumberReader(Reader r)
    {
        super(r);
    }
    public void setLineNumber(int linenumber)
    {
        this.linenumber = linenumber;
    }
    public int getLineNumber()
    {
        return linenumber;
    }
    public String MyreadLine() throws IOException
    {
        linenumber++;//每读一行,行数就自加一次
        return super.MyreadLine();
    }
}
*/
class MyLineNumberReader
{
    private Reader r;
    private int linenumber;
    MyLineNumberReader(Reader r)
    {
        this.r = r;
    }
    public void setLineNumber(int linenumber)
    {
        this.linenumber = linenumber;
    }
    public int getLineNumber()
    {
        return linenumber;
    }
    public String MyreadLine() throws IOException
    {
        linenumber++;//每读一行,行数就自加一次
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        while((ch = r.read())!=-1)
        {
            if(ch=='\r')
                continue;
            if(ch=='\n')
                return sb.toString();
            else
                sb.append((char)ch);
        }
        if(sb.length()!=0)
            return sb.toString();
        return null;
    }
    public void Myclose() throws IOException
    {
        r.close();
    }
}
class MyLineNumberReaderDemo
{
    public static void main(String[] args)
    {
        FileReader fr = null;
        MyLineNumberReader myl = null;
        String str = null;
        try
        {
          fr  = new FileReader("MyBufferedReaderTest.java");
          myl = new MyLineNumberReader(fr);
          //myl.setLineNumber(100);  //设置第一行从101行开始
          while((str = myl.MyreadLine())!=null)
           {
             System.out.println(myl.getLineNumber()+":"+str);
           }
        }
        catch(IOException e)
        {
            System.out.println("流读入异常！");
        }
        finally
        {
            try
            {
                myl.Myclose();
            }
            catch(IOException e)
            {
                System.out.println("流关闭异常！");
            }
 
        }
    }
}

java.io 

类 BufferedWriter:写入缓冲区

构造方法摘要

BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。

BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

方法摘要

void close() 关闭此流，但要先刷新它。

void flush() 刷新该流的缓冲。

void newLine() 写入一个行分隔符。具有跨平台性，相当于windows系统的"\r\n"和linux系统的"\n"；

void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。

void write(int c) 写入单个字符。

void write(String s, int off, int len) 写入字符串的某一部分。

//例子4：

import java.io.*;
class BufferedWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个字符写入流对象，和目的地文件相关联.
        FileWriter fw = new FileWriter("F:\\myfile\\buf.txt");
 
        //为了提高字符写入流效率，加入了缓冲技术，只需要将被提高效率的流对象作为参数
        //传递给缓冲区的构造函数即可。此时，缓冲区和流相关联.
        BufferedWriter buf = new BufferedWriter(fw);
 
        buf.write("abcdefg");
        for(int i=0;i<3;i++)
        {
        buf.newLine();//换行
        buf.write("changjiang"+i);
        //记住，只要用到缓冲区，必须要刷新
        buf.flush();
        }
        //其实关闭缓冲区，就是关闭缓冲区中的流对象
        buf.close();
    }
}

使用字符流缓冲的一个综合实例如下：

要求：通过一个缓冲区复制一个.java文件

注意：readLine()方法返回的时候只返回回车符之前的数据内容，并不返回回车符。

//例子5： 没有异常处理时：

import java.io.*;
class BufferedCopyTest
{
    public static void main(String[] args)throws IOException
    {
        //创建一个读入流对象，与要被复制的文件相关联
        FileReader fr = new FileReader("BufferedReaderDemo.java");
        //创建一个写入流对象，与目的文件相关联
        FileWriter fw = new FileWriter("BufferedReaderDemo_Copy.txt");
 
        //创建一个读入缓冲区,与流对象相关联
        BufferedReader bufr = new BufferedReader(fr);
        //创建一个写入缓冲区,与流对象相关联
        BufferedWriter bufw = new BufferedWriter(fw);        
 
        //读取数据存入缓冲区中
        String line;
        while((line = bufr.readLine())!=null)
        {
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
        }
        bufw.close();
        bufr.close();
    }
}

//例子6： 有异常的处理时：

import java.io.*;
class BufferedCopyTest2
{
    public static void main(String[] args)
    {
        BufferedReader bufr = null;
        BufferedWriter bufw = null;
        try
        {
         bufr = new BufferedReader(new FileReader("BufferedReaderDemo.java"));
         bufw = new BufferedWriter(new FileWriter("BufferedReader_Copy.txt"));
         String line;
          while((line = bufr.readLine())!=null)
          {
            System.out.println(line);
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
          }
        }
        catch(IOException e)
        {
            throw new RuntimeException("读写入异常");
        }
        finally
        {
          try
          {
            if(bufr!=null)
               bufr.close();
          }
          catch(IOException e)
          {
            throw new RuntimeException("关闭流异常");
          }
          try
          {
            if(bufw!=null)
               bufw.close();
          }
          catch(IOException e)
          {
            throw new RuntimeException("关闭流异常");
          }
        }
    }
}