java学习笔记（9）——IO系统 缓冲流

字节缓冲流

字节缓冲输出流

java.io.BufferedOutputStream extends OutputStream

构造方法：

BufferedOutputStream(OutputStream out):建立一个新的缓冲输出流，将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size)：

参数：
    OutputStream out：字节输出流
    可传递FileOutputStream，缓冲流给FileOutputStream增长一个缓冲区，提升其写入效率
    
    int size：指定缓冲流内部缓冲区大小

使用步骤（！！！）

1. 建立FileOutputStream对象，构造方法中绑定输出目的地
2. 建立BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提升FileOutputStream对象效率
3. 使用BufferedOutputStream对象中write方法，将数据写入到内部缓冲区
4. 使用BufferedOutputStream对象中flush方法，把内部缓冲区的数据，刷新到文件中
5. 释放资源（先调用flush，再close）

public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("E:\\A JI\\program\\java\\g.txt");

        BufferedOutputStream bos = new BufferedOutputStream(fos);

        bos.write("把数据写入缓冲区".getBytes());
        bos.flush();
        bos.close();
    }

字节缓冲输入流

java.io.BufferedIntputStream extends InputStream

构造方法：

BufferedInputStream(InputStream in):建立一个新的缓冲输入流，将数据写入指定的底层输出流
BufferedInputStream(InputStream in, int size)：

参数：
    InputStream in：字节输出流
    可传递FileInputStream，缓冲流给FileInputStream增长一个缓冲区，提升其读取效率
    
    int size：指定缓冲流内部缓冲区大小

使用步骤（！！！）

1. 建立FileInputStream对象，构造方法中绑定要读取的数据源
2. 建立BufferedInputStream对象，构造方法中传递FileInputStream对象，提升FileInputStream对象读取效率
3. 使用BufferedInputStream对象中read方法，读取文件
4. 释放资源

public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("E:\\A JI\\program\\java\\g.txt");

        BufferedInputStream bis = new BufferedInputStream(fis);

        byte[] bytes = new byte[1024];
        int len = 0;
        while((len = bis.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }
        bis.close();
    }

字符缓冲流

字符缓冲输出流

java.io.BufferedWriter extends Writer

构造方法：

BufferedWriter(Writer out):建立一个新的缓冲字符输出流
BufferedWriter(Writer out, int size)：

参数：
    Writer out：字符输出流
    可传递FileWriter，缓冲流给FileWriter增长一个缓冲区，提升其写入效率
    
    int size：指定缓冲流内部缓冲区大小

特有成员方法：

void newLine()：写入一个行分隔符，会自动根据不一样的操做系统，获取不一样的航分隔符

使用步骤（！！！）

1. 建立字符缓冲输出流对象，构造方法中传递字符输出流
2. 使用BufferedWriter对象中write方法，将数据写入到内部缓冲区
3. 使用BufferedWriter对象中flush方法，把内部缓冲区的数据，刷新到文件中
4. 释放资源

public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\A JI\\program\\java\\g.txt"));

        for (int i = 0; i < 10; i++) {
            bw.write("123");
            bw.newLine();
        }

        bw.flush();
        bw.close();
    }

字符缓冲输入流

java.io.BufferedReader extends Reader

构造方法：

BufferedReader(Reader in):建立一个新的缓冲字符输入流
BufferedReader(Reader in, int size)：

参数：
    Reader in：字节输出流
    可传递FileReader，缓冲流给FileReader增长一个缓冲区，提升其读取效率
    
    int size：指定缓冲流内部缓冲区大小

特有的成员方法：

String readLine():读取数据的 行 终止符号

返回值：
    包括该行内容的字符串，不包含任何**行终止符**，若到达流末尾，**则返回null**（while条件此处有变化）

使用步骤（！！！）

1. 建立FileReader对象，构造方法中绑定要读取的数据源
2. 建立BufferedReader对象，构造方法中传递FileReader对象，提升FileReader对象读取效率
3. 使用BufferedReader对象中read/readLine方法，读取文件
4. 释放资源

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("E:\\A JI\\program\\java\\g.txt"));

        String line;
        while((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }

案例

文本排序！！！！

public static void main(String[] args) throws IOException {
        HashMap<String, String> map = new HashMap<>();

        BufferedReader br = new BufferedReader(new FileReader("E:\\A JI\\program\\java\\g.txt"));

        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\A JI\\program\\java\\out.txt"));
        //使用readLine，逐行读取文本
        String line;
        while((line = br.readLine()) != null) {
            //对文本进行切割，能够根据 . 来切割
            //  . 是一个转义字符，须要两个\表示一个普通的 .
            String[] arr = line.split("\\.");
            //将切割好的序号和文本内容存储到HashMap中，key序号有序，会自动排序
            map.put(arr[0], arr[1]);
        }

        //遍历HashMap，获取每个键值对
        for (String key : map.keySet()) {
            String value = map.get(key);
            //把每个键值对，拼接成一个文本行
            line = key + "." + value;
            //将拼接好的文本，写入文件
            bw.write(line);
            bw.newLine(); //写一个换行
        }

        bw.flush();
        bw.close();
    }