Java-缓冲流

字节缓冲流：
BufferedOutputStream:字节缓冲输出流

package dl.java.day27.Demo01;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
    java.io.BufferedOutputStream extends OutputStream
    BufferedOutputStream:字节缓冲输出流

    继承父类的共性成员方法：
        public void close():关闭此输出流并释放与此流相关联的任何系统资源
        public void flush()：刷新此输出流并强制任何缓冲的输出字节被重写
        public void write(byte[] b)：将b.length字节从指定的字节数组写入此输出流
        public void write(byte[] b,int off, int len)：从指定的字节数组写入len字节，从偏移量off开始输出到此输出流
        public abstract void write(int b)：将指定字节的输出流
    构造方法：
        BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
        BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
        参数：
            OutputStream：字节输出流
                可以传递FileOutputStream，缓冲区会给FileOutputStream增加一个缓冲区，提高FileOutputStream写入效率
            int size：指定缓冲流内部缓冲区的大小，不指定就是默认
    使用步骤：重点
        1.创建一个FileOutputStream对象，构造方法绑定目的地
        2.创建缓冲流BufferedOutputStream对象，构造方法传递FileOutputStream对象，提高FileOutputStream效率
        3.使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区
        4.使用BufferedOutputStream对象中的方法flush，把内部缓冲区的数据刷新到文件中
        5.释放资源(会先调用flush方法，第四步可省略)
 */
public class Demo01BufferedOutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象，构造方法绑定目的地
        FileOutputStream fos = new FileOutputStream("E:\\java\\java_project\\day11-code\\src\\dl\\java\\day27\\a.txt");
        // 2.创建缓冲流BufferedOutputStream对象，构造方法传递FileOutputStream对象
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //3.使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区
        bos.write("把数据写入内部缓冲区".getBytes());
        //4.使用BufferedOutputStream对象中的方法flush，把内部缓冲区的数据刷新到文件中
        //bos.flush();
        //5.释放资源(会先调用flush方法，第四步可省略)
        bos.close();
    }
}

字节缓冲输入流：BufferedInputStream

package dl.java.day27.Demo01;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

/*
    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：字节输入流
                传递FileInputStream，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream读取效率
            int size：指定缓冲流内部缓冲区的大小，不指定就是默认
    使用步骤：重点
        1.创建一个FileInputStream对象，构造方法绑定目的地
        2.创建BufferedInputStream对象，构造方法传递FileInputStream对象，提高FileInputStream效率
        3.使用BufferedInputStream对象中的方法read，读取文件
        4.释放资源
 */
public class Demo02BufferedInputStream {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileInputStream对象，构造方法绑定目的地
        FileInputStream fis = new FileInputStream("E:\\java\\java_project\\day11-code\\src\\dl\\java\\day27\\a.txt");
        //2.创建BufferedInputStream对象，构造方法传递FileInputStream对象
        BufferedInputStream bis = new BufferedInputStream(fis);
        //3.使用BufferedInputStream对象中的方法read，读取文件
        //int read()从输入流中读取数据的下一个字节
        /*int len = 0;
        while ((len = bis.read())!=-1){
            System.out.println(len);
        }*/

        //int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
        byte[] bytes = new byte[1024];//存储每次读取的数据
        int len  = 0;
            while ((len = bis.read(bytes))!=-1){
                System.out.println(new String(bytes,0,len));
            }

        bis.close();
    }
}

缓冲流的效率测试–复制文件

package dl.java.day27.Demo02;

import java.io.*;

/*
    文件复制：一读一写
        明确：
            数据源
            目的地
    文件复制步骤：
        1.创建字节缓冲输入流对象，构造方法中传递字节输入流
        2.创建字节缓冲输出流对象，构造方法中传递字节输出流
        3.使用字节缓冲输入流对象中的方法read，读取文件
        4.使用字节缓冲输出流对象中的文件write，把读取的文件写入到内部缓冲区中
        5.释放资源(会先把缓冲区中的数据，刷新到文件中)
 */
public class Demo02CopyFile {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();

        //1.创建字节缓冲输入流对象，构造方法中传递字节输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\java\\java_project\\day11-code\\src\\dl\\java\\day27\\a.txt"));
        //2.创建字节缓冲输出流对象，构造方法中传递字节输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("e:\\a.txt"));
        //3.使用字节缓冲输入流对象中的方法read，读取文件
        //一次读取一个字节写入一个字节的方式
        /*int len = 0;
        while ((len = bis.read())!=-1){
            bos.write(len);
        }*/

        //使用数组缓冲读取多个字节，写入多个字节
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }

        bos.close();
        bis.close();

        long e = System.currentTimeMillis();
        System.out.println("复制文件耗时："+(e-s)+"毫秒");
    }
}

字符缓冲流
BufferedWriter字符缓冲输出流

package dl.java.day27.Demo01;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/*
    java.io.BufferedWriter extends Writer
    BufferedWriter:字符缓冲输出流

    继承父类的共性成员方法：
        void write(int c) 写入一个字符
        void writer(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 size：指定缓冲区的大小
    特有的成员方法：
        void newLine() 写入一个行分隔符，会根据不同的操作系统，获取不同的行分隔符
        换行：
            Windows:\r\n
            Linux:/n
            Mac:/r
    使用步骤：
        1.创建字符缓冲输出流对象，构造方法传递字符输出流
        2.调用字符缓冲输出流中的方法write，把数据写入内存缓冲区中
        3.调用字符缓冲输出流中的方法flush，把内存缓冲区中的数据刷新到文件中
        4.释放资源
 */
public class Demo03BufferedWriter {
    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输出流对象，构造方法传递字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\java\\java_project\\day11-code\\src\\dl\\java\\day27\\b.txt"));
        //2.调用字符缓冲输出流中的方法write，把数据写入内存缓冲区中
        for (int i = 0; i < 10; i++) {
            bw.write("张三");
            //bw.write("\r\n");
            bw.newLine();
        }
        //3.调用字符缓冲输出流中的方法flush，把内存缓冲区中的数据刷新到文件中
        bw.flush();
        //4.释放资源
        bw.close();
    }
}

字符缓冲输入流：BufferedReader

package dl.java.day27.Demo01;

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

/*
    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读取效率
            int size：指定缓冲区的大小
    特有成员方法：
        String readLine() 读取一个文本行 读取一行数据
            行的终止符号：换行 \n，  回车 \r ，回车后跟着换行  \r\n
        返回值:
            包含改行内容的字符串，不包含任何终止符，如果已达到流末尾，则会返回null
    使用步骤：
        1.创建字符缓冲输入流对象，构造方法中传递字符输入流
        2.使用字符缓冲输入流中的方法read/readLine，读取文本
        3.释放资源
 */
public class Demo04BufferedReader {
    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输入流对象，构造方法中传递字符输入流
        BufferedReader br = new BufferedReader(new FileReader("E:\\java\\java_project\\day11-code\\src\\dl\\java\\day27\\b.txt"));
        //2.使用字符缓冲输入流中的方法read/readLine，读取文本
        /*String line = br.readLine();
        System.out.println(line);*/

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

        //3.释放资源
        br.close();
    }
}

练习：文本排序

package dl.java.day27.Demo01;

import java.io.*;
import java.util.HashMap;

/*
    练习：
        对文本的内容进行排序
        按照(1,2,...)排序
    分析：
        1.创建一个HashMap集合对象，可以：存储每行文本的序号；value存储每行的文本
        2.创建字符缓冲输入流对象，构造方法中用字符输入流
        3.创建字符缓冲输出流对象，构造方法中用字符输出流
        4.使用字符缓冲输入流中的方法readLine，逐行读取文本
        5.对读取到的文本进行切割，获取行中的序号和文本的内容
        6.把切割好的序号和文本内容存储到HashMap集合中(key序号是有序的，会自动排序)
        7.遍历HashMap集合，获取每一个键值对
        8.把每一个键值对拼接为一个文本行
        9.把拼接好的文本行，使用字符缓冲流中的方法write，写入到文件中
        10.释放资源
 */
public class Demo05Text {
    public static void main(String[] args) throws IOException {
        //1.创建一个HashMap集合对象，可以：存储每行文本的序号；value存储每行的文本
        HashMap<String,String> map = new HashMap<>();
        //2.创建字符缓冲输入流对象，构造方法中用字符输入流
        BufferedReader br = new BufferedReader(new FileReader("E:\\java\\java_project\\day11-code\\src\\dl\\java\\day27\\c.txt"));
        //3.创建字符缓冲输出流对象，构造方法中用字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\java\\java_project\\day11-code\\src\\dl\\java\\day27\\out.txt"));
        //4.使用字符缓冲输入流中的方法readLine，逐行读取文本
        String line;
        while ((line = br.readLine())!=null){
            //5.对读取到的文本进行切割，获取行中的序号和文本的内容
            String[] arr = line.split("\\.");
            //6.把切割好的序号和文本内容存储到HashMap集合中(key序号是有序的，会自动排序)
            map.put(arr[0],arr[1]);
        }
        //7.遍历HashMap集合，获取每一个键值对
        for (String key: map.keySet()){
            String value = map.get(key);
            //8.把每一个键值对拼接为一个文本行
            line = key+"."+value;
            // 9.把拼接好的文本行，使用字符缓冲流中的方法write，写入到文件中
            bw.write(line);
            bw.newLine();//写换行
        }
        //10.释放资源
        bw.close();
        br.close();
    }
}