缓冲流

缓冲流原理

缓冲流也叫高效刘，是对4个基本的FileXxx流的增强，所以也是4个流，按照数据类型分类：
字节缓冲流：BufferedInputStream，BufferedOutputStream
字符缓冲流：BufferedReader，BufferedWriter
缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

 

传统的字节输入流读取文件的时候，会一个一个字节的读取，然后在一个一个的返回。
使用缓冲区后输入的时候是一个一个输入的，但是返回的时候是返回一个缓冲区数组。

BufferedOutputStream字节缓冲输出流

/*使用步骤
 创建FileOutputStram对象，构造方法中绑定要输出的文件夹
 创建BufferedOutputSteam对象，构造方法中传递FileOutputStream对象，提高FileOuptStram对象效率
 使用BufferedOutputSteam对象中的方法write，把数据写到内部缓冲区中
 使用BufferedOutputSteam对象中的方法flush，把内部缓冲区中的数据，刷新到文件中
 释放资源（释放资源会先调用flush方法，所以第四步可以省略）
*/
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoBufferedOutputStream{
    public static void main(String[] args) throws IOException{
        FileOutputStream fos = new FileOutputStream("1.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write("我写入了数据".getBytes());//这里如果不关闭或者刷新的话，不会把数据保存到文件中，而是保存在缓冲区中会随着程序的结束而消失。
        bos.flush();
        bos.close();       
    }
}

 BufferedInputStream字节缓冲输入流

/*
java.io.BufferedInputStream extends InputStream
BufferedInputStream 字节缓冲输入流
继承自来自父类的成员方法
    int read()从输入流中读取数据的下一个字节
    int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数据b中
    void close() 关闭此输入流并释放与该关联的所有系统资源

构造方法
    BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流in，以便以后使用
    BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流in，以便以后使用
    
    参数
        InputStream in  字节输入流
            我们可以传递FileInputStream，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream的读取效率
        int size：指定缓冲流内部缓冲区的大小，不指定默认
使用步骤
    创建FileInputStream对象，构造方法中绑定要读取的数据流、
    创建BufferedInputerStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象的读取效率
    使用BufferedInputStream对象中方法read读取文件
    释放资源
*/

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;


public class Demo02BufferedInputStream{
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("1.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        int len = 0;  //记录每次读取到的字节
        byte [] bytes = new byte[1024];//储存每次读取的数据
        //单个字节读取
        // while ((len = bis.read())!=-1){
        //     System.out.println(len);
        // }
        //多字节读取
        while((len = bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
        bis.close();
    }
}

 BufferedWriter 字符缓冲输出流

/*
字符缓冲流
java.io.BufferedWriter extends writer
BufferedWriter: 字符缓冲输入流
继承自父类的共性成员方法
    void write(int c) 写入单个字符
    void write(char[] cbuf)写入字符数组
    abstract void write(char[] cbuf, int off ,int len)写入字符数组的某一部分，off数组的开始索引，len写的字符个数
    void write(String str)写入字符串
    void write(String str, int off ,int len) 写入字符串的某一部分，off字符串的开始索引，len写的字符个数
    void flush()刷新该流的缓冲
    void close()关闭此流
    
构造方法
    BufferedWriter(Writer out)  创建一个使用默认大小输出缓冲区的缓冲字符输出流
    BufferedWriter(Writer out ,int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
    参数：
        Writer out:字符输出流
            我们可以传递FileWriter，缓冲流会给FileWriter增加一个缓冲区，提高FileWriter的写入效率
        int sz:指定缓冲区的大小，不写默认大小
特有的成员方法：
    void newLine()  写入一个行分隔符，会根据不同的操作系统，获取不同的行分隔符
使用步骤：
    创建字符缓冲输出流对象，构造方法中传递字符输出流
    调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区中
    调用字符缓冲输出流中的方法flush，把内存缓冲区的数据，刷新到文件中
    释放资源
 */
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Demo03BufferedWriter{
    public static void main(String[] args) throws IOException{
        BufferedWriter bw = new BufferedWriter(new FileWriter("1.txt"));
        for (int i =0;i<10;i++){//循环写十次小鬼Ghost，写入到1.txt文件中
            bw.write("小鬼Ghost");
            bw.newLine();//换行
        }
        bw.flush();
        bw.close();
    }
}

BufferedReader 字符缓冲输入流

/*
java.io.BufferedReader extends Reader
继承自父类的共性成员方法：
    int read() 读取单个字符并返回。
    int read(char[] cbuf) 一次读取多个字符，将字符读入数组
    void close()  关闭改流并释放与之相关连的所有资源

    构造方法：
    BufferedReader(Reader in)   创建一个使用默认大小输入缓冲区的缓冲字符输入流。
    BufferedReader(Reader in ,int sz)  创建一个使用指定大小输入缓冲区的缓冲字符输入流
    参数：
        Reader in: 字符输入流
            我们可以传递FileReader，缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取效率
    
    特有的成员方法：
        String readLine() 读取一个文本行，读取一行数据
            行的终止符号：通过下列字符之一都可认为某行已终止：换行('\n')、回车('\r')或回车后直接跟着换行(\r\n)。
        返回值
            包含该行内容的字符串，不包含任何行终止符，如果已经到达流末尾，则返回null
        抛出
            IOException - 如果发生I/O错误
    
    使用步骤
        创建字符缓冲输入流对象，构造方法中传递字符输入流
        使用字符缓冲输入流对象中的方法read/readLine 读取文本
        释放资源
        
*/


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Demo04BufferedReader {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new FileReader("1.txt"));

        String line;
        while((line = br.readLine()) != null) {
            System.out.println(line);//如果不使用循环的话，只会读取一行的信息，所以这里使用while循环
        }
        br.close();
    }
    
}