缓冲流的了解

缓冲流：

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter

 

是包装流(处理流)的一种,它依赖于原始的输入输出流, 它令输入输出流具有1个缓冲区, 显著减少与外部设备的IO次数, 提高输入输出的效率，而且提供一些额外的方法。

缓冲区就是专门用于传递数据的一块内存。当写入数据时，程序将数据发往缓冲区，缓冲区满，系统再将数据发往相应的设备；当读取数据时，程序重缓冲区读取，缓冲区若空，系统将从相应的设备读取数据。

作用：提高了内存与外部设备之间的数据传输效率。

 

字节缓冲流：

BufferedInputStream：

public class BufferedInputStreamTest01 {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        //BufferedInputStream流的构造方法，要传一个是InputStream的节点流
        /* public BufferedInputStream(InputStream in) {
            this(in, DEFAULT_BUFFER_SIZE);
        }*/
        //FileInputStream extends InputStream
        //FileInputStream is a InputStream
        /*
        包装流：BufferedInputStream
        节点流：FileInputStream
         */
        try {
            //read()方法，读取文件单个字节数据
            bis = new BufferedInputStream(new FileInputStream("D:\\java\\temp02.txt"));
            System.out.println(bis.available());
            System.out.println(bis.read());

            //循环read()方法，读取文件全部数据
            //循环多次，每次获取一个字节
            bis = new BufferedInputStream(new FileInputStream("D:\\java\\temp02.txt"));
            int readData = 0;
            while ((readData = bis.read()) != -1){
                System.out.print(readData+" ");
            }

            //read(bytes)方法，把获取到的数据放到字节数组中，一次获取的长度是bytes.字节
            //循环多次，每次获取多个字节，完成文件的全部读取
            System.out.println();
            bis = new BufferedInputStream(new FileInputStream("D:\\java\\temp02.txt"));
            byte[] bytes = new byte[1024];
            int readCount = 0;
            while ((readCount = bis.read(bytes)) != -1){
                System.out.print(new String(bytes,0,readCount));
            }

            //available()方法获取文件的剩余未读的字节数readCount
            //设置字节数组的长度为readCount,一次把文件中未读的数据，读取出来，放到字节数组中
            //一次读取，没有循环
            System.out.println();
            bis = new BufferedInputStream(new FileInputStream("D:\\java\\temp02.txt"));
            readCount = bis.available();
            bytes = new byte[readCount];
            bis.read(bytes);
            System.out.print(new String(bytes,0,readCount));

            //跳过3个字节不输出
            System.out.println();
            bis = new BufferedInputStream(new FileInputStream("D:\\java\\temp02.txt"));
            bis.skip(3);
            readCount = bis.available();
            bytes = new byte[readCount];
            bis.read(bytes);
            System.out.print(new String(bytes,0,readCount));


        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

BufferedOutputStream：

public class BufferedOutputStreamTest01 {
    public static void main(String[] args) {
        BufferedOutputStream bos= null;
        try {

            //单独写一个字符a到文件中，覆盖原来的数据
            bos = new BufferedOutputStream(new FileOutputStream("D:\\java\\temp02.txt"));
            bos.write(97);

            //写一个字节数组，把字节数组的内容写到文件中(以追加的形式),这边会覆盖原来的97
            bos = new BufferedOutputStream(new FileOutputStream("D:\\java\\temp02.txt",true));
            byte[] bytes = new byte[]{98,99,100};
            bos.write(bytes);

            //指定字节数组中的字节写到文件中
            bos.write(bytes,0,1);

            //刷新
            bos.flush();


        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字符缓冲流：

BufferedReader：

public class BufferedReaderTest01 {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            //节点流：FileReader
            //包装流:BufferedReader
            FileReader reader = new FileReader("..\\..\\java\\temp.txt");
            //读第一行
            br = new BufferedReader(reader);
            String s = br.readLine();
            System.out.println(s);

            //读第二行
            String s1 = br.readLine();
            System.out.println(s1);

            //循环读，每次读一行。没有值得行，返回空
            br = new BufferedReader(new FileReader("..\\..\\java\\temp.txt"));
            s = null;
            while ((s = br.readLine()) != null){
                //读出来，不带换行符
                System.out.println(s);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

BufferedWriter ：

public class BufferedWriterTest01 {
    public static void main(String[] args) {
        FileWriter in = null;
        BufferedWriter writer = null;
        try {
            //覆盖写入
            in = new FileWriter("..\\..\\java\\writer.txt");
            writer = new BufferedWriter(in);
            writer.write("BufferedWriter流123");
            writer.flush();

            //追加写入
            in = new FileWriter("..\\..\\java\\writer.txt",true);
            writer = new BufferedWriter(in);
            writer.write("\n");
            writer.write("BufferedWriter流456");
            writer.flush();

            //字符数组写入
            char[] chars = "BufferedWriter流789".toCharArray();
            writer.write(10);//10是回车
            writer.write(chars);

            writer.write(10);
            writer.write(chars,14,1);//流

            //字符串写入
            writer.write(10);//10是回车
            writer.write("BufferedWriter流abc");

            writer.write(10);
            writer.write("abcdef",0,3);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(writer != null){
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}