Java基础IO之二字符流缓冲区类

字符流缓冲区

字符流的缓冲区:

BufferedWriter 写

BufferedReader 读

高效的字符读写

缓冲区字符流实例

1.BufferedWriter 操作

public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        //1.创建流对象
        FileWriter fw = new FileWriter("demo.txt");
        //2.创建字符流缓冲区
        BufferedWriter bw = new BufferedWriter(fw);
        //3.使用缓冲区的方法
        bw.write("helloworld");
        bw.newLine(); //创建一个新行 其实就是\r\n ;linux平台:\n
        bw.write("this is my bufferedWriter");
        //4.刷新
        bw.flush();
        //5.关闭流 内部调用了fw.close() 所以关闭缓冲区的流
        bw.close();
    }
}

2.BufferedReader 操作

public class BufferedReaderDemo {
    public static void main(String[] args) throws Exception {
        //1.创建流对象
        FileReader fr = new FileReader("demo.txt");
        //2.创建读取缓冲区对象
        BufferedReader br = new BufferedReader(fr);
        String res;
        while((res=br.readLine())!=null){
            System.out.println(res);
        }
        br.close();
    }
}

3.字符流缓冲区原理

缓冲区是用来增加基本字符流;优化读写操作,提升性能

4.使用缓冲区复制文本文件

public class BufferedReaderWriterDemo {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("demo.txt"));
            bw = new BufferedWriter(new FileWriter("demo1.txt"));
            String line;
            while((line=br.readLine())!=null){
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(bw!=null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

自定义缓冲区

1.自定义读取缓冲区

public class MyBufferedReader {
    //1.获取被缓冲的对象类
    private Reader reader;
    //2.缓冲区的默认大小
    private char[] buf = new char[1024];
    //4.用于记录存储到缓冲区中字符个数的变量
    private int count;
    //5.定时用于操作数组元素的角标
    private int pos = 0;
    public MyBufferedReader(Reader reader) {
        this.reader = reader;
    }
    //3.实现自定义read方法
    //先通过具体的流对象read方法,从目的中读取一批数据到缓冲区中
    public int read() throws IOException {
        //一次从磁盘中读取一批数据,当count为0时再从磁盘中读取一批数据
        if (count == 0) {
            count = reader.read(buf);
            pos = 0;
        }
        if (count < 0)
            return -1;
        count--;
        return buf[pos++];
    }
    //6.关闭缓冲区
    public void close() throws IOException {
        reader.close();
    }
    //7.自定义读取一行方法
    //通过read方法从缓冲区中读取字符,并进行存储
    //当读取的字符是换行符时,将存储的数据作为字符串返回
    public String readLine() throws IOException {
        StringBuffer sb = new StringBuffer();
        int ch = 0;
        while ((ch = reader.read()) != -1) {
            if (ch == '\r')
                continue;
            if (ch == '\n')
                return sb.toString();
            sb.append((char) ch);
        }
        if(sb.length()>0)
            return sb.toString();
        return null;
    }
}

2.使用自定义缓冲区

public class MyBufferedReaderMain {
    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("demo.txt");
        MyBufferedReader mbr = new MyBufferedReader(fr);
        //read(mbr);
        readLine(mbr);
        mbr.close();
    }
    private static void read(MyBufferedReader mbr) throws IOException {
        int ch;
        while((ch=mbr.read())!=-1){
            System.out.print((char)ch);
        }
        System.out.println();
    }
    private static void readLine(MyBufferedReader mbr) throws IOException {
        String line;
        while((line=mbr.readLine())!=null){
            System.out.println(line);
        }
    }
}

缓冲区内部实现的方式就是将数据通过read(char[] buf)一次读取一批,从而提升性能!