day17-缓冲流&转换流&序列化流&打印流&Properties（一）

1. 【理解】什么是缓冲流
2. 【掌握】缓冲流的使用
3. 【理解】转换流
4. 【理解】序列化流
5. 【理解】打印流
6. 【掌握】Properties集合的使用

缓冲流,也叫高效流，是对4个基本的`FileXxx` 流的增强，所以也是4个流，按照数据类型分类
通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
这种类被称为：缓冲区类(高效类)
写数据：BufferedOutputStream
读数据：BufferedInputStream
构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。

public class BufferedDemo {
        public static void main(String[] args) throws IOException {
        //相当于把字节流进行了一次装
        //FileOutputStream fos = new FileOutputStream("a.txt");
        //BufferedOutputStream bos = new BufferedOutputStream(fos);
        //简单写法
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
        //也可以进行追加
        //BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt",true));
        //写一个字节
        bos.write(97);
        //写一个字节数组
        byte[] by = {97,98,99};
        bos.write(by);
        bos.write("hello".getBytes());
        //指定写一个字节
        bos.write(by,1,2);
        //关闭
        bos.close();
    }
}

public class BufferedDemo {
    public static void main(String[] args) throws IOException {
        //字节输入缓冲流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
        //一次读出一个字节
        int read = bis.read();
        System.out.println((char)read);
        //一次读出一个字节数组
        byte[] by = new byte[1024];
        int len;
        while ((len = bis.read(by)) != -1){
            System.out.println(new String(by,0,len));
        }
    }
}

public static void main(String[] args) throws IOException {
    //读
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
    //写
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));
    //复制
    byte[] bys = new byte[1024];
    int len =0;
    while((len = bis.read(bys)) != -1){
      bos.write(bys,0,len);
    }
    bis.close();
    bos.close();
  }

/*
 * 需求：把D:\\工作\\EV已录视频\\01-课程介绍.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 字节流四种方式复制文件：
 * 基本字节流一次读写一个字节： 共耗时：117235毫秒
 * 基本字节流一次读写一个字节数组： 共耗时：156毫秒
 * 高效字节流一次读写一个字节： 共耗时：1141毫秒
 * 高效字节流一次读写一个字节数组： 共耗时：47毫秒
 */
public class CopyMp4Demo {
  public static void main(String[] args) throws IOException {
    long start = System.currentTimeMillis();
     method1("D:\\工作\\EV已录视频\\01-课程介绍.mp4", "copy1.mp4");
     method2("D:\\工作\\EV已录视频\\01-课程介绍.mp4", "copy2.mp4");
     method3("D:\\工作\\EV已录视频\\01-课程介绍.mp4", "copy3.mp4");
     method4("D:\\工作\\EV已录视频\\01-课程介绍.mp4", "copy4.mp4"); 
    long end = System.currentTimeMillis();
    System.out.println("共耗时：" + (end - start) + "毫秒");
  }
  // 高效字节流一次读写一个【字节数组】：
  public static void method4(String srcString, String destString)
      throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
        srcString));
    BufferedOutputStream bos = new BufferedOutputStream(
        new FileOutputStream(destString));
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = bis.read(bys)) != -1) {
      bos.write(bys, 0, len);
    }
    bos.close();
    bis.close();
  }
  // 高效字节流一次读写一个【字节】：
  public static void method3(String srcString, String destString)
      throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
        srcString));
    BufferedOutputStream bos = new BufferedOutputStream(
        new FileOutputStream(destString));
    int by = 0;
    while ((by = bis.read()) != -1) {
      bos.write(by);
    }
    bos.close();
    bis.close();
  }
  // 基本字节流一次读写一个字节数组
  public static void method2(String srcString, String destString)
      throws IOException {
    FileInputStream fis = new FileInputStream(srcString);
    FileOutputStream fos = new FileOutputStream(destString);
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = fis.read(bys)) != -1) {
      fos.write(bys, 0, len);
    }
    fos.close();
    fis.close();
  }
  // 基本字节流一次读写一个字节
  public static void method1(String srcString, String destString)
      throws IOException {
    FileInputStream fis = new FileInputStream(srcString);
    FileOutputStream fos = new FileOutputStream(destString);
    int by = 0;
    while ((by = fis.read()) != -1) {
      fos.write(by);
    }
    fos.close();
    fis.close();
  }
}

public static void main(String[] args) throws IOException {
        //字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));
        bw.write(97);
        bw.write("hello");
        char[] chs = {'j','a','v','a',};
        bw.write(chs);
        bw.close();
    }

public static void main(String[] args) throws IOException {
        //字符输入流
        BufferedReader br = new BufferedReader(new FileReader("c.txt"));
        //读一个字符
        int read = br.read();
        System.out.println(read);
        //循环读
        int ch;
        while ( (ch = br.read()) != -1){
            System.out.print((char)ch);
        }
        //循环读字符数组
        char[] c = new char[1024];
        int ch2;
        while ( (ch2 = br.read(c)) != -1){
            System.out.print(new String(c,0,ch2));
        }
    }

/*
 * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源：
 *    a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
 * 目的地：
 *    b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
 */
public class CopyFileDemo {
  public static void main(String[] args) throws IOException {
    // 封装数据源 读
    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    // 封装目的地 写
    BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
    // 两种方式其中的一种一次读写一个字符数组
    char[] chs = new char[1024];
    int len = 0;
    while ((len = br.read(chs)) != -1) {
      bw.write(chs, 0, len);
      bw.flush();
    }
    // 释放资源
    bw.close();
    br.close();
  }
}

/*
 * 字符缓冲流的特殊方法：
 * BufferedWriter:
 *        public void newLine():根据系统来决定换行符  写入时换行
 */
public static void main(String[] args) throws IOException {
    // 创建字符缓冲输出流对象
    BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
    for (int x = 0; x < 10; x++) {
        bw.write("hello" + x);
        // bw.write("\r\n");//之前换行做法
        bw.newLine();//现在换行做法
        bw.flush();
    }
    bw.close();
}

/*
 * 字符缓冲流的特殊方法：
 * BufferedReader:
 *        public String readLine()：一次读取一行数据
 *        包含该行内容的字符串，不包含任何行终止符(不包含换行)，如果已到达流末尾，则返回 null
 */
public static void main(String[] args) throws IOException {
    // 创建字符缓冲输入流对象
    BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
    // String line = br.readLine();//一次读取一行数据
    // System.out.println(line);
    // 最终版代码
    String line = null;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
    //释放资源
    br.close();
}