字符集、IO流（超详细）

Surpass余sheng军

已于 2023-04-04 16:16:40 修改

阅读量274

点赞数

文章标签： java jvm servlet

于 2023-03-20 23:10:32 首次发布

By Mr.Gao

本文链接：https://blog.csdn.net/weixin_53622554/article/details/129677791

版权

一. 字符集

字符集：ASCII字符集、GBK编码、Unicode字符集(统一码、万国码)
其中，ASCII字符集采用一个字节存储一个字符
GBK编码中一个中文字符以两个字节来存储
Unicode字符集一个中文字符以三个字节来存储
编码：把文字转换成字节
解码：把字节转换成对应的中文形式(编码前和编码后的字符集必须一致，否则乱码)
英文和数字在任何国家的字符集中都占一个字节
输入流：把磁盘文件中的数据读入到内存的过程，称为输入，负责读
输出流：把内存中的数据写出到磁盘文件的过程，称为输出，负责写
磁盘也叫做硬盘
IO流的作用：读写文件数据的
IO流按流的方向可以分为：输入流和输出流
IO流按流中的数据最小单位可以分为：字节流和字符流
字节流适操作所有类型的文件(包括音视频文件图片等)
字符流只能操作纯文本文件
任何文件的底层都是字节
输入流：读数据到内存输出流：写数据到磁盘
抽象类：字节输入流：InputStream 字节输出流：OutputStream
字符输入流：Reader 字符输出流：Writer
实现类：文件字节输入流：FileInputStream 文件字节输出流：FileOutputStream
文件字符输入流：FileReader 文件字符输出流：FileWriter
只有对于输出流才能flush刷新！
只有对于输出流才有覆盖管道和追加数据管道(append：true)
输出流写数据的时候就是一个字节一个字节去写的。
之前学的流都是基础流 / 原始流，性能不是很好，缓冲流读写数据的性能更好！
缓冲流也叫高效流或者高级流
缓冲流自带8KB缓冲区，可以提高原始流读写数据的性能
字节缓冲输入流：BufferedInputStream 字节缓冲输出流：BufferedOutputStream
字符缓冲输入流：BufferedReader 字符缓冲输出流：BufferedWriter
文件字节输出流:FileOutputStream，换行操作:os.write("\r\n".getBytes());
文件字符输出流:FileWriter,换行操作:fw.write("\r\n");
字符缓冲输入流BufferedReader,新功能，按行读取：readLine(),就不能写多态，因为这是BufferdReader的独有功能
字符缓冲输出流BufferedWriter,新功能，换行操作：newLine(),就不能写多态，因为这是BufferedWriter的独有功能
转换流也是基础流 / 原始流，转换流也可以转换成缓冲流 / 高级流 / 高效流。
转换流：字符输入转换流：InputStreamReader 字符输出转换流：OutputStreamWriter

字符输入转换流：InputStreamReader,可以把原始的字节流按照指定编码转换成字符输入流

字符输出转换流：OutputStreamWriter,可以把原始的字节输出流按照指定编码转换成字符输出流

对象字节输出流：ObjectOutputStream 对象字节输入流：ObjectInputStream

对象序列化：作用：以内存为基准，把内存中的对象存储到磁盘文件中去，称为对象序列化。

使用到的流是对象字节输出流：ObjectOutrputStream，对象字节输出流，写对象数据到磁盘文件。

对象如果要序列化，必须要实现Serializable序列化接口。

对象反序列化：使用到的流是对象字节输入流：ObjectInputStream

作用：以内存为基准，使用对象字节输入流，把存储到磁盘文件中的对象数据恢复成内存中的Java对象，称为对象反序列化！

打印流可以实现方便、高效的写数据到文件中去，打印流一般指PrintSteam，PrintWriter

PrintStream继承自字节输出流：OutputStream

PrintWriter继承自字符输出流：Writer

1.1 常见字符集介绍

字符集基础知识：

字符集（Character Set）是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同。
常见字符集有：
ASCII字符集
GBK字符集
Unicode（UTF-8）字符集等...

1.2 字符集的编码、解码操作

编码：把文字转换成字节
解码：把字节转换成对应的中文形式（编码前和编码后的字符集必须一致，否则乱码）

package com.gch.d3_charset;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
   目标:学会自己进行文字的编码和解码,为以后可能用到的场景做准备
 */
public class Test {
    public static void main(String[] args) throws UnsupportedEncodingException {
        // 1.编码:把文字转换成字节(使用指定的编码)
        String name = "528周杰伦";
//        byte[] bytes = name.getBytes(); // 以当前代码默认字符集进行编码(UTF-8)
        byte[] bytes = name.getBytes("GBK");
        System.out.println(bytes.length); // 9
        System.out.println(Arrays.toString(bytes)); // [53, 50, 56, -42, -36, -67, -36, -62, -41]

        // 2.解码:把字节转换成对应的中文形式(编码前  和  编码后的字符集必须一致,否则乱码)
//        String rs = new String(bytes); // 默认的UTF-8
        String rs = new String(bytes,"GBK");  // 指定GBK解码
        System.out.println(rs); // 528周杰伦
    }
}

二. IO流概述

三. 字节流的使用

文件字节输入流文件字节输出流文件字符输入流文件字符输出流

3.1 文件字节输入流：每次读取一个字节

package com.gch.d4_byte_stream;

import java.io.*;

public class FileInputStreamDemo1 {
    public static void main(String[] args) throws IOException {

        // 1.创建一个文件字节输入流管道与源文件接通。
//        InputStream is = new FileInputStream(new File("day09-file-io-app\\src\\data.txt"));
        // 简化写法
        InputStream is = new FileInputStream(("day09-file-io-app\\src\\data.txt"));

        // 2.读取一个字节返回(每次读取1滴水)
//        int b1 = is.read();
//        System.out.println(b1); // 97
//        System.out.println((char)b1); // a
//
//        int b2 = is.read();
//        System.out.println((char) b2); // b
//
//        int b3 = is.read();
//        System.out.println((char) b3); // 3
//
//        int b4 = is.read(); // 读取完毕返回-1
//        System.out.println(b4);

        // 3.使用循环改进
        // 定义一个变量记录每次读取的字节
        int b;
        while((b = is.read()) != -1){
            System.out.print((char)b); // ab3
        }
    }
}

3.2 文件字节输出流：每次读取一个字节数组

package com.gch.d4_byte_stream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

/**
   目标:使用文件字节输入流每次读取一个字节数组的数据
 */
public class FileInputStreamDemo02 {
    public static void main(String[] args) throws Exception {
        // 1.创建一个文件字节输入流管道与源文件接通
        InputStream is = new FileInputStream("day09-file-io-app/src/data02.txt");

        // 2.定义一个字节数组,用于读取字节数组
//        byte[] buffer = new byte[3]; //  3B:3个字节  1KB  1K代表1024个数据  B代表Byte字节

//        int len = is.read(buffer);
//        System.out.println("读取了" + len + "个字节。"); // 读取了3个字节。
//        // 解码
//        String rs = new String(buffer);
//        System.out.println(rs); // gch
//
//        int len1 = is.read(buffer);
//        System.out.println("读取了" + len1 + "个字节。"); // 读取了3个字节。
//        // 解码
//        String rs1 = new String(buffer);
//        System.out.println(rs1); // abc
//        // buffer = [ab c]
//
//        // buffer = [ed c]
//        int len2 = is.read(buffer);
//        System.out.println("读取了" + len2 + "个字节。"); // 读取了2个字节。
//        // 解码
//        // 读取多少倒出多少(重点)
//        String rs2 = new String(buffer,0,len2);
//        System.out.println(rs2); // ed
//
//        int len3 = is.read(buffer);
//        System.out.println(len3); // -1 读取完毕返回-1

        // 3.改进使用循环,每次读取一个字节数组
        byte[] buffer = new byte[3];
        int len; // 记录每次读取的字节数
        while((len = is.read(buffer)) != -1){
            // 读取多少倒出多少
            System.out.print(new String(buffer, 0 ,len)); // gchabced
        }
    }
}

3.3 文件字节输入流：读取文件的全部字节

package com.gch.d4_byte_stream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

/**
   目标:使用文件字节输入流一次读完文件的全部字节,可以解决乱码问题
 */
public class FileInputStreamDemo03 {
    public static void main(String[] args) throws Exception {
        // 1.创建一个文件字节输入流管道与源文件接通
        File f = new File("day09-file-io-app/src/data03.txt");
        InputStream is = new FileInputStream(f);

        // 2.定义一个字节数组与文件的大小刚刚一样大
        byte[] buffer = new byte[(int)f.length()];
        int len = is.read(buffer);
        System.out.println("读取了" + len + "个字节!"); // 读取了89个字节!
        System.out.println("文件大小:" + f.length()); // 文件大小:89
        // 解码
        System.out.println(new String(buffer));
    }
}

3.4 文件字节输出流：写字节数据到文件

package com.gch.d4_byte_stream;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

/**
    目标：字节输出流的使用。

    IO流的体系：
            字节流                                   字符流
    字节输入流           字节输出流               字符输入流       字符输出流
    InputStream         OutputStream           Reader         Writer     (抽象类)
    FileInputStream     FileOutputStream       FileReader     FileWriter (实现类)

    a.FileOutputStream文件字节输出流。
        -- 作用：以内存为基准，把内存中的数据，按照字节的形式写出到磁盘文件中去。
                 简单来说，把内存数据按照字节写出到磁盘文件中去。
        -- 构造器：
            public FileOutputStream(File file):创建一个字节输出流管道通向目标文件对象。
            public FileOutputStream(String file):创建一个字节输出流管道通向目标文件路径。
            public FileOutputStream(File file , boolean append):创建一个追加数据的字节输出流管道通向目标文件对象。
            public FileOutputStream(String file , boolean append):创建一个追加数据的字节输出流管道通向目标文件路径。
        -- 方法：
           public void write(int a):写一个字节出去 。
           public void write(byte[] buffer):写一个字节数组出去。
           public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
                           参数一，字节数组；参数二：起始字节索引位置，参数三：写多少个字节数出去。
    小结：
        记住。
        换行：  os.write("\r\n".getBytes()); // 换行
        追加数据管道： OutputStream os = new FileOutputStream("day10_demo/out01.txt" , true); // 追加管道！！
 */
public class OutputStreamDemo04 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个文件字节输出流管道与目标文件接通
        // OutputStream os = new FileOutputStream("day09-file-io-app/src/out04.txt");// 覆盖管道,先清空之前的数据,写新数据进去
        OutputStream os = new FileOutputStream("day09-file-io-app/src/out04.txt",true);// 追加数据管道!


        // 2、写数据出去
        // a.public void write(int a):写一个字节出去
        os.write('a');
        os.write(98);
        os.write("\r\n".getBytes()); // 换行
//        os.write('晖'); // [ooo]

        // b.public void write(byte[] buffer):写一个字节数组出去。
        byte[] buffer = {'a', 97, 98, 99};
        os.write(buffer);
        os.write("\r\n".getBytes()); // 换行

        byte[] buffer1 = "我是中国人".getBytes();
//        byte[] buffer1 = "我是中国人".getBytes("GBK"); // 乱码
        os.write(buffer1);
        os.write("\r\n".getBytes()); // 换行

        // c. public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
        byte[] buffer2 = {'a',98,99,100};
        os.write(buffer2, 0 ,3);
        os.write("\r\n".getBytes()); // 换行

        // 写数据,必须刷新数据,刷新后可以继续使用流
        os.flush();
        // 释放资源,包含了刷新的,关闭后流不可以使用了
//        os.close();
    }
}

3.5 finally代码块讲解

package com.gch.d5_resource;

import java.io.*;

/**
   目标:学会使用finally释放资源
 */
public class CopyDemo01 {
    public static void main(String[] args)  {
            System.out.println(test(10, 2)); // 100
        }
    }

    public static int test(int a,int b){
        try{
            int c = a / b;
//            System.exit(0);
            return c;
        }catch(Exception e){
            e.printStackTrace();
            return -1111; // 计算出现Bug
        }finally {
            // 哪怕上面有return语句执行,也必须先执行完这里才可以!
            // 开发中不建议在这里加return,如果加了,返回的永远是这里的数据了,这样会出问题!
            return 100;
        }
    }
}

3.6 文件拷贝

package com.gch.d5_resource;

import java.io.*;

/**
   目标:学会使用finally释放资源
 */
public class CopyDemo01 {
    public static void main(String[] args)  {
        InputStream is = null;
        OutputStream os = null;
        try {
            // 1.创建一个字节输入流管道与原视频接通
             is = new FileInputStream("C:\\Users\\A.G.H\\Desktop\\蓝杰\\并发编程\\002弹球游戏视频.mp4");

            // 2.创建一个字节输出流管道与目标文件接通
             os = new FileOutputStream("C:\\Users\\A.G.H\\new.mp4");

            // 3.定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数
            while((len = is.read(buffer)) != -1){
                // 读取多少倒出多少
                os.write(buffer, 0 ,len);
            }
            System.out.println("复制完成~");
//            System.out.println(10 / 0);
            return;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 无论代码是正常结束还是出现异常,finally代码块都会执行
            System.out.println("======finally======");
            // 4.关闭流
            try {
                if(os != null)os.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                if(is != null)is.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3.7 IO流：资源释放的方式

try()的括号里面只能放置资源对象，用完会自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）

package com.gch.d5_resource;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class TryCatchDemo2 {
    public static void main(String[] args) {
        try(
                // 这里面只能放置资源对象,用完自动关闭:自动调用资源对象的close方法关闭资源(即使出现异常也会做关闭操作)
                // 1.创建一个字节输入流管道与源文件接通
                InputStream is = new FileInputStream("day09-file-io-app\\src\\data.txt");
                // 2.创建一个字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream("day09-file-io-app/src/data02.txt");

//                int age = 24; // 报错,因为这里只能放资源
                // 最终会自动调用资源的close方法
                MyConnection connection = new MyConnection(); // class com.gch.d5_resource.MyConnection资源被成功释放~~~
                ){
            // 3.定义一个字节数组转义数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while((len = is.read(buffer)) != -1){
                // 读多少写多少
                os.write(buffer,0, len);
            }
            System.out.println("复制完成了~~~");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

class MyConnection implements AutoCloseable{
    @Override
    public void close() throws Exception {
        System.out.println(getClass() + "资源被成功释放~~~");
    }
}

四. 字符流的使用

字符流更适合读取文本数据

文件字节输入流文件字节输出流文件字符输入流文件字符输出流

4.1 文件字符输入流-一次读取一个字符

package com.gch.d6_char_stream;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;

/**
     目标：字符输入流的使用。

     IO流的体系：
            字节流                                   字符流
     字节输入流           字节输出流               字符输入流       字符输出流
     InputStream         OutputStream            Reader         Writer     (抽象类)
     FileInputStream     FileOutputStream        FileReader     FileWriter (实现类)

     c.FileReader:文件字符输入流。
         -- 作用：以内存为基准，把磁盘文件的数据以字符的形式读入到内存。
            简单来说，读取文本文件内容到内存中去。

         -- 构造器：
            public FileReader(File file):创建一个字符输入流与源文件对象接通。
            public FileReader(String filePath):创建一个字符输入流与源文件路径接通。

         -- 方法：
            public int read(): 读取一个字符的编号返回,读取完毕返回-1
            public int read(char[] buffer):读取一个字符数组，读取多少个字符就返回多少个数量，读取完毕返回-1
     小结：
        字符流一个一个字符的读取文本内容输出，可以解决中文读取输出乱码的问题。
        字符流很适合操作文本文件内容。
        但是：一个一个字符的读取文本内容性能较差！！
 */
public class FileReaderDemo01 {
    public static void main(String[] args) throws Exception {
        // 目标：每次读取一个字符。
        // 1、创建一个字符输入流管道与源文件接通
        Reader fr = new FileReader("file-io-app\\src\\data06.txt");

        // 2、读取一个字符返回，没有可读的字符了返回-1
//        int code = fr.read();
//        System.out.print((char)code);
//
//        int code1 = fr.read();
//        System.out.print((char)code1);

        // 3、改进:使用循环读取字符
        int code;
        while ((code = fr.read()) != -1){
            System.out.print((char) code);
        }
    }
}

4.2 文件字符输入流-一次读取一个字符数组

package com.gch.d6_char_stream;

import java.io.FileReader;
import java.io.Reader;

/**
     目标：字符输入流的使用-按照字符数组读取。

     IO流的体系：
            字节流                                       字符流
     字节输入流           字节输出流               字符输入流       字符输出流
     InputStream         OutputStream           Reader         Writer     (抽象类)
     FileInputStream     FileOutputStream       FileReader     FileWriter (实现类)

     c.FileReader:文件字符输入流。
         -- 作用：以内存为基准，把磁盘文件的数据以字符的形式读入到内存。
            简单来说，读取文本文件内容到内存中去。
         -- 构造器：
            public FileReader(File file):创建一个字符输入流与源文件对象接通。
            public FileReader(String filePath):创建一个字符输入流与源文件路径接通。
         -- 方法：
            public int read(): 读取一个字符的编号返回！ 读取完毕返回-1
            public int read(char[] buffer):读取一个字符数组，
                    读取多少个字符就返回多少个数量，读取完毕返回-1
     小结：
         字符流按照字符数组循环读取数据，可以解决中文读取输出乱码的问题，而且性能也较好！！
 */
public class FileReaderDemo02 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个文件字符输入流与源文件接通
        Reader fr = new FileReader("file-io-app/src/data07.txt");

        // 2、用循环，每次读取一个字符数组的数据。  1024 + 1024 + 8
        char[] buffer = new char[1024]; // 1K字符 而不是1KB B是字节不是字符
        int len;
        while ((len = fr.read(buffer)) != -1) {
            String rs = new String(buffer, 0, len);
            System.out.print(rs);
        }

    }
}

4.3 文件字符输出流

package com.gch.d6_char_stream;

import java.io.File;
import java.io.FileWriter;
import java.io.Writer;

/**
     目标：字符输出流的使用。

     IO流的体系：
            字节流                                   字符流
     字节输入流           字节输出流               字符输入流       字符输出流
     InputStream         OutputStream           Reader         Writer     (抽象类)
     FileInputStream     FileOutputStream       FileReader     FileWriter (实现类)

     d.FileWriter文件字符输出流的使用。
        -- 作用：以内存为基准，把内存中的数据按照字符的形式写出到磁盘文件中去。
            简单来说，就是把内存的数据以字符写出到文件中去。
        -- 构造器：
           public FileWriter(File file):创建一个字符输出流管道通向目标文件对象。
           public FileWriter(String filePath):创建一个字符输出流管道通向目标文件路径。
           public FileWriter(File file,boolean append):创建一个追加数据的字符输出流管道通向目标文件对象。
           public FileWriter(String filePath,boolean append):创建一个追加数据的字符输出流管道通向目标文件路径。
        -- 方法：
             a.public void write(int c):写一个字符出去
             b.public void write(String c)写一个字符串出去：
             c.public void write(char[] buffer):写一个字符数组出去
             d.public void write(String c ,int pos ,int len):写字符串的一部分出去
             e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
     小结：
        字符输出流可以写字符数据出去，总共有5个方法写字符。
        覆盖管道：
             Writer fw = new FileWriter("Day10Demo/src/dlei03.txt"); // 覆盖数据管道
        追加数据管道：
             Writer fw = new FileWriter("Day10Demo/src/dlei03.txt",true); // 追加数据管道
        换行：
             fw.write("\r\n"); // 换行
        结论：读写字符文件数据建议使用字符流。复制文件建议使用字节流。
 */
public class FileWriterDemo03 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字符输出流管道与目标文件接通
        // Writer fw = new FileWriter("file-io-app/src/out08.txt"); // 覆盖管道，每次启动都会清空文件之前的数据
        Writer fw = new FileWriter("file-io-app/src/out08.txt", true); // 覆盖管道，每次启动都会清空文件之前的数据

//      a.public void write(int c):写一个字符出去
        fw.write(98);
        fw.write('a');
        fw.write('徐'); // 不会出问题了
        fw.write("\r\n"); // 换行

//       b.public void write(String c)写一个字符串出去
        fw.write("abc我是中国人");
        fw.write("\r\n"); // 换行


//       c.public void write(char[] buffer):写一个字符数组出去
        char[] chars = "abc我是中国人".toCharArray();
        fw.write(chars);
        fw.write("\r\n"); // 换行


//       d.public void write(String c ,int pos ,int len):写字符串的一部分出去
        fw.write("abc我是中国人", 0, 5);
        fw.write("\r\n"); // 换行


//       e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
        fw.write(chars, 3, 5);
        fw.write("\r\n"); // 换行


        // fw.flush();// 刷新后流可以继续使用
        fw.close(); // 关闭包含刷新，关闭后流不能继续使用
    }
}

五. 缓冲流

之前学习的流都是属于基础流 / 原始流，性能其实不是最好的，缓冲流读写数据的性能更好
缓冲流也称为高效流或者高级流！之前学的字节流和字符流可以称为原始流！
缓冲流自带缓冲区，可以提高原始流读写数据的性能！

5.1 缓冲流概述

5.2 字节缓冲流

package com.gch.d1_byte_buffer;

import java.io.*;

/**
    目标：使用字节缓冲流完成数据的读写操作。
 */
public class ByteBufferDemo {
    public static void main(String[] args) {

        try (
                // 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
                // 1、创建一个字节输入流管道与原视频接通
                InputStream is = new FileInputStream("D:\\resources\\newmeinv.jpeg");
                // a.把原始的字节输入流包装成高级的缓冲字节输入流
                InputStream bis = new BufferedInputStream(is);
                // 2、创建一个字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream("D:\\resources\\newmeinv222.jpeg");
                // b.把字节输出流管道包装成高级的缓冲字节输出流管道
                OutputStream bos = new BufferedOutputStream(os);
        ) {
            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer, 0 , len);
            }
            System.out.println("复制完成了！");
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

5.3 字节缓冲流的性能分析

package com.gch.d2_byte_buffer_time;

import java.io.*;

/**
    目标：利用字节流的复制统计各种写法形式下缓冲流的性能执行情况。

    复制流：
        （1）使用低级的字节流按照一个一个字节的形式复制文件。
        （2）使用低级的字节流按照一个一个字节数组的形式复制文件。
        （3）使用高级的缓冲字节流按照一个一个字节的形式复制文件。
        （4）使用高级的缓冲字节流按照一个一个字节数组的形式复制文件。

    源文件：C:\course\3-视频\18、IO流-文件字节输出流FileOutputStream写字节数据出去.avi
    目标文件：C:\course\

    小结：
        使用高级的缓冲字节流按照一个一个字节数组的形式复制文件，性能好，建议开发使用！
 */
public class ByteBufferTimeDemo {
    private static final String SRC_FILE = "D:\\course\\基础加强\\day08-日志框架、阶段项目\\视频\\14、用户购票功能.avi";
    private static final String DEST_FILE = "D:\\course\\";

    public static void main(String[] args) {
        copy01(); // 使用低级的字节流按照一个一个字节的形式复制文件：慢的让人简直无法忍受。直接被淘汰。
        copy02(); // 使用低级的字节流按照一个一个字节数组的形式复制文件: 比较慢，但是还是可以忍受的！
        copy03(); // 缓冲流一个一个字节复制：很慢，不建议使用。
        copy04(); // 缓冲流一个一个字节数组复制：飞快，简直太完美了（推荐使用）1GB耗时1s多
    }

    /**
       使用缓冲的字节流按照一个一个字节数组的形式复制文件
     */
    private static void copy04() {
        long startTime = System.currentTimeMillis();
        try (
                // 1、创建低级的字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                // a.把原始的字节输入流包装成高级的缓冲字节输入流
                InputStream bis = new BufferedInputStream(is);
                // 2、创建低级的字节输出流与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "video4.avi");
                // b.把字节输出流管道包装成高级的缓冲字节输出流管道
                OutputStream bos = new BufferedOutputStream(os);
        ) {

            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer, 0 , len);
            }

        } catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用缓冲的字节流按照一个一个字节数组的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }


    /**
       使用缓冲的字节流按照一个一个字节的形式复制
     */
    private static void copy03() {
        long startTime = System.currentTimeMillis();
        try (
                // 1、创建低级的字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                // a.把原始的字节输入流包装成高级的缓冲字节输入流
                InputStream bis = new BufferedInputStream(is);
                // 2、创建低级的字节输出流与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "video3.avi");
                // b.把字节输出流管道包装成高级的缓冲字节输出流管道
                OutputStream bos = new BufferedOutputStream(os);
        ){

            // 3、定义一个变量记录每次读取的字节（一个一个字节的复制）
            int b;
            while ((b = bis.read()) != -1){
                bos.write(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用缓冲的字节流按照一个一个字节的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }


    /**
       使用低级的字节流按照一个一个字节数组的形式复制文件
     */
    private static void copy02() {
        long startTime = System.currentTimeMillis();
        try (
                // 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
                // 1、创建一个字节输入流管道与原视频接通
                InputStream is = new FileInputStream(SRC_FILE);
                // 2、创建一个字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "video2.avi")
        ) {

            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0 , len);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用低级的字节流按照一个一个字节数组的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }

    /**
      使用低级的字节流按照一个一个字节的形式复制文件
     */
    private static void copy01() {
        long startTime = System.currentTimeMillis();
        try (
                // 1、创建低级的字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                // 2、创建低级的字节输出流与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "video1.avi")
                ){

            // 3、定义一个变量记录每次读取的字节（一个一个字节的复制）
            int b;
            while ((b = is.read()) != -1){
                os.write(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用低级的字节流按照一个一个字节的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }
}

5.4 字符缓冲流

package com.gch.d3_char_buffer;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
    目标：学会使用缓冲字符输入流提高字符输入流的性能，新增了按照行读取的方法
    (经典代码),最适合读中文
 */
public class BufferedReaderDemo1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个文件字符输入流与源文件接通。
                Reader fr = new FileReader("io-app2/src/data01.txt");
                // a、把低级的字符输入流包装成高级的缓冲字符输入流。
                BufferedReader br = new BufferedReader(fr);
                ){

            // 2、用循环，每次读取一个字符数组的数据。  1024 + 1024 + 8
//            char[] buffer = new char[1024]; // 1K字符
//            int len;
//            while ((len = br.read(buffer)) != -1) {
//                String rs = new String(buffer, 0, len);
//                System.out.print(rs);
//            }

              String line;
              while ((line = br.readLine()) != null){
                  System.out.println(line);
              }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package com.gch.d3_char_buffer;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;

/**
     目标：缓冲字符输出流的使用，学会它多出来的一个功能：newLine();
 */
public class BufferedWriterDemo2 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字符输出流管道与目标文件接通
        Writer fw = new FileWriter("io-app2/src/out02.txt"); // 覆盖管道，每次启动都会清空文件之前的数据
       //Writer fw = new FileWriter("io-app2/src/out02.txt", true); // 追加数据
        BufferedWriter bw = new BufferedWriter(fw);

//      a.public void write(int c):写一个字符出去
        bw.write(98);
        bw.write('a');
        bw.write('徐'); // 不会出问题了
        bw.newLine(); // bw.write("\r\n"); // 换行

//       b.public void write(String c)写一个字符串出去
        bw.write("abc我是中国人");
        bw.newLine(); // bw.write("\r\n"); // 换行


//       c.public void write(char[] buffer):写一个字符数组出去
        char[] chars = "abc我是中国人".toCharArray();
        bw.write(chars);
        bw.newLine(); // bw.write("\r\n"); // 换行


//       d.public void write(String c ,int pos ,int len):写字符串的一部分出去
        bw.write("abc我是中国人", 0, 5);
        bw.newLine(); // bw.write("\r\n"); // 换行

//       e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
        bw.write(chars, 3, 5);
        bw.newLine(); // bw.write("\r\n"); // 换行


        // fw.flush();// 刷新后流可以继续使用
        bw.close(); // 关闭包含刷线，关闭后流不能使用
    }
}

package com.gch.d3_char_buffer;


import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
   目标:完成出师表顺序的恢复,并存入到另一个新文件中去
 */
public class BufferedCharTest3 {
    public static void main(String[] args) {
        try( // 1.创建缓冲字符输入流管道与源文件接通
             BufferedReader br = new BufferedReader(new FileReader("day10-io-demo/src/csb.txt"));
             // 5.创建字符输出流管道与源文件接通
             BufferedWriter bw = new BufferedWriter(new FileWriter("day10-io-demo/src/new-csb.txt"));
             ) {
            // 2.定义一个List集合存储每行内容
            List<String> lists = new ArrayList<>();
            // 3.定义循环,按照行读取文章
            String line;
            while((line = br.readLine()) != null){
                lists.add(line);
            }
            System.out.println(lists);
            // 4.排序
            Collections.sort(lists);
            System.out.println(lists);

            // 6.遍历集合中的每行文章写出去,且要换行
            for (String list : lists) {
                bw.write(list);
                bw.newLine();
            }
            System.out.println("复制完成~~~");
        } catch (Exception e) {
           e.printStackTrace();
        }
    }
}

六. 转换流

6.1 问题引出：不同编码读取乱码问题

ANSI编码就是GBK编码。

package com.gch.d4_transfer_stream;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;


/**
   演示一下代码编码与文件编码相同和不同的情况
 */
public class CharSetTest00 {
    public static void main(String[] args) {
        try (
                // 代码：UTF-8 文件 UTF-8 不会乱码
                // 1、创建一个文件字符输入流与源文件接通。
                // Reader fr = new FileReader("io-app2/src/data01.txt");


                // 代码：UTF-8 文件 GBK  乱码.     abc 我   爱 你中国
                //                                  oo  oo
                Reader fr = new FileReader("D:\\resources\\data.txt");
                // a、把低级的字符输入流包装成高级的缓冲字符输入流。
                BufferedReader br = new BufferedReader(fr);
        ){
            String line;
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6.2 字符输入转换流

package com.gch.d4_transfer_stream;

import java.io.*;

/**
     目标：字符输入转换流InputStreamReader的使用。

             字节流                                     字符流
     字节输入流               字节输出流              字符输入流            字符输出流
     InputStream             OutputStream          Reader               Writer   (抽象类)
     FileInputStream         FileOutputStream      FileReader           FileWriter(实现类)
     BufferedInputStream     BufferedOutputStream  BufferedReader       BufferedWriter(实现类，缓冲流)
                                                   InputStreamReader    OutputStreamWriter(实现类，转换流)
     字符输入转换流InputStreamReader:
          -- 作用：可以解决字符流读取不同编码乱码的问题。
                  也可以把原始的字节流按照指定编码转换成字符输入流

          -- 构造器：
                public InputStreamReader(InputStream is)：可以使用当前代码默认编码转换成字符流，几乎不用！
                public InputStreamReader(InputStream is,String charset):可以指定编码把字节流转换成字符流(核心)

     小结：
        字符输入转换流InputStreamReader:作用：可以解决字符流读取不同编码乱码的问题。
        public InputStreamReader(InputStream is,String charset):可以指定编码把字节流转换成字符流(核心)
 */
public class InputStreamReaderDemo01 {
    public static void main(String[] args) throws Exception {
        // 代码UTF-8   文件 GBK  "D:\\resources\\data.txt"
        // 1、提取GBK文件的原始字节流。   abc 我
        //                            ooo oo
        InputStream is = new FileInputStream("D:\\resources\\data.txt");
        // 2、把原始字节流转换成字符输入流
        // Reader isr = new InputStreamReader(is); // 默认以UTF-8的方式转换成字符流。 还是会乱码的  跟直接使用FileReader是一样的
        Reader isr = new InputStreamReader(is , "GBK"); // 以指定的GBK编码转换成字符输入流  完美地解决了乱码问题

        // 3、把低级的字符输入流包装成高级的缓冲字符输入流
        BufferedReader br = new BufferedReader(isr);
        String line;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
    }
}

6.3 字符输出转换流

package com.gch.d4_transfer_stream;

import java.io.*;
import java.nio.Buffer;

/**
     目标：字符输出转换OutputStreamWriter流的使用。

                字节流                                         字符流
     字节输入流               字节输出流              字符输入流            字符输出流
     InputStream             OutputStream          Reader               Writer   (抽象类)
     FileInputStream         FileOutputStream      FileReader           FileWriter(实现类)
     BufferedInputStream     BufferedOutputStream  BufferedReader       BufferedWriter(实现类，缓冲流)
                                                   InputStreamReader    OutputStreamWriter

     字符输出转换流：OutputStreamWriter
           -- 作用：可以指定编码把字节输出流转换成字符输出流。
                   可以指定写出去的字符的编码。
           -- 构造器：
                public OutputStreamWriter(OutputStream os) :   用当前默认编码UTF-8把字节输出流转换成字符输出流
                public OutputStreamWriter(OutputStream os , String charset):指定编码把字节输出流转换成字符输出流
     小结：
        字符输出转换流OutputStreamWriter可以指定编码把字节输出流转换成字符输出流。
        从而实现指定写出去的字符编码！
 */
public class OutputStreamWriterDemo02 {
    public static void main(String[] args) throws Exception {
        // 1、定义一个字节输出流
        OutputStream os = new FileOutputStream("io-app2/src/out03.txt");

        // 2、把原始的字节输出流转换成字符输出流
        // Writer osw = new OutputStreamWriter(os); // 以默认的UTF-8写字符出去 跟直接写FileWriter一样
        Writer osw = new OutputStreamWriter(os , "GBK"); // 指定GBK的方式写字符出去

        // 3、把低级的字符输出流包装成高级的缓冲字符输出流。
        BufferedWriter bw = new BufferedWriter(osw);

        bw.write("我爱中国1~~");
        bw.write("我爱中国2~~");
        bw.write("我爱中国3~~");

        bw.close();
    }
}

七. 序列化对象

7.1 对象序列化

package com.gch.d5_serializable;

import java.io.Serializable;

/**
   对象如果要序列化,必须要实现Serializable序列化接口。
 */
public class Student implements Serializable {
    private String name;
    private String loginName;
    // transient修饰的成员变量不参与序列化
    private transient String password;
    private int age;


    public Student() {
    }

    public Student(String name, String loginName, String password, int age) {
        this.name = name;
        this.loginName = loginName;
        this.password = password;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", loginName='" + loginName + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.gch.d5_serializable;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
   学会对象序列化,使用对象字节输出流ObjectOutputStream把内存中的对象存入到磁盘文件中。
   对象如果要序列化,必须要实现Serializable序列化接口。
   transient修饰的成员变量不参与序列化
   如果序列化的内容更改,必须要先序列化再反序列化，否则直接反序列化会报错
 */
public class ObjectOutputStreamDemo1 {
    public static void main(String[] args) throws Exception {
        // 1.创建学生对象
        Student s = new Student("徐磊","xulei","1314520",21);

        // 2.对象序列化:使用对象字节输出流包装字节输出流管道
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day10-io-demo/src/obj.txt"));

        // 3.直接调用序列化方法
        oos.writeObject(s);

        // 4.释放资源
        oos.close();
        System.out.println("序列化完成了~~~");
    }
}

7.2 对象反序列化

package com.gch.d5_serializable;

import java.io.Serializable;

/**
   对象如果要序列化,必须要实现Serializable序列化接口。
 */
public class Student implements Serializable {
    private String name;
    private String loginName;
    // transient修饰的成员变量不参与序列化
    private transient String password;
    private int age;


    public Student() {
    }

    public Student(String name, String loginName, String password, int age) {
        this.name = name;
        this.loginName = loginName;
        this.password = password;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", loginName='" + loginName + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

对象反序列化代码：

package com.gch.d5_serializable;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
   目标:学会进行对象反序列化:使用对象字节输入流把文件中的对象数据恢复成内存中的Java对象
 */
public class ObjectInputStreamDemo2 {
    public static void main(String[] args) throws Exception {
        // 1.创建对象字节输入流管道包装低级的字节输入流管道
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day10-io-demo/src/obj.txt"));

        // 2.调用对象字节输入流的反序列化方法
        Student s = (Student) ois.readObject();

        System.out.println(s); // Student{name='徐磊', loginName='xulei', password='null', age=21}
    }
}

八. 打印流

8.1 PrinterStream、PrintWriter

package com.gch.d6_print_stream;

import java.io.FileOutputStream;
import java.io.PrintStream;

/**
   目标:学会使用PrintStream打印流  高效、方便写数据到文件
   PrintStream继承自字节输出流OutputStream
   性能高效是因为内部基于的是缓冲流
 */
public class PrintDemo1 {
    public static void main(String[] args) throws Exception {
        // 1.创建一个打印流对象
//        PrintStream ps = new PrintStream(new FileOutputStream("day10-io-demo/src/ps.txt"));
//        PrintStream ps = new PrintStream("day10-io-demo/src/ps.txt","UTF-8");
        PrintStream ps = new PrintStream("day10-io-demo/src/ps.txt");

        // 2.打印数据/写数据到文件中去
        ps.println(97);
        ps.println('a');
        ps.println(23);
        ps.println(23.3);
        ps.println(true);
        ps.println("我是打印流写的,我很高效哦~~~");

        // 3.刷新流
//        ps.flush();
        ps.close();
    }
}

package com.gch.d6_print_stream;

import java.io.FileWriter;
import java.io.PrintWriter;

/**
   目标:学会使用PrintWriter打印流 方便、高效的写数据到文件
   PrintWriter继承自字符输出流Writer
 */
public class PrintDemo2 {
    public static void main(String[] args) throws Exception {
        // 1.创建一个PrintWriter打印流对象
        // 低级管道可以实现数据追加
//        PrintWriter pw = new PrintWriter(new FileWriter("day10-io-demo/src/ps2.txt",true));
        PrintWriter pw = new PrintWriter("day10-io-demo/src/ps2.txt");

        // 2.打印数据 / 写数据到文件中去
        // 打印功能上与PrintStream没有区别
        pw.println(97);
        pw.println('a');
        pw.println(29.7);
        pw.println(false);
        pw.println("我是PrintWriter打印流哦~~~");

        // 3.刷新流
        pw.close();
    }
}

8.2 打印流的应用：输出语句的重定向

package com.gch.d6_print_stream;

import java.io.PrintStream;

/**
   目标:了解改变输出语句的位置到文件
 */
public class PrintDemo3 {
    public static void main(String[] args) throws Exception{
        System.out.println("Melo");
        System.out.println("0329");

        // 改变输出语句的位置(重定向)
        PrintStream ps = new PrintStream("day10-io-demo/src/log.txt");
        System.setOut(ps); // 把系统打印流改成我们自己的打印流

        System.out.println("lijingze");
        System.out.println("0528");
    }
}

九. 补充知识：.properties属性文件（属性）

package com.gch.d7_properties;

import java.io.FileWriter;
import java.util.Map;
import java.util.Properties;
import java.util.Scanner;

/**
    目标：Properties的概述和使用(框架底层使用，了解这个技术即可)（保存数据到属性文件）

    Properties: 属性集对象。
         其实就是一个Map集合。也就是一个键值对集合，但是我们一般不会当集合使用，
         因为有HashMap。

    Properties核心作用：
         Properties代表的是一个属性文件，可以把键值对的数据存入到一个属性文件中去。
         属性文件：后缀是.properties结尾的文件,里面的内容都是 key=value。

    大家在后期学的很多大型框架技术中，属性文件都是很重要的系统配置文件。
        users.properties
                admin=123456
                dlei=dlei

     需求：使用Properties对象生成一个属性文件，里面存入用户名和密码信息。

     Properties的方法：
         -- public Object setProperty(String key, String value) ： 保存一对属性。  (put)
         -- public String getProperty(String key) : 使用此属性列表中指定的键搜索属性值 (get)
         -- public Set<String> stringPropertyNames() : 所有键的名称的集合  (keySet())
         -- public void store(OutputStream out, String comments): 保存数据到属性文件中去
         -- public void store(Writer fw, String comments): 保存数据到属性文件中去

     小结：
            Properties可以保存键值对数据到属性文件
 */
public class PropertiesDemo01 {
    public static void main(String[] args) throws Exception {
        // 需求：使用Properties把键值对信息存入到属性文件中去。
//        Map maps = new Properties();
        // 不能使用多态写,因为Properties要调用自己的独有功能
        Properties properties = new Properties(); // 离家出走的集合
//        properties.put("admin",123456);
        // setProperty保存键值对,setProperty源码就是调put()方法
        properties.setProperty("admin", "123456");
        properties.setProperty("dlei", "003197");
        properties.setProperty("heima", "itcast"); // {admin=123456, dlei=003197, heima=itcast}
        System.out.println(properties);

        /**
           参数一：保存管道:字符输出流管道
           参数二：保存心得,说白了就是一个注释
           存文本信息,适合用字符输出流
         */
        properties.store(new FileWriter("day10-io-demo/src/users.properties")
                , "this is users!! I am very happy! give me 100!");

    }
}

package com.gch.d7_properties;

import java.io.FileReader;
import java.util.Properties;
import java.util.Set;

/**
    目标：Properties读取属性文件中的键值对信息。（读取）
    Properties的方法：
        -- public Object setProperty(String key, String value) ： 保存一对属性。
        -- public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值
        -- public Set<String> stringPropertyNames() ：所有键的名称的集合
        -- public void store(OutputStream out, String comments):保存数据到属性文件中去
        -- public synchronized void load(InputStream inStream):加载属性文件的数据到属性集对象中去
        -- public synchronized void load(Reader fr):加载属性文件的数据到属性集对象中去
    小结：
        属性集对象可以加载读取属性文件中的数据!!
 */
public class PropertiesDemo02 {
    public static void main(String[] args) throws Exception {
        // 需求：Properties读取属性文件中的键值对信息。（读取）
        Properties properties = new Properties();
        System.out.println(properties); // {}

        // 加载属性文件中的键值对数据到属性对象properties中去
        properties.load(new FileReader("day10-io-demo/src/users.properties"));

        System.out.println(properties); // {admin=123456, dlei=003197, heima=itcast}

        // public String getProperty(String key) 	使用此属性列表中指定的键搜索属性值 (get)
        String rs = properties.getProperty("dlei");
        System.out.println(rs); // 003197
        String rs1 = properties.getProperty("admin");
        System.out.println(rs1); // 123456
    }
}

十. 补充知识：IO框架

package com.gch.d8_commons_io;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.file.Files;
import java.nio.file.Path;

/**
    目标:Commons-io包的使用介绍。

    什么是Commons-io包？
            commons-io是apache开源基金组织提供的一组有关IO操作的类库，
            可以挺提高IO功能开发的效率。commons-io工具包提供了很多有关io操作的类，

    见下表：
         | 包                                  | 功能描述                                     |
         | ----------------------------------- | :------------------------------------------- |
         | org.apache.commons.io               | 有关Streams、Readers、Writers、Files的工具类 |
         | org.apache.commons.io.input         | 输入流相关的实现类，包含Reader和InputStream  |
         | org.apache.commons.io.output        | 输出流相关的实现类，包含Writer和OutputStream |
         | org.apache.commons.io.serialization | 序列化相关的类

    步骤：
         1. 下载commons-io相关jar包；http://commons.apache.org/proper/commons-io/
         2. 把commons-io-2.6.jar包复制到指定的Module的lib目录中
         3. 将commons-io-2.6.jar加入到classpath中

    小结：
         IOUtils和FileUtils可以方便的复制文件和文件夹！！
 */
public class CommonsIODemo01 {
    public static void main(String[] args) throws Exception {

//       1.完成文件复制！
        IOUtils.copy(new FileInputStream("D:\\resources\\hushui.jpeg"),
         new FileOutputStream("D:\\resources\\hushui2.jpeg"));


        // 2.完成文件复制到某个文件夹下！
        FileUtils.copyFileToDirectory(new File("D:\\resources\\hushui.jpeg"), new File("D:/"));


          // 3.完成文件夹复制到某个文件夹下！
          FileUtils.copyDirectoryToDirectory(new File("D:\\resources") , new File("D:\\new"));
        // 删除非空文件夹
           FileUtils.deleteDirectory(new File("D:\\new"));

        FileUtils.deleteDirectory(new File("D:\\new"));
    }
}