public static void main(String[] args) {
    // 01-路径分隔符【例如环境变量里的分隔符】 windows系统使用“分号”，linux系统使用“冒号”
    String pathSeparator = File.pathSeparator;
    System.out.println(pathSeparator);

    char pathSeparatorChar = File.pathSeparatorChar;
    System.out.println(pathSeparatorChar);

    // 02-文件名称分隔符  windows系统使用反斜杠\  linux系统使用正斜杠/
    String separator = File.separator;
    System.out.println(separator);

    char separatorChar = File.separatorChar;
    System.out.println(separatorChar);
}

public static void main(String[] args) {
    // 01-public File(String pathname)
    File file01 = new File("F:\\00-BLOG-HOME\\themes\\icarus-latest\\layout\\widget");
    System.out.println(file01);    // 重写了 toString 方法，否则会打印内存地址


    // 02-public File(String parent, String child)
    File file02 = new File("F:\\", "00-BLOG-HOME");
    System.out.println(file02);


    // 03-public File(File parent, String child)
    File parent = new File("F:\\");
    File file03 = new File(parent, "00-BLOG-HOME");
    System.out.println(file03);
}

public static void main(String[] args) {
    // 01-public String getAbsolutePath()
    File file01 = new File("F:\\00-BLOG-HOME\\themes\\icarus-latest\\layout\\widget");
    System.out.println(file01.getAbsolutePath());

    File file02 = new File("00-BLOG-HOME");
    System.out.println(file02.getAbsolutePath());


    // 02-public String getPath()
    System.out.println(file01.getPath());
    System.out.println(file02.getPath());

    System.out.println(file01);
    System.out.println(file01.toString());   // 看源码知：toString 调用的就是 getPath() 方法


    // 03-public String getName() ，获取的就是构造方法传递路径的结尾部分(文件/文件夹)
    System.out.println(file01.getName());
    System.out.println(file02.getName());


    /**
     * 04-public long length()  ：返回由此 File 表示的文件的长度。获取的是构造方法指定的文件的大小,以字节为单位。
     * 注意 : 1、文件夹是没有大小概念的,不能获取文件夹的大小。2、如果构造方法中给出的路径不存在,那么length方法返回0
     */
    // 获取文件大小，不存在返回 0
    File file04 = new File("F:\\00-BLOG-HOME\\source\\about\\index.md");
    System.out.println(file04.length());

    // 获取文件夹大小，直接返回 0 ，因为文件夹没有大小，只有文件有大小
    File file05 = new File("F:\\00-BLOG-HOME\\source\\about");
    System.out.println(file05.length());
}

public static void main(String[] args) {
    // 01-public boolean exists() ：用于判断构造方法中的路径是否存在
    File file01 = new File("F:\\00-BLOG-HOME\\themes\\icarus-latest\\layout\\widget");
    System.out.println(file01.exists());

    File file02 = new File("00-BLOG-HOME");
    System.out.println(file02.exists());


    /**
     * 02-public boolean isDirectory() ：用于判断构造方法中给定的路径是否以文件夹结尾
     * 03-public boolean isFile() ：用于判断构造方法中给定的路径是否以文件结尾
     * 注意 : 1、电脑的硬盘中只有文件/文件夹,两个方法是互斥。2、这两个方法使用前提,路径必须是存在的,否则都返回 false
     */
    if(file01.exists()){
        System.out.println(file01.isDirectory());
        System.out.println(file01.isFile());

        System.out.println(file02.isDirectory());
        System.out.println(file02.isFile());
    }
}

public static void main(String[] args) throws IOException {
    //demo01();
    //demo02();
    //demo03();
}

private static void demo03() {
    // 04-public boolean delete() ：可以删除构造方法路径中给出的文件/文件夹
    // 注意：文件/文件夹删除成功,返回 true 。2、文件夹中有内容,不会删除返回 false ; 构造方法中路径不存在 false 。
    // 注意：delete 方法是直接在硬盘删除文件/文件夹,不走回收站,删除要谨慎。
    File file05 = new File("F:\\home\\111");
    System.out.println(file05.delete());
}

private static void demo02() {
    // 02-public boolean mkdir() ：创建单级空文件夹
    File file03 = new File("F:\\home\\啊啊啊");
    System.out.println(file03.mkdir());

    // 03-public boolean mkdirs() ：既可以创建单级空文件夹,也可以创建多级文件夹，创建文件夹的路径和名称在构造方法中给出(构造方法的参数)
    File file04 = new File("F:\\home\\111\\啊啊啊");
    System.out.println(file04.mkdirs());

    // 注意 : 1.此方法只能创建文件夹,不能创建文件。2、文件夹不存在,创建文件夹,返回 true 。
    // 3、文件夹存在,不会创建,返回 false;构造方法中给出的路径不存在返回 false
}

private static void demo01() throws IOException {
    // 01-public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。创建文件的路径和名称在构造方法中给出(构造方法的参数)
    // 注意 : 1、此方法只能创建文件,不能创建文件夹。2、创建文件的路径必须存在,否则会抛出异常。3、文件不存在,创建文件,返回 true ，文件存在,不会创建,返回 false 。
    File file01 = new File("F:\\home\\01.txt");
    System.out.println(file01.createNewFile());

    File file02 = new File("F:\\blog-home\\01.txt");
    System.out.println(file02.createNewFile());    // 路径不存在，抛异常：java.io.IOException: 系统找不到指定的路径。
}

public static void main(String[] args) {
    // 01-public String[] list() ：返回一个 String 数组，表示该 File 目录中的所有子文件或目录。
    File file01 = new File("F:\\home");
    String[] list = file01.list();
    for (String str : list) {
        System.out.println(str);
    }

    // 02-public File[] listFiles() ：返回一个 File 数组，表示该 File 目录中的所有的子文件或目录。
    File file02 = new File("F:\\home");
    File[] listFiles = file02.listFiles();
    for (File file : listFiles) {
        System.out.println(file);
    }

    // 03-注意事项：
    // 1、list 方法和 listFiles 方法遍历的是构造方法中给出的目录，如果构造方法中给出的目录的路径不存在,会抛出空指针异常。
    // 2、如果构造方法中给出的路径不是一个目录,也会抛出空指针异常。

}

public static void main(String[] args) {
    recursion(1);
}

private static void recursion(int i) {
    // 添加一个递归结束的条件，i == 500 的时候结束
    // 如果此递归没有结束条件，会报异常：Exception in thread "main" java.lang.StackOverflowError
    if(i > 500){
        return;    // 结束方法
    }
    System.out.println(i);
    recursion(++i);
}

public static void main(String[] args) {
    int sum = sum(100);
    System.out.println(sum);
}

public static int sum(int n) {
    if (n == 1) {
        return 1;
    }
    return n + sum(n - 1);
}

public static void main(String[] args) {
        long mul = mul(10);
        System.out.println(mul);
    }

    public static long mul(int n){
        if(n == 1){
            return 1;
        }
        return n * mul(n - 1);
    }

// 定义一个变量，记录文件数目
static int count = 0;
public static void main(String[] args) {
    File file = new File("F:\\home");
    getFiles(file);
}

public static void getFiles(File file){
    File[] list = file.listFiles();
    for (File s : list) {
        if(s.isDirectory()){
            getFiles(s);
        }
        System.out.println(s);
        System.out.println(++count);
    }
}

 // 定义一个变量，记录文件数目
static int count = 0;

public static void main(String[] args) {
    File file = new File("F:\\home");
    getFiles(file);
}

public static void getFiles(File file) {
    File[] list = file.listFiles();
    for (File s : list) {
        if (s.isDirectory()) {
            getFiles(s);
        } else {
            if (s.toString().endsWith(".xml")) {
                System.out.println(s);
                System.out.println(++count);
            }
        }
    }
}

// 定义一个变量，记录文件数目
static int count = 0;

public static void main(String[] args) {
    File file = new File("F:\\home");
    getFiles(file);
}

public static void getFiles(File file) {
    File[] list = file.listFiles(new FileFilter() {
        @Override
        public boolean accept(File pathname) {
            if(pathname.isDirectory()){
                return true;
            }
            return pathname.getName().toLowerCase().endsWith(".xml");
        }
    });
    for (File s : list) {
        if (s.isDirectory()) {
            getFiles(s);
        } else {
            if (s.toString().endsWith(".xml")) {
                System.out.println(s);
                System.out.println(++count);
            }
        }
    }
}

 // 定义一个变量，记录文件数目
    static int count = 0;

public static void main(String[] args) {
    File file = new File("F:\\home");
    getFiles(file);
    System.out.println("\n匹配到的合适的文件个数：" + count + "个");
}

public static void getFiles(File file) {
    // 使用 Lambda 表达式优化了匿名内部类
    File[] list = file.listFiles(pathname-> pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".xml"));
    for (File s : list) {
        if (s.isDirectory()) {
            getFiles(s);
        } else {
            if (s.toString().endsWith(".xml")) {
                System.out.println(s);
                count++;
            }
        }
    }
}

public static void main(String[] args) throws Exception {
    // 01-创建文件对象
    File file = new File("F:\\home\\02.txt");

    // 02-创建输出流对象的第一种构造方法
    FileOutputStream fos = new FileOutputStream(file);

    // 03-创建输出流对象的第二种构造方法
    FileOutputStream fileOutputStream = new FileOutputStream("F:\\home\\03.txt");

    // 04-关闭流
    fileOutputStream.close();
    fos.close();
}

public static void main(String[] args) throws IOException {
    // 01-使用文件名称创建流对象
    FileOutputStream fos = new FileOutputStream("F:\\home\\fos.txt");

    // 02-写出数据
    fos.write(97);    // 写出第1个字节
    fos.write(98);    // 写出第2个字节
    fos.write(99);    // 写出第3个字节

    // 03-关闭资源
    fos.close();
}

// 输出结果 ：abc

public static void main(String[] args) throws Exception {
public static void main(String[] args) throws Exception {
    /**
     * 一次写多个字节的方法:
     * public void write(byte[] b)：将 b.length 字节从指定的字节数组写入此输出流。
     * public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len 字节，从偏移量 off 开始输出到此输出流。
     */
    FileOutputStream fileOutputStream = new FileOutputStream("F:\\home\\03.txt");
    FileOutputStream fos = new FileOutputStream("F:\\home\\04.txt");

    // 01-如果写的第一个字节是正数(0 —— 127),那么显示的时候会查询 ASCII 表
    byte[] arr = {65, 66, 67, 68, 69};    // ABCDE

    // 02-向文件中写入数据
    fileOutputStream.write(arr);

    // 03-如果写的第一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK)
    byte[] bytes = {-65, -66, -67, 68, 69};    // 烤紻E
    fos.write(bytes);

    // 04-public void write(byte[] b, int off, int len
    fos.write(arr, 1, 2);    // 04.txt文件中：烤紻EBC

    // 05-写入字符串的方法 : 可以使用 String 类中的 getBytes() 方法把字符串,转换为字节数组
    byte[] str = "你好".getBytes();
    System.out.println(Arrays.toString(str));    // [-28, -67, -96, -27, -91, -67]
    fos.write(str);    // 04.txt文件中：烤紻EBC浣犲ソ

    // 06-关闭流
    fileOutputStream.close();
    fos.close();
}

public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream("F:\\home\\06.txt");     

    // 字符串转换为字节数组
    byte[] b = "abcde".getBytes();

    // 写出从索引 2 开始，2 个字节。索引 2 是 c，两个字节，也就是 cd
    fos.write(b, 2, 2);

    // 关闭资源
    fos.close();
}

public static void main(String[] args) throws IOException {
    // 这样创建流对象，可以在 05.txt 文件中追加数据
    FileOutputStream fos = new FileOutputStream("F:\\home\\05.txt"，true);     

    // 字符串转换为字节数组
    byte[] bytes = "abcde".getBytes();

    // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
    fos.write(bytes);

    // 关闭资源
    fos.close();
}

public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream("F:\\home\\05.txt");

    // 定义字节数组
    byte[] words = {97, 98, 99, 100, 101};

    // 遍历数组
    for (int i = 0; i < words.length; i++) {
        // 写出一个字节
        fos.write(words[i]);
        // 写出一个换行, 换行符号转成数组写出
        fos.write("\r\n".getBytes());
    }

    // 关闭资源
    fos.close();
}

public static void main(String[] args) throws IOException{
    // 01-使用 File 对象创建流对象
    File file = new File("F:\\home\\05.txt");
    FileInputStream fos = new FileInputStream(file);
  
    // 02-使用文件名称创建流对象
    FileInputStream fileInputStream = new FileInputStream("F:\\home\\06.txt");
    
    // 03-关闭资源
    fileInputStream.close();
    fos.close();
}

public static void main(String[] args) throws Exception {
    // 01-创建输入流对象
    FileInputStream fileInputStream = new FileInputStream("F:\\home\\04.txt");

    // 02-记录读取到的字节
    int read = fileInputStream.read();

    // 03-循环输出内容
    while (read != -1){
        System.out.print(read + " ");
        read = fileInputStream.read();
    }

    // 04-关闭资源
    fileInputStream.close();
}

public static void main(String[] args) throws IOException{
    // 使用文件名称创建流对象
    FileInputStream fis = new FileInputStream("F:\\home\\06.txt");    // 文件中为 abcde

    // 定义变量，作为有效个数
    int len；
    
    // 定义字节数组，作为装字节数据的容器   
    byte[] b = new byte[2];
    
    // 循环读取
    while (( len = fis.read(b)) != -1) {
           // 每次读取后,把数组变成字符串打印
        System.out.println(new String(b));
    }
    
    // 关闭资源
    fis.close();
}

// 输出结果：
// ab
// cd
// ed

public static void main(String[] args) throws IOException {
    // 01-使用文件名称创建流对象.
    FileInputStream fis = new FileInputStream("F:\\home\\03.txt");    // 文件中为 abcde
    
    // 02-定义变量，作为有效个数
    int len;
    
    // 03-定义字节数组，作为装字节数据的容器
    byte[] b = new byte[1024];
    
    // 04-循环读取
    while ((len = fis.read(b)) != -1) {
        // 每次读取后,把数组的有效字节部分，变成字符串打印
        System.out.println(new String(b, 0, len));    // len 每次读取的有效字节个数
        System.out.println(len);
    }
    
    // 05-关闭资源
    fis.close();
}

// 输出结果：
// abcde
// 5

public static void main(String[] args) throws IOException {
    // 1、创建一个字节输入流对象,构造方法中绑定要读取的数据源
    FileInputStream fis = new FileInputStream("F:\\home\\01.png");

    // 2、创建一个字节输出流对象,构造方法中绑定要写入的目的地
    FileOutputStream fos = new FileOutputStream("F:\\01.png");

    // 一次读取一个字节写入一个字节的方式
    // 3、使用字节输入流对象中的方法read读取文件
    /*int len = 0;
    while((len = fis.read())!=-1){
        // 4、使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
        fos.write(len);
    }*/

    // 3、使用数组缓冲读取多个字节,写入多个字节
    byte[] bytes = new byte[1024 * 8];

    // 4、使用字节输入流对象中的方法 read 读取文件
    int len;    // 每次读取的有效字节个数
    while ((len = fis.read(bytes)) != -1) {
        // 5、使用字节输出流中的方法 write , 把读取到的字节写入到目的地的文件中
        fos.write(bytes, 0, len);
    }

    // 6、释放资源(先关写的,后关闭读的;如果写完了,肯定读取完毕了)
    fos.close();
    fis.close();
}

public static void main(String[] args)  throws IOException{
    // 01-使用 File 对象创建流对象
    File file = new File("F:\\home\\02.txt");
    FileReader fr = new FileReader(file);
  
    // 02-使用文件名称创建流对象
    FileReader fileReader = new FileReader("F:\\home\\03.txt");

    // 03-关闭资源
    fileReader.close();
    fr.close();
}

public static void main(String[] args) throws IOException {
    // 使用文件名称创建流对象
    FileReader fr = new FileReader("F:\\home\\02.txt");

    // 定义变量，保存数据
    int b;

    // 循环读取
    while ((b = fr.read()) != -1) {
        System.out.println((char)b);
    }

    // 关闭资源
    fr.close();
}

public static void main(String[] args) throws IOException {
    // 1、创建 FileReader 对象,构造方法中绑定要读取的数据源
    FileReader fr = new FileReader("F:\\home\\01.txt");

    // 2、int read(char[] cbuf) 一次读取多个字符,将字符读入数组。
    char[] cs = new char[2];    // 存储读取到的多个字符
    int len;
    while((len = fr.read(cs)) != -1){
         // String类的构造方法：String(char[] value) 把字符数组转换为字符串
        System.out.println(new String(cs);
    }

    // 3、释放资源
    fr.close();
}

// 输出结果：
// 我在
// 这里
// 呀里

public static void main(String[] args) throws IOException {
    // 1、创建 FileReader 对象,构造方法中绑定要读取的数据源
    FileReader fr = new FileReader("F:\\home\\01.txt");
    
    // 2、int read(char[] cbuf) 一次读取多个字符,将字符读入数组。
    char[] cs = new char[2];    // 存储读取到的多个字符
    int len;
    while((len = fr.read(cs)) != -1){
        // String(char[] value, int offset, int count) 把字符数组的一部分转换为字符串 offset 数组的开始索引 count 转换的个数
        System.out.println(new String(cs, 0, len));
    }

    // 3、关闭资源
    fr.close();
}

// 输出结果：
// 我在
// 这里
// 呀

public static void main(String[] args) throws IOException {
    // 使用 File 对象创建流对象
    File file = new File("F:\\home\\05.txt");
    FileWriter fw = new FileWriter(file);
  
    // 使用文件名称创建流对象
    FileWriter fileWriter = new FileWriter("F:\\home\\06.txt");

    // 03-关闭资源
    fileWriter.close();
    fw.close();
}

public static void main(String[] args) throws IOException {
    // 使用文件名称创建流对象
    FileWriter fw = new FileWriter("F:\\home\\07.txt");     
    
    // 写出数据
    fw.write(97);      // 写出第1个字符
    fw.write('b');     // 写出第2个字符
    fw.write('C');     // 写出第3个字符
    fw.write(30000);   // 写出第4个字符，中文编码表中30000对应一个汉字。
  
    // 【注意】关闭资源时,与 FileOutputStream 不同。如果不关闭,数据只是保存到缓冲区，并未保存到文件。
    fw.close();
}

// 输出结果：
// abC田

/**
 * flush 方法和 close 方法的区别：
 * - flush ：刷新缓冲区，流对象可以继续使用。
 * - close ：先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
 */
public static void main(String[] args) throws IOException {
    // 1、创建 FileWriter 对象,构造方法中绑定要写入数据的目的地
    FileWriter fw = new FileWriter("F:\\home\\08.txt");

    // 2、使用 FileWriter 中的方法 write , 把数据写入到内存缓冲区中(字符转换为字节的过程)
    // void write(int c) 写入单个字符。
    fw.write(97);

    // 3、使用 FileWriter 中的方法 flush , 把内存缓冲区中的数据,刷新到文件中
    fw.flush();
    fw.write(98);    // 刷新之后流可以继续使用

    // 4、释放资源(会先把内存缓冲区中的数据刷新到文件中)
    fw.close();

    // close 方法之后流已经关闭了,已经从内存中消失了,流就不能再使用了
    fw.write(99);    // IOException: Stream closed
}

public static void main(String[] args) throws IOException {
    // 使用文件名称创建流对象
    FileWriter fw = new FileWriter("F:\\home\\09.txt");     
    
    // 字符串转换为字节数组
    char[] chars = "井冈山大学".toCharArray();
  
    // 写出字符数组
    fw.write(chars);    // 井冈山大学
    
    // 写出从索引3开始，写2个字节。索引3是'大'，两个字节，也就是 大学
    fw.write(b, 3, 2);    // 大学
  
    // 关闭资源
    fos.close();
}

public static void main(String[] args) throws IOException {
    // 01-使用文件名称创建流对象
    FileWriter fw = new FileWriter("F:\\home\\10.txt");

    // 02-定义字符串
    String msg = "井冈山大学";
  
    // 03-写出字符串
    fw.write(msg);     // 井冈山大学
  
    // 04-写出从索引3开始，写2个字节。索引3是'大'，两个字节，也就是 大学
    fw.write(msg, 3, 2);    // 大学
      
    // 05-关闭资源
    fw.close();
}

public static void main(String[] args) throws IOException {
    // 01-使用文件名称创建流对象，可以续写数据
    FileWriter fw = new FileWriter("F:\\home\\11.txt"，true);     

    // 02-写出字符串
    fw.write("井冈山");
    
    // 03-写出换行
    fw.write("\r\n");

    // 04-写出字符串
    fw.write("大学");

    // 05-关闭资源
    fw.close();
}

// 输出结果:
// 井冈山
// 大学

/**
 * 在jdk1.7之前使用try catch finally 处理流中的异常
 * 格式:
 *    try{
 *        可能会产出异常的代码
 *    }catch(异常类变量 变量名){
 *        异常的处理逻辑
 *    }finally{
 *        一定会执行的代码
 *        资源释放
 *    }
 */
public static void main(String[] args) {
    // 提高变量 fw 的作用域,让 finally 可以使用。变量在定义的时候,可以没有值,但是使用的时候必须有值
    // fw = new FileWriter("09_IOAndProperties\\g.txt",true); 执行失败,fw 没有值,fw.close 会报错
    FileWriter fw = null;
    try{
        // 可能会产出异常的代码
        fw = new FileWriter("F:\\home\\11.txt", true);
        for (int i = 0; i < 10 ; i++) {
            fw.write("HelloWorld " + i + "\r\n");
        }
    }catch(IOException e){
        // 异常的处理逻辑
        System.out.println(e);
    }finally {
        // 一定会执行的代码
        // 创建对象失败了,fw的默认值就是 null , null 是不能调用方法的,会抛出 NullPointerException , 需要增加一个判断,不是 null 在把资源释放
        if(fw != null){
            try {
                // fw.close 方法声明抛出了 IOException 异常对象,所以我们就的处理这个异常对象,要么 throws , 要么 try catch
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

/**
 * JDK7 的新特性
 * 在try的后边可以增加一个(),在括号中可以定义流对象
 * 那么这个流对象的作用域就在try中有效
 * try中的代码执行完毕,会自动把流对象释放,不用写finally
 */
public static void main(String[] args) {
    try(// 1、创建一个字节输入流对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("F:\\home\\12.txt");
        // 2、创建一个字节输出流对象,构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("F:\\home\\13.txt");){

        // 可能会产出异常的代码
        // 一次读取一个字节写入一个字节的方式
        // 3、使用字节输入流对象中的方法 read 读取文件
        int len = 0;
        while((len = fis.read()) != -1){
            // 4、使用字节输出流中的方法 write , 把读取到的字节写入到目的地的文件中
            fos.write(len);
        }

    }catch (IOException e){
        // 异常的处理逻辑
        System.out.println(e);
    }
}

/**
 * JDK9 新特性
 * try的前边可以定义流对象
 * 在try后边的()中可以直接引入流对象的名称(变量名)
 * 在try代码执行完毕之后,流对象也可以释放掉,不用写finally
 * 格式:
 *     A a = new A();
 *     B b = new B();
 *     try(a,b){
 *         可能会产出异常的代码
 *     }catch(异常类变量 变量名){
 *         异常的处理逻辑
 *     }
 */
public static void main(String[] args) throws IOException {
    // 1、创建一个字节输入流对象,构造方法中绑定要读取的数据源
    FileInputStream fis = new FileInputStream("F:\\home\\14.txt");

    // 2、创建一个字节输出流对象,构造方法中绑定要写入的目的地
    FileOutputStream fos = new FileOutputStream("F:\\home\\15.txt");

    try(fis; fos){
        // 一次读取一个字节写入一个字节的方式
        // 3、使用字节输入流对象中的方法 read 读取文件
        int len = 0;
        while((len = fis.read()) != -1){
            // 4、使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
            fos.write(len);
        }
    }catch (IOException e){
        System.out.println(e);
    }
}

/**
 * 使用Properties 集合存储数据,遍历取出 Properties 集合中的数据。Properties 集合是一个双列集合,key 和 value 默认都是字符串
 *  Properties集合有一些操作字符串的特有方法
 *      Object setProperty(String key, String value) 调用 Hashtable 的方法 put。
 *      String getProperty(String key) 通过 key 找到 value 值,此方法相当于 Map 集合中的 get(key) 方法
 *      Set<String> stringPropertyNames() 返回此属性列表中的键集，其中该键及其对应值是字符串,此方法相当于 Map 集合中的 keySet 方法
 */
public static void main(String[] args) {
    // 01-创建 Properties 集合对象
    Properties prop = new Properties();

    // 02-使用 setProperty 往集合中添加数据
    prop.setProperty("赵丽颖", "168");
    prop.setProperty("迪丽热巴", "165");
    prop.setProperty("古力娜扎", "160");

    // 03-使用 stringPropertyNames 把 Properties 集合中的键取出,存储到一个 Set 集合中
    Set<String> set = prop.stringPropertyNames();

    // 04-遍历 Set 集合,取出 Properties 集合的每一个键
    for (String key : set) {
        // 05-使用 getProperty 方法通过 key 获取 value
        String value = prop.getProperty(key);
        System.out.println(key + " = " + value);
    }
}

/**
 * 可以使用 Properties 集合中的方法 store,把集合中的临时数据,持久化写入到硬盘中存储
 * void store(OutputStream out, String comments)
 * void store(Writer writer, String comments)
 * 参数:
 * OutputStream out: 字节输出流,不能写入中文
 * Writer writer: 字符输出流,可以写中文
 * String comments: 注释,用来解释说明保存的文件是做什么用的，但是不能使用中文,会产生乱码,默认是 Unicode 编码,一般使用""空字符串
 */
public static void main(String[] args) throws IOException {
    // 1、创建 Properties 集合对象并添加数据
    Properties prop = new Properties();
    prop.setProperty("赵丽颖", "168");
    prop.setProperty("迪丽热巴", "165");
    prop.setProperty("古力娜扎", "175");

    // 2、创建字符输出流对象,构造方法中绑定要输出的目的地，不要使用字节输出流，会乱码
    FileWriter fw = new FileWriter("F:\\home\\14.txt");

    // 3、使用 Properties 集合中的方法 store,把集合中的临时数据,持久化写入到硬盘中存储
    prop.store(fw,"save my data");
    
    // 4、释放资源
    fw.close();
}

/**
 * 可以使用 Properties 集合中的方法 load,把硬盘中保存的文件(键值对),读取到集合中使用
 * void load(InputStream inStream)
 * void load(Reader reader)
 * 参数:
 *     InputStream inStream : 字节输入流,不能读取含有中文的键值对
 *     Reader reader : 字符输入流,能读取含有中文的键值对
 * 注意事项:
 *     1、存储键值对的文件中,键与值默认的连接符号可以使用=,空格(其他符号)
 *     2、存储键值对的文件中,可以使用#进行注释,被注释的键值对不会再被读取
 *     3、存储键值对的文件中,键与值默认都是字符串,不用再加引号
 */
public static void main(String[] args) throws IOException {
    // 1、创建 Properties 集合对象
    Properties prop = new Properties();

    // 2、使用 Properties 集合对象中的方法 load 读取保存键值对的文件
    prop.load(new FileReader("F:\\home\\14.txt"));

    // 3、遍历 Properties 集合
    Set<String> set = prop.stringPropertyNames();
    for (String key : set) {
        String value = prop.getProperty(key);
        System.out.println(key + " = " + value);
    }
}

// 01-创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\home\\05.txt"));

// 02-创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("F:\\home\\05.txt"));

/**
 * 继承自父类的共性成员方法:
 *     public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
 *     public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
 *     public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
 *     public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
 *     public abstract void write(int b) ：将指定的字节输出流。
 *     构造方法:
 *     BufferedOutputStream(OutputStream out)  创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
 *     BufferedOutputStream(OutputStream out, int size)  创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
 *     参数:
 *     OutputStream out:字节输出流，我们可以传递FileOutputStream,缓冲流会给FileOutputStream增加一个缓冲区,提高FileOutputStream的写入效率
 *     int size:指定缓冲流内部缓冲区的大小,不指定默认
 */
public static void main(String[] args) throws IOException {
    // 1、创建 FileOutputStream 对象,构造方法中绑定要输出的目的地
    FileOutputStream fos = new FileOutputStream("F:\\home\\05.txt");

    // 2、创建 BufferedOutputStream 对象,构造方法中传递 FileOutputStream 对象,提高效率
    BufferedOutputStream bos = new BufferedOutputStream(fos);

    // 3、使用 BufferedOutputStream 对象中的方法 write , 把数据写入到内部缓冲区中
    bos.write("井冈山大学".getBytes());

    // 4、使用 BufferedOutputStream 对象中的方法 flush , 把内部缓冲区中的数据,刷新到文件中
    bos.flush();

    // 5、释放资源(会先调用 flush 方法刷新数据,第4部可以省略)
    bos.close();
}

/**
 * 继承自父类的成员方法:
 *     int read()从输入流中读取数据的下一个字节。
 *     int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
 *     void close() 关闭此输入流并释放与该流关联的所有系统资源。
 *     构造方法:
 *         BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
 *         BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
 *     参数:
 *         InputStream in:字节输入流，我们可以传递FileInputStream,缓冲流会给FileInputStream增加一个缓冲区,提高FileInputStream的读取效率
 *         int size:指定缓冲流内部缓冲区的大小,不指定默认
 */
public static void main(String[] args) throws IOException {
    // 1、创建 FileInputStream 对象,构造方法中绑定要读取的数据源
    FileInputStream fis = new FileInputStream("F:\\home\\05.txt");
   
    // 2、创建 BufferedInputStream 对象,构造方法中传递 FileInputStream 对象,提高读取效率
    BufferedInputStream bis = new BufferedInputStream(fis);
   
    // 3、使用 BufferedInputStream 对象中的方法 read ,读取文件
    // int read() 从输入流中读取数据的下一个字节，也就是一个字节一个字节地读，效率低
//    int len;    // 记录每次读取到的字节
//    while((len = bis.read()) != -1){
//        System.out.println(len);
//    }

    // int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
    byte[] bytes = new byte[1024 * 8];//存储每次读取的数据
    int len;    // 记录每次读取的有效字节个数
    while ((len = bis.read(bytes)) != -1) {
        System.out.println(new String(bytes, 0, len));
    }

    // 4、释放资源
    bis.close();
}

public static void main(String[] args) {
    // 记录开始时间
    long start = System.currentTimeMillis();
    // 创建流对象
    try (
            FileInputStream fis = new FileInputStream("F:\\home\\01.pdf");
            FileOutputStream fos = new FileOutputStream("F:\\01.pdf")
    ) {
        // 读写数据
        int b;
        while ((b = fis.read()) != -1) {
            fos.write(b);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    // 记录结束时间
    long end = System.currentTimeMillis();
    System.out.println("普通流复制时间: " + (end - start) + " 毫秒");
}

// 普通流复制时间: 1278098 毫秒

public static void main(String[] args) {
    // 记录开始时间
    long start = System.currentTimeMillis();
    // 创建流对象
    try (
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\home\\01.pdf"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("F:\\01.pdf"))
    ) {
        // 读写数据
        int b;
        while ((b = bis.read()) != -1) {
            bos.write(b);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    // 记录结束时间
    long end = System.currentTimeMillis();
    System.out.println("缓冲流复制时间: " + (end - start) + " 毫秒");
}

// 缓冲流复制时间: 10480 毫秒

public static void main(String[] args) {
    // 记录开始时间
    long start = System.currentTimeMillis();
    // 创建流对象
    try (
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\home\\01.pdf"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("F:\\02.pdf"))
    ) {
        // 读写数据
        int len;
        byte[] bytes = new byte[8 * 1024];
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    // 记录结束时间
    long end = System.currentTimeMillis();
    System.out.println("缓冲流使用数组复制时间: " + (end - start) + " 毫秒");
}

// 缓冲流使用数组复制时间: 566 毫秒

// 01-创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("F:\\home\\05.txt"));

// 02-创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\home\\05.txt"));

public static void main(String[] args) throws IOException {
    // 创建流对象
    BufferedReader br = new BufferedReader(new FileReader("F:\\home\\05.txt"));

    // 定义字符串,保存读取的一行文字
    String line;

    // 循环读取,读取到最后返回 null
    while ((line = br.readLine()) != null) {
        System.out.print(line);
        System.out.println("---");
    }

    // 释放资源
    br.close();
}

public static void main(String[] args) throws IOException  {
    // 创建流对象
    BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\home\\edu.txt"));

    // 写出数据
    bw.write("井冈山");

    // 写出换行
    bw.newLine();
    bw.write("大学");
    bw.newLine();
    bw.write("欢迎你");
    bw.newLine();

    // 释放资源
    bw.close();
}

// 输出效果:
// 井冈山
// 大学
// 欢迎你

/**
 * 继承自父类的共性成员方法:
 *    void write(int c) 写入单个字符。
 *    void write(char[] cbuf)写入字符数组。
 *    abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分, off 数组的开始索引, len 写的字符个数。
 *    void write(String str)写入字符串。
 *    void write(String str, int off, int len) 写入字符串的某一部分,off 字符串的开始索引, len 写的字符个数。
 *    void flush()刷新该流的缓冲。
 *    void close() 关闭此流，但要先刷新它。
 *
 *     构造方法:
 *         BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
 *         BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
 *         参数:
 *             Writer out:字符输出流，我们可以传递FileWriter,缓冲流会给FileWriter增加一个缓冲区,提高FileWriter的写入效率
 *             int sz:指定缓冲区的大小,不写默认大小
 */
public static void main(String[] args) throws IOException {
    // 1、创建字符缓冲输出流对象,构造方法中传递字符输出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\home\\edu.txt"));

    // 2、调用字符缓冲输出流中的方法 write , 把数据写入到内存缓冲区中
    for (int i = 0; i < 10 ; i++) {
        bw.write("井冈山大学~~~");
        // bw.write("\r\n");
        bw.newLine();
    }
    
    // 3、调用字符缓冲输出流中的方法 flush ,把内存缓冲区中的数据,刷新到文件中
    bw.flush();
    
    // 4、释放资源
    bw.close();
}

/**
 * 继承自父类的共性成员方法:
 *     int read() 读取单个字符并返回。
 *     int read(char[] cbuf)一次读取多个字符,将字符读入数组。
 *     void close() 关闭该流并释放与之关联的所有资源。
 *     构造方法:
 *         BufferedReader(Reader in)  创建一个使用默认大小输入缓冲区的缓冲字符输入流。
 *         BufferedReader(Reader in, int sz)     创建一个使用指定大小输入缓冲区的缓冲字符输入流。
 *         参数:
 *             Reader in:字符输入流，我们可以传递FileReader,缓冲流会给FileReader增加一个缓冲区,提高FileReader的读取效率
 *     特有的成员方法:
 *         String readLine() 读取一个文本行。读取一行数据
 *         行的终止符号:通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行(\r\n)。
 *         返回值:包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
 */
public static void main(String[] args) throws IOException {
    // 1、创建字符缓冲输入流对象,构造方法中传递字符输入流
    BufferedReader br = new BufferedReader(new FileReader("F:\\home\\05.txt"));

    // 2、使用字符缓冲输入流对象中的方法read/readLine读取文本
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }

    // 3、释放资源
    br.close();
}

public static void main(String[] args) throws IOException {
    // 1、创建一个 HashMap 集合对象,存储每行文本的序号(1,2,3,..);value:存储每行的文本
    HashMap<String, String> map = new HashMap<>();

    // 2、创建字符缓冲输入流对象,构造方法中绑定字符输入流
    BufferedReader br = new BufferedReader(new FileReader("F:\\home\\05.txt"));

    // 3、创建字符缓冲输出流对象,构造方法中绑定字符输出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\05.txt"));

    // 4、使用字符缓冲输入流中的方法 readline ,逐行读取文本
    String line;
    while ((line = br.readLine()) != null) {
        // 5、对读取到的文本进行切割,获取行中的序号和文本内容
        String[] arr = line.split("\\.");

        // 6、把切割好的序号和文本的内容存储到 HashMap 集合中(key 序号是有序的,会自动排序 1,2,3,4..)
        map.put(arr[0], arr[1]);
    }

    // 7、遍历 HashMap 集合,获取每一个键值对
    for (String key : map.keySet()) {
        String value = map.get(key);

        // 8、把每一个键值对,拼接为一个文本行
        line = key + "." + value;

        // 9、把拼接好的文本,使用字符缓冲输出流中的方法 write ,写入到文件中
        bw.write(line);
        bw.newLine();    // 写换行
    }
    // 10、释放资源
    bw.close();
    br.close();
}

public static void main(String[] args) throws IOException {
    FileReader fileReader = new FileReader("F:\\GBK.txt");    // 井冈山大学
    int read;
    while ((read = fileReader.read()) != -1) {
        System.out.print((char)read);
    }
    fileReader.close();
}

// 输出结果：
// ����ɽ��ѧ

public static void main(String[] args) throws IOException {
    read_gbk();
    read_utf_8();
}

// 使用 InputStreamReader 读取 GBK 格式的文件
private static void read_gbk() throws IOException {
    // 1、创建 InputStreamReader 对象,构造方法中传递字节输入流和指定的编码表名称
    InputStreamReader isr = new InputStreamReader(new FileInputStream("F:\\gbk.txt"),"GBK"); // 你好

    // 2、使用InputStreamReader对象中的方法 read 读取文件
    int len;
    while((len = isr.read())!=-1){
        System.out.println((char)len);
    }
    // 3、释放资源
    isr.close();
}

// 使用 InputStreamReader 读取 UTF-8 格式的文件
private static void read_utf_8() throws IOException {
    // 1、创建 InputStreamReader 对象,构造方法中传递字节输入流和指定的编码表名称
    InputStreamReader isr = new InputStreamReader(new FileInputStream("F:\\utf_8.txt")); // 不指定默认使用 UTF-8
    
    // 2、使用 InputStreamReader 对象中的方法 read 读取文件
    int len;
    while((len = isr.read())!=-1){
        System.out.println((char)len);
    }
    // 3、释放资源
    isr.close();
}

public static void main(String[] args) throws IOException {
    gbk();
    utf_8();
}

// 使用转换流 OutputStreamWriter 写 GBK 格式的文件
private static void gbk() throws IOException {
    // 1、创建 OutputStreamWriter 对象,构造方法中传递字节输出流和指定的编码表名称
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("F:\\gbk.txt"),"GBK");

    // 2、使用 OutputStreamWriter 对象中的方法 write , 把字符转换为字节存储缓冲区中(编码)
    osw.write("你好");

    // 3、使用 OutputStreamWriter 对象中的方法 flush , 把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
    osw.flush();

    // 4、释放资源
    osw.close();
}

// 使用转换流 OutputStreamWriter 写 UTF-8 格式的文件
private static void utf_8() throws IOException {
    // 1、创建 OutputStreamWriter 对象,构造方法中传递字节输出流和指定的编码表名称
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("F:\\utf_8.txt"),"utf-8"); // 不指定默认使用UTF-8

    // 2、使用 OutputStreamWriter 对象中的方法 write , 把字符转换为字节存储缓冲区中(编码)
    osw.write("你好");

    // 3、使用 OutputStreamWriter 对象中的方法 flush , 把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
    osw.flush();

    // 4、释放资源
    osw.close();
}

public static void main(String[] args) throws IOException {
    // 1、创建 InputStreamReader 对象,构造方法中传递字节输入流和指定的编码表名称 GBK
    InputStreamReader isr = new InputStreamReader(new FileInputStream("F:\\GBK.txt"),"GBK");
    
    // 2、创建 OutputStreamWriter 对象,构造方法中传递字节输出流和指定的编码表名称 UTF-8
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("F:\\utf_8.txt"),"UTF-8");
    
    // 3、使用 InputStreamReader 对象中的方法 read 读取文件
    int len;
    while((len = isr.read()) != -1){
        // 4、使用 OutputStreamWriter 对象中的方法 write , 把读取的数据写入到文件中
        osw.write(len);
    }
    
    // 5、释放资源
    osw.close();
    isr.close();
}

/*
 * 序列化和反序列化的时候,会抛出NotSerializableException没有序列化异常
 * 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
 * Serializable接口也叫标记型接口
 *     要进行序列化和反序列化的类必须实现Serializable接口,就会给类添加一个标记
 *     当我们进行序列化和反序列化的时候,就会检测类上是否有这个标记
 *         有:就可以序列化和反序列化
 *         没有:就会抛出 NotSerializableException异常
 * 去市场买肉-->肉上有一个蓝色章(检测合格)-->放心购买-->买回来怎么吃随意
 *
 *
 * static关键字:静态关键字
 *     静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
 *     被static修饰的成员变量不能被序列化的,序列化的都是对象
 *     private static int age;
 *     oos.writeObject(new Person("小美女",18));
 *     Object o = ois.readObject();
 *     Person{name='小美女', age=0}
 *
 * transient关键字:瞬态关键字
 *     被transient修饰成员变量,不能被序列化
 *     private transient int age;
 *     oos.writeObject(new Person("小美女",18));
 *     Object o = ois.readObject();
 *     Person{name='小美女', age=0}
 */
public class Person implements Serializable{
    // 防止出现 InvalidClassException
    private static final long serialVersionUID = 1L;
    private String name;
    //private static int age;
    //private transient int age;
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

/*
 * java.io.ObjectOutputStream extends OutputStream
 * ObjectOutputStream:对象的序列化流
 * 作用:把对象以流的方式写入到文件中保存
 *
 * 构造方法:
 *     ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。
 *     参数:
 *         OutputStream out:字节输出流
 * 特有的成员方法:
 *     void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
 */
public static void main(String[] args) throws IOException {
    // 1、创建 ObjectOutputStream 对象,构造方法中传递字节输出流
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("F:\\person.txt"));

    // 2、使用 ObjectOutputStream 对象中的方法 writeObject ,把对象写入到文件中
    oos.writeObject(new Person("小美女", 18));

    // 3、释放资源
    oos.close();
}

public static void main(String[] args) throws IOException, ClassNotFoundException {
    // 1、创建 ObjectInputStream 对象,构造方法中传递字节输入流
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("F:\\person.txt"));

    // 2、使用 ObjectInputStream 对象中的方法 readObject 读取保存对象的文件
    Object o = ois.readObject();

    // 3、释放资源
    ois.close();

    // 4、使用读取出来的对象(打印)
    System.out.println(o);
    Person p = (Person)o;
    System.out.println(p.getName() + p.getAge());
}

// 防止出现 InvalidClassException
    private static final long serialVersionUID = 1L;