Buffered缓冲流

缓冲流【Buffered】

缓冲流我们可以理解为对原来的数组方式进行数据传输的一种增强
按照类型分为两种：

• 字符缓冲流：BufferedReader BufferedWriter
• 字节缓冲流：BufferedInputStream BufferedOutputStream
  缓冲流的基本原理，是在创建流对象的时候，会先创建一个内置的默认的大小的缓冲区数组，通过缓冲区来读写数据，减少系统的io操作的次数 ，减少开销，提高程序的读写效率。
  字节缓冲流：
  构造方法：
• public BufferedInputStream(InputStream input)：创建一个新的缓冲输入流
• public BufferedOutputStream(OutputStream output):创建一个新的缓冲输出流
  代码例子如下：

   public static void main(String[] args) throws IOException {
        //1、创建一个FileInputStream流对象，构造方法中绑定需要写入的数据源。
        FileInputStream fis = new FileInputStream("day29_IO//one.txt");
        //2、创建BufferedInputStream对象，构造方法中传递FileOutputStream流对象。
        BufferedInputStream bis = new BufferedInputStream(fis);
        //3、使用BufferedInputStream对象中的方法read，把数据读取到内存当中
        int len =  0;
        byte[] bytes = new byte[1024];
        while ((len = bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
        //4、释放资源
        bis.close();
    }
     public static void main(String[] args) throws IOException {
        //1、创建一个FileOutputStream流对象，构造方法中绑定需要写入的目的地。
        FileOutputStream fos = new FileOutputStream("day29_IO//one.txt");
        //2、创建BufferedOutputStream对象，构造方法中传递FileOutputStream流对象。
        BufferedOutputStream bus = new BufferedOutputStream(fos);
        //3、使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区中。
        bus.write("Hello World_Java".getBytes());
        // 4、使用BufferedOutputStream对象中的方法flush，把内存缓冲区中的数据刷新到目的地中。
        bus.flush();
        //释放资源
        bus.close();
    }

字符缓冲流
构造方法

• public BufferedWriter(Writer out):创建一个新的字符缓冲输出流
• public BufferedWriter(Reader in):创建一个新的字符缓冲输入流
  特有方法
• BufferedReader:public String readLine():读取整行的文本信息。
• BufferedWriter：public void newLine()：写入一行的行分隔符 ，由系统属性定义换行符号。
  代码例子如下：
  字符缓冲输入流代码演示：

public static void main(String[] args) throws IOException {
        //1. 创建一个字符缓冲输入流对象，构造方法中传递一个字符输入流
        final BufferedReader br = new BufferedReader(new FileReader("day29_IO\\abc.txt"));
        //2. 使用字符缓冲输入流对象中的read/readLine,读取文本信息
       /* String str = br.readLine();
        System.out.println(str);// data=小孙*/

        // 循环的结束条件  readLine()返回值是null
        String str = null;
        while ((str = br.readLine()) != null) {
            System.out.println(str);
        }
        // 3.释放资源。
        br.close();
  }

字符缓冲输出流代码演示：

public static void main(String[] args) throws IOException {
        //1.创建一个字符缓冲输出流对象，构造方法中传递一个字符输出流
        final BufferedWriter bw = new BufferedWriter(new FileWriter("day29_IO\\two.txt"));
        //2.调用字符缓冲输出流对象中的write，把数据写入到内存缓冲区中。
        bw.write("我今天学习了PS");
        bw.newLine();
        bw.write("3d软件mmd");
        bw.newLine();
        bw.write("c4d");
        //3.调用字符缓冲输出流对象中的flush方法，把内存缓冲区中的数据刷新到文件中。
        bw.flush();
        //4.释放资源。
        bw.close();
 }

例子：文件复制
代码如下演示：

 // 使用缓冲流完成文件复制
    public static void show02() throws IOException {
        // 获取开始的时间
        long start = System.currentTimeMillis();
        // 1.构建一个字节缓冲输入流
        final BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\admin\\Desktop\\3.gif"));
        // 2.构建一个字节缓冲输出流
        final BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\documents\\day29_IO\\3.gif"));
        // 3.使用字节缓冲输入流对象中的方法read(byte[] b)，读取文件
        byte[] bytes = new byte[1024];
        // 确定while循环结束的条件  read() == -1
        int len = 0;// 记录读取到的有效字节个数
        while ((len = bis.read(bytes)) != -1) {
            // 4. 把读取到的字节内容再次写入到目的地文件中，调用write
            bos.write(bytes, 0, len);
        }

        // 5.释放资源
        bos.close();
        bis.close();
        // 获取结束的时间
        long end = System.currentTimeMillis();
        System.out.println("文件复制耗费的时间为：" + (end - start) + "ms");// 文件复制耗费的时间为：91ms

    }