20:File类与IO流-----缓冲流

一:概述

缓冲流也叫高效流，是对4个基本的FileXxx流的增强，所以也是4个流，按照数据类型分类

字节缓冲流:BufferedInputStream,BufferOutputStream
字符缓冲流:BufferedReader,BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

二：BufferedOutputStream字节缓冲流

构造方法:

public BufferedInputStream(InputStream in);创建一个新的缓冲区输入流。
public BufferedOutputStream(OutputStream out);创建一个新的缓冲输出流。

package Demo06;

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

/*
    java.io.BufferedOutputStream extends OutputStream
    BufferedOutputStream:字节缓冲输出流
    继承自父类的共性方法：
    public void close();关闭输出流并释放与此流相关联的任何系统资源。
    public void flush90;刷新此输出流并强制任何缓冲的输出字节被写出。
    public void write(byte[] b);将b.length字节从指定的字节数组写入到此输出流。
    public void write(byte[] b,int off,int lne);从指定的字节数组写入len字节，从偏移量off开始输出此输出流流。
    public abstract void write(int b);将指定的字节输出流。

   构造方法:
        BufferedOutputStream(OutputStram out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
        BufferedOutputStream(OutputStream out,int size);创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
        参数：
            OutputStream out 字节输出流
            我们可以传递FileOutputStream ，缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写效率。
            int siez:指定缓冲流内部的缓冲区的大小，不指定默认。
   使用步骤:
        1:创建FileOutputStream对象，构造方法中绑定要输出的目的地。
        2:创建BufferedOutputStream对象，构造方法传递FileOutputStream对象，提高FileOutputStream的写效率。
        3:使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中。
        4:使用BufferedOutputStream对象中的方法flush,把内存缓冲区的数据，刷新到文件中。
        5;释放资源。
*/
public class Demo01BufferedOutputStream {
    public static void main(String[] args) throws IOException {
        //1:创建FileOutputStream对象，构造方法中绑定要输出的目的地。
        FileOutputStream fos =new FileOutputStream("C:\\Users\\Sky\\Desktop\\one.txt");
        // 2:创建BufferedOutputStream对象，构造方法传递FileOutputStream对象，提高FileOutputStream的写效率。
        BufferedOutputStream bos =new BufferedOutputStream(fos);
        //3:使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中。
        bos.write("我把数据写入内部缓冲区中".getBytes());
        // 4:使用BufferedOutputStream对象中的方法flush,把内存缓冲区的数据，刷新到文件中。
        bos.flush();;
        //5;释放资源。(会先调用flush方法刷新数据，第四步可省略).
        bos.close();
    }
}

三：BufferedInputStream字节缓冲流。

package Demo06;

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并保存其参数，即输入流
        参数：
            InputSTREAM in:字节输入流
                我们可以传递FileInputStream，缓冲区会给FileInputStream增加一个缓冲区，提高FileInputStream的读取效率

    使用步骤:
        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("C:\\Users\\Sky\\Desktop\\one.txt");
        // 2:创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高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));
        }
        //4:释放资源。
        bis.close();
    }
}

四：缓冲流的效率测试_复制文件

package Demo10;

import java.io.*;

/*
    文件复制练习：一读一写：
    明确：
        数据源:C:\Users\Sky\Desktop\one.txt
        数据的目的地C:\Users\Sky\Desktop\one\one.txt
    文件复制的步骤：
        1:创建字节缓冲输入流对象，构造方法传递字节输入流
        2:创建字节缓冲输出流对象，构造方法中传递字节输出流
        3:使用字节缓冲输入流对象中的方法read,读取文件。
        4:使用字节缓冲输出流中的方法write,把读取的数据写入到内部缓冲区中。
        5:释放资源（会先把缓冲区的数据，刷新到文件中。0
*/
public class Demo02CopyFile {
    public static void main(String[] args) throws IOException {
        long s =System.currentTimeMillis();//获取毫秒值
        // 1:创建字节缓冲输入流对象，构造方法传递字节输入流
        BufferedInputStream bis =new BufferedInputStream(new FileInputStream("C:\\Users\\Sky\\Desktop\\one.txt"));
        //2:创建字节缓冲输出流对象，构造方法中传递字节输出流
        BufferedOutputStream bos =new BufferedOutputStream(new FileOutputStream("C:\\Users\\Sky\\Desktop\\one\\one.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 Demo10;

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

/*
    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 lne);写入字符串的某一部分，off字符串的开始索引，len写的字符个数。
        void flush()刷新该流的缓冲。
        void close() 关闭此流，但是要先刷新它。

    构造方法：
        BufferedWriter(Writer out)
        创建一个使用默认大小的输出缓冲区字符输出流。
        BufferedWriter(writer out ,int size);
        创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
        参数:
                    Writer out:字符输出流。
                        我们可以传递FileWriter,缓冲流会把FileWriter增加一个缓冲区，提高FileWriter的写入效率。
                    int size:指定缓冲区的大小，不写默认大小。
       特有的成员方法；
            void newLine();写入一个行分隔符。会根据不同的操作系统，获取不同的行分隔符。
            换行：换行符号：
                window:\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("C:\\Users\\Sky\\Desktop\\one.txt"));
        //2:调用字符缓冲区中的方法write,把数据写入到内存缓冲区中。
        for (int i=0;i<10;i++){
            bw.write("helloworld");
            //bw.write("\r\n");
            bw.newLine();
        }
        // 3:调用字符缓冲区中的方法flush,把内存缓冲区的数据，刷新到文件中。
        bw.flush();;
        // 4:释放资源。
        bw.close();;
    }
}

六:BufferedReader字符缓冲输入流。

package Demo10;

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 size); 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
        参数：
            Reader in:字符输入流
                我们可以传递FileReader,缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取效率。
        特有的成员的方法：
            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("C:\\Users\\Sky\\Desktop\\one.txt"));
        //2:使用字符缓冲输入流对象中的方法read/readLine读取文本。
        //String line =br.readLine();
       // System.out.println(line);
        /*
            while的结束条件：读取到null结束。
        */
        String line;
        while ((line =br.readLine())!=null){
            System.out.println(line);
        }
        //3:释放资源。
        br.close();
    }
}

七：练习——对文本内容进行排序

package Demo10;

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

/*
    练习：
    对文本的内容进行排序
    按照（1,2,3...)顺序排序
   分析：
    1：创建一个HashMap集合对象，可以:存储每行文本的序号(1,2,3,...);value:存储每行的文本。
    2：创建字符缓冲输入流对象，构造方法绑定字符输入流。
    3：创建字符缓冲输出流对象，构造方法绑定字符输出流。
    4：使用字符缓冲流中的方法readLine,进行读取文本。
    5：对读取的文本进行切割。获取行中的序号和文本内容。
    6:把切割好的序号和文本内容存储到HashMap集合中，(key)序号是有效的，会自动排序1，2，3，...
    7:遍历HashMap集合，获取每一个键值对。
    8:把每一个键值对，转换为一个文本行。
    9：把拼接好的文本，使用字符缓冲输出流中的方法write,写入到文本中。
    10:释放资源。
*/
public class Demo01Test {
    public static void main(String[] args) throws IOException {
        //1：创建一个HashMap集合对象，可以:存储每行文本的序号(1,2,3,...);value:存储每行的文本。
        HashMap<String,String> map =new HashMap<>();
        //2：创建字符缓冲输入流对象，构造方法绑定字符输入流。
        BufferedReader br =new BufferedReader(new FileReader("C:\\Users\\Sky\\Desktop\\in.txt"));
        //3：创建字符缓冲输出流对象，构造方法绑定字符输出流。
        BufferedWriter bw =new BufferedWriter(new FileWriter("C:\\Users\\Sky\\Desktop\\out.txt"));
        //4：使用字符缓冲流中的方法readLine,进行读取文本。
        String line;
        while((line=br.readLine())!=null){
            //5：对读取的文本进行切割。获取行中的序号和文本内容。
            String[] arr =line.split("\\.");
            //6:把切割好的序号和文本内容存储到HashMap集合中，(key)序号是有效的，会自动排序1，2，3，...
            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.close();;
     br.close();;
    }
}