/*
     处理流之一：缓冲流的使用

     1.缓冲流：
    BufferedInputStream
     BufferedOutputStream

    • BufferedReader
      BufferedWriter


       2.作用：提高流的读取、写入的速度
      提高读写速度的原因：内部提供了一个缓冲区

      * 3.处理流，就是“套接”__在已有的流的基础上
      *

    字节缓冲流

    1. package com.atguigu.java1;
    3. import org.junit.Test;
    5. import java.io.*;
    7. /**
    8.  * 处理流之一：缓冲流的使用
    9.  *
    10.  * 1.缓冲流：
    11.  * BufferedInputStream
    12.  * BufferedOutputStream
    13.  * BufferedReader
    14.  * BufferedWriter
    15.  *
    16.  * 2.作用：提高流的读取、写入的速度
    17.  *   提高读写速度的原因：内部提供了一个缓冲区
    18.  *
    19.  * 3.处理流，就是“套接”在已有的流的基础上
    20.  *
    21.  *
    22.  * @author Dxkstart
    23.  * @create 2021-05-30 14:29
    24.  */
    25. public class BufferedTest {
    28.     /*
    29.     实现非文本文件的复制
    31.      */
    33.     @Test
    34.     public void BufferedSreamTest(){
    36.         BufferedInputStream bis = null;
    37.         BufferedOutputStream bos = null;
    39.         try {
    40.             //1.造文件
    41.             File file1 = new File("爱丽丝1.jpg");
    42.             File file2 = new File("爱丽丝2.jpg");
    44.             //2.造流
    46.             //2.1 造节点流
    47.             FileInputStream fis = new FileInputStream(file1);
    48.             FileOutputStream fos = new FileOutputStream(file2);
    50.             //2.2 造缓冲流
    51.             bis = new BufferedInputStream(fis);
    52.             bos = new BufferedOutputStream(fos);
    55.             //3.复制的细节：读取、写入
    56.             byte[] buffer = new byte[10];
    57.             int len;
    58.             while((len = bis.read(buffer)) != -1){
    59.                 bos.write(buffer,0,len);
    60.             }
    61.         } catch (IOException e) {
    62.             e.printStackTrace();
    63.         } finally {
    64.             //4.关闭流资源
    65.             //要求：先关闭外层的流，再关闭内层的流
    66.             //说明：关闭外层的流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略
    67.             try {
    68.                 if(bis != null)
    69.                     bis.close();
    70.             } catch (IOException e) {
    71.                 e.printStackTrace();
    72.             }
    73.             try {
    74.                 if(bos != null)
    75.                     bos.close();
    76.             } catch (IOException e) {
    77.                 e.printStackTrace();
    78.             }
    80.         }
    81.     }
    84.     //实现文件复制的方法
    85.     public void copyFileWithBuffered(String srcPath,String destPath){
    87.         BufferedInputStream bis = null;
    88.         BufferedOutputStream bos = null;
    90.         try {
    91.             //1.造文件
    92.             File file1 = new File(srcPath);
    93.             File file2 = new File(destPath);
    95.             //2.造流
    97.             //2.1 造节点流
    98.             FileInputStream fis = new FileInputStream(file1);
    99.             FileOutputStream fos = new FileOutputStream(file2);
    101.             //2.2 造缓冲流
    102.             bis = new BufferedInputStream(fis);
    103.             bos = new BufferedOutputStream(fos);
    106.             //3.复制的细节：读取、写入
    107.             byte[] buffer = new byte[1024];
    108.             int len;
    109.             while((len = bis.read(buffer)) != -1){
    110.                 bos.write(buffer,0,len);
    111.             }
    112.         } catch (IOException e) {
    113.             e.printStackTrace();
    114.         } finally {
    115.             //4.关闭流资源
    116.             //要求：先关闭外层的流，再关闭内层的流
    117.             //说明：关闭外层的流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略
    118.             try {
    119.                 if(bis != null)
    120.                     bis.close();
    121.             } catch (IOException e) {
    122.                 e.printStackTrace();
    123.             }
    124.             try {
    125.                 if(bos != null)
    126.                     bos.close();
    127.             } catch (IOException e) {
    128.                 e.printStackTrace();
    129.             }
    131.         }
    133.     }
    135.     @Test
    136.     public void testcopyFileWithBuffered(){
    138.         long start = System.currentTimeMillis();
    140.         String srcPath = "C:\\Users\\Administrator\\Desktop\\IO\\视频\\\\01.mp4";
    141.         String destPath = "C:\\Users\\Administrator\\Desktop\\IO\\视频\\\\03.mp4";
    142.         copyFileWithBuffered(srcPath,destPath);
    144.         long end = System.currentTimeMillis();
    146.         System.out.println("复制操作花费的时间为：" + (end - start));//3460ms,917ms
    149.     }
    153. }

    字符缓冲流

    1. package com.atguigu.java1;
    3. import org.junit.Test;
    5. import java.io.*;
    7. /**
    8.  * @author Dxkstart
    9.  * @create 2021-05-30 15:17
    10.  */
    11. public class BufferedTest2 {
    13.     /*
    14.     使用BufferedReader和BufferedWriter实现文本文件的复制
    17.      */
    18.     @Test
    19.     public void testBufferesReaderBufferedWriter(){
    20.         BufferedReader br = null;
    21.         BufferedWriter bw = null;
    23.         try {
    24.             //1\2.1\2.2步
    25.             br = new BufferedReader(new FileReader(new File("C:\\Users\\Administrator\\Desktop\\IO\\hi.txt")));
    26.             bw = new BufferedWriter(new FileWriter(new File("C:\\Users\\Administrator\\Desktop\\IO\\hi2.txt")));
    28.             //读写操作
    29.             //方式一：
    30. //            char[] buffer = new char[1024];
    31. //            int len;
    32. //            while((len = br.read(buffer)) != -1){
    33. //                bw.write(buffer,0,len);
    34. //    //            bw.flush();
    35. //            }
    38.             //方式二：
    39.             String data;
    40.             while((data = br.readLine()) != null){
    41.                 //方法一：
    42.                 bw.write(data + "\n");//data中不包含换行符
    43. //                //方法二：
    44. //                bw.write(data);//data中不包含换行符
    45. //                bw.newLine();//提供换行操作
    47.             }
    49.         } catch (IOException e) {
    50.             e.printStackTrace();
    51.         } finally {
    52.             //关闭资源
    53.             try {
    54.                 if(br != null) {
    55.                     br.close();
    56.                 }
    57.             } catch (IOException e) {
    58.                 e.printStackTrace();
    59.             }
    60.             try {
    61.                 if(bw != null) {
    62.                     bw.close();
    63.                 }
    64.             } catch (IOException e) {
    65.                 e.printStackTrace();
    66.             }
    68.         }
    69.     }
    70. }