package com.lc.day17.file1;

import org.junit.Test;

import java.io.File;
import java.io.IOException;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Date;

/**
 * ClassName: TestFile
 * Package: com.lc.day17.file1
 * Description:
 *
 * @Author 爱扣钉-陈晨
 * @Create 2023/8/5 9:23
 * @Version 1.0
 */
public class TestFile {


    /*
    - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
    - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
    - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
    - `public boolean delete()` ：删除文件或者文件夹
      删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
     */
    @Test
    public void test05() throws IOException {
        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

        boolean newFile = file1.createNewFile();
        System.out.println(newFile);

        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
        boolean mkdir = file2.mkdir();
        System.out.println(mkdir);

        File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

        //时间转换
        LocalDate date = LocalDate.now();

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        String dateFile = date.format(dateTimeFormatter);

        File file = new File(file3, dateFile);
        System.out.println(file.mkdir());


        //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
        File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
        System.out.println(file4.mkdirs());

        System.out.println(file4.delete());

        file1.delete();
    }


    /*
    - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
    - `public boolean isDirectory()` ：此File表示的是否为目录。
    - `public boolean isFile()` ：此File表示的是否为文件。
    - public boolean canRead() ：判断是否可读
    - public boolean canWrite() ：判断是否可写
    - public boolean isHidden() ：判断是否隐藏
     */
    @Test
    public void test04(){
        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
        boolean exists = file1.exists();
        System.out.println("存在："+exists);

        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
        boolean directory = file2.isDirectory();
        System.out.println("文件夹："+directory);
        boolean file = file2.isFile();
        System.out.println("文件"+file);

        boolean b = file2.canRead();
        System.out.println("可读"+b);
        boolean w = file2.canWrite();
        System.out.println("可写"+w);

        File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
        boolean hidden = file3.isHidden();
        System.out.println("隐藏："+hidden);
    }

    /*
     * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
     * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
     */
    @Test
    public void test03(){
        //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

        File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
        String[] list = file.list();
        //遍历
        for (String s : list) {
            System.out.println("名称："+s);
        }

        //File数组
        File[] files = file.listFiles();

        for (File file1 : files) {
            System.out.println(file1.getName());
            System.out.println(file1.getAbsoluteFile());
        }


    }



    /*
     * public String getName() ：获取名称
     * public String getPath() ：获取路径
     * `public String getAbsolutePath()`：获取绝对路径
     * public File getAbsoluteFile()：获取绝对路径表示的文件
     * `public String getParent()`：获取上层文件目录路径。若无，返回null
     * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
     * public long lastModified() ：获取最后一次的修改时间，毫秒值
     */
    @Test
    public void test02(){
        File file = new File("upload\\a.txt");
        System.out.println(file.getName());
        String path = file.getPath();
        System.out.println(path);
        File absoluteFile = file.getAbsoluteFile();
        System.out.println(absoluteFile);

        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
        File absoluteFile1 = file1.getAbsoluteFile();
        System.out.println(absoluteFile1);
        String path1 = file1.getPath();
        System.out.println(path1);

        //path 使用的是构建路径。
        String parent = file1.getParent();
        System.out.println("parent:"+parent);

        long length = file1.length();
        System.out.println("字节："+length);

        long l = file1.lastModified();
        Date date = new Date(l);
        System.out.println(date);

        //1.8 转换成时间 ？？？

    }

    /*
    * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
    * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
    * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

    关于路径：
    * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
    * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
      * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
      * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
     */
    @Test
    public void test01(){
        //绝对路径
        File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
        //获取名称
        System.out.println(file.getName());
        //输出
        System.out.println(file);

        //相对路径
        File file1 = new File("upload", "a.txt");// upload\\a.txt
        //获取名称
        System.out.println(file1.getName());
        //输出
        System.out.println(file1);


        //构造  public File(File parent, String child)`
        File upload = new File("upload");
        File file2 = new File(upload, "b.txt");

        //获取名称
        System.out.println(file2.getName());
        //输出
        System.out.println(file2);
    }

}
package com.lc.day17.file1;

import org.junit.Test;

import java.io.File;
import java.io.IOException;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Date;

/**
 * ClassName: TestFile
 * Package: com.lc.day17.file1
 * Description:
 *
 * @Author 爱扣钉-陈晨
 * @Create 2023/8/5 9:23
 * @Version 1.0
 */
public class TestFile {


    /*
    - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
    - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
    - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
    - `public boolean delete()` ：删除文件或者文件夹
      删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
     */
    @Test
    public void test05() throws IOException {
        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

        boolean newFile = file1.createNewFile();
        System.out.println(newFile);

        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
        boolean mkdir = file2.mkdir();
        System.out.println(mkdir);

        File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

        //时间转换
        LocalDate date = LocalDate.now();

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        String dateFile = date.format(dateTimeFormatter);

        File file = new File(file3, dateFile);
        System.out.println(file.mkdir());


        //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
        File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
        System.out.println(file4.mkdirs());

        System.out.println(file4.delete());

        file1.delete();
    }


    /*
    - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
    - `public boolean isDirectory()` ：此File表示的是否为目录。
    - `public boolean isFile()` ：此File表示的是否为文件。
    - public boolean canRead() ：判断是否可读
    - public boolean canWrite() ：判断是否可写
    - public boolean isHidden() ：判断是否隐藏
     */
    @Test
    public void test04(){
        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
        boolean exists = file1.exists();
        System.out.println("存在："+exists);

        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
        boolean directory = file2.isDirectory();
        System.out.println("文件夹："+directory);
        boolean file = file2.isFile();
        System.out.println("文件"+file);

        boolean b = file2.canRead();
        System.out.println("可读"+b);
        boolean w = file2.canWrite();
        System.out.println("可写"+w);

        File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
        boolean hidden = file3.isHidden();
        System.out.println("隐藏："+hidden);
    }

    /*
     * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
     * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
     */
    @Test
    public void test03(){
        //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

        File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
        String[] list = file.list();
        //遍历
        for (String s : list) {
            System.out.println("名称："+s);
        }

        //File数组
        File[] files = file.listFiles();

        for (File file1 : files) {
            System.out.println(file1.getName());
            System.out.println(file1.getAbsoluteFile());
        }


    }



    /*
     * public String getName() ：获取名称
     * public String getPath() ：获取路径
     * `public String getAbsolutePath()`：获取绝对路径
     * public File getAbsoluteFile()：获取绝对路径表示的文件
     * `public String getParent()`：获取上层文件目录路径。若无，返回null
     * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
     * public long lastModified() ：获取最后一次的修改时间，毫秒值
     */
    @Test
    public void test02(){
        File file = new File("upload\\a.txt");
        System.out.println(file.getName());
        String path = file.getPath();
        System.out.println(path);
        File absoluteFile = file.getAbsoluteFile();
        System.out.println(absoluteFile);

        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
        File absoluteFile1 = file1.getAbsoluteFile();
        System.out.println(absoluteFile1);
        String path1 = file1.getPath();
        System.out.println(path1);

        //path 使用的是构建路径。
        String parent = file1.getParent();
        System.out.println("parent:"+parent);

        long length = file1.length();
        System.out.println("字节："+length);

        long l = file1.lastModified();
        Date date = new Date(l);
        System.out.println(date);

        //1.8 转换成时间 ？？？

    }

    /*
    * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
    * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
    * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

    关于路径：
    * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
    * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
      * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
      * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
     */
    @Test
    public void test01(){
        //绝对路径
        File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
        //获取名称
        System.out.println(file.getName());
        //输出
        System.out.println(file);

        //相对路径
        File file1 = new File("upload", "a.txt");// upload\\a.txt
        //获取名称
        System.out.println(file1.getName());
        //输出
        System.out.println(file1);


        //构造  public File(File parent, String child)`
        File upload = new File("upload");
        File file2 = new File(upload, "b.txt");

        //获取名称
        System.out.println(file2.getName());
        //输出
        System.out.println(file2);
    }
}package com.lc.day17.file1;

 import org.junit.Test;

 import java.io.File;
 import java.io.IOException;
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.util.Date;

 /**
  * ClassName: TestFile
  * Package: com.lc.day17.file1
  * Description:
  *
  * @Author 爱扣钉-陈晨
  * @Create 2023/8/5 9:23
  * @Version 1.0
  */
 public class TestFile {


     /*
     - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
     - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
     - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
     - `public boolean delete()` ：删除文件或者文件夹
       删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
      */
     @Test
     public void test05() throws IOException {
         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

         boolean newFile = file1.createNewFile();
         System.out.println(newFile);

         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
         boolean mkdir = file2.mkdir();
         System.out.println(mkdir);

         File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

         //时间转换
         LocalDate date = LocalDate.now();

         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

         String dateFile = date.format(dateTimeFormatter);

         File file = new File(file3, dateFile);
         System.out.println(file.mkdir());


         //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
         File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
         System.out.println(file4.mkdirs());

         System.out.println(file4.delete());

         file1.delete();
     }


     /*
     - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
     - `public boolean isDirectory()` ：此File表示的是否为目录。
     - `public boolean isFile()` ：此File表示的是否为文件。
     - public boolean canRead() ：判断是否可读
     - public boolean canWrite() ：判断是否可写
     - public boolean isHidden() ：判断是否隐藏
      */
     @Test
     public void test04(){
         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
         boolean exists = file1.exists();
         System.out.println("存在："+exists);

         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
         boolean directory = file2.isDirectory();
         System.out.println("文件夹："+directory);
         boolean file = file2.isFile();
         System.out.println("文件"+file);

         boolean b = file2.canRead();
         System.out.println("可读"+b);
         boolean w = file2.canWrite();
         System.out.println("可写"+w);

         File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
         boolean hidden = file3.isHidden();
         System.out.println("隐藏："+hidden);
     }

     /*
      * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
      * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
      */
     @Test
     public void test03(){
         //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

         File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
         String[] list = file.list();
         //遍历
         for (String s : list) {
             System.out.println("名称："+s);
         }

         //File数组
         File[] files = file.listFiles();

         for (File file1 : files) {
             System.out.println(file1.getName());
             System.out.println(file1.getAbsoluteFile());
         }


     }



     /*
      * public String getName() ：获取名称
      * public String getPath() ：获取路径
      * `public String getAbsolutePath()`：获取绝对路径
      * public File getAbsoluteFile()：获取绝对路径表示的文件
      * `public String getParent()`：获取上层文件目录路径。若无，返回null
      * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
      * public long lastModified() ：获取最后一次的修改时间，毫秒值
      */
     @Test
     public void test02(){
         File file = new File("upload\\a.txt");
         System.out.println(file.getName());
         String path = file.getPath();
         System.out.println(path);
         File absoluteFile = file.getAbsoluteFile();
         System.out.println(absoluteFile);

         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
         File absoluteFile1 = file1.getAbsoluteFile();
         System.out.println(absoluteFile1);
         String path1 = file1.getPath();
         System.out.println(path1);

         //path 使用的是构建路径。
         String parent = file1.getParent();
         System.out.println("parent:"+parent);

         long length = file1.length();
         System.out.println("字节："+length);

         long l = file1.lastModified();
         Date date = new Date(l);
         System.out.println(date);

         //1.8 转换成时间 ？？？

     }

     /*
     * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
     * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
     * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

     关于路径：
     * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
     * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
       * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
       * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
      */
     @Test
     public void test01(){
         //绝对路径
         File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
         //获取名称
         System.out.println(file.getName());
         //输出
         System.out.println(file);

         //相对路径
         File file1 = new File("upload", "a.txt");// upload\\a.txt
         //获取名称
         System.out.println(file1.getName());
         //输出
         System.out.println(file1);


         //构造  public File(File parent, String child)`
         File upload = new File("upload");
         File file2 = new File(upload, "b.txt");

         //获取名称
         System.out.println(file2.getName());
         //输出
         System.out.println(file2);
     }
 }package com.lc.day17.file1;

  import org.junit.Test;

  import java.io.File;
  import java.io.IOException;
  import java.time.LocalDate;
  import java.time.format.DateTimeFormatter;
  import java.util.Date;

  /**
   * ClassName: TestFile
   * Package: com.lc.day17.file1
   * Description:
   *
   * @Author 爱扣钉-陈晨
   * @Create 2023/8/5 9:23
   * @Version 1.0
   */
  public class TestFile {


      /*
      - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
      - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
      - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
      - `public boolean delete()` ：删除文件或者文件夹
        删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
       */
      @Test
      public void test05() throws IOException {
          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

          boolean newFile = file1.createNewFile();
          System.out.println(newFile);

          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
          boolean mkdir = file2.mkdir();
          System.out.println(mkdir);

          File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

          //时间转换
          LocalDate date = LocalDate.now();

          DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

          String dateFile = date.format(dateTimeFormatter);

          File file = new File(file3, dateFile);
          System.out.println(file.mkdir());


          //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
          File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
          System.out.println(file4.mkdirs());

          System.out.println(file4.delete());

          file1.delete();
      }


      /*
      - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
      - `public boolean isDirectory()` ：此File表示的是否为目录。
      - `public boolean isFile()` ：此File表示的是否为文件。
      - public boolean canRead() ：判断是否可读
      - public boolean canWrite() ：判断是否可写
      - public boolean isHidden() ：判断是否隐藏
       */
      @Test
      public void test04(){
          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
          boolean exists = file1.exists();
          System.out.println("存在："+exists);

          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
          boolean directory = file2.isDirectory();
          System.out.println("文件夹："+directory);
          boolean file = file2.isFile();
          System.out.println("文件"+file);

          boolean b = file2.canRead();
          System.out.println("可读"+b);
          boolean w = file2.canWrite();
          System.out.println("可写"+w);

          File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
          boolean hidden = file3.isHidden();
          System.out.println("隐藏："+hidden);
      }

      /*
       * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
       * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
       */
      @Test
      public void test03(){
          //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

          File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
          String[] list = file.list();
          //遍历
          for (String s : list) {
              System.out.println("名称："+s);
          }

          //File数组
          File[] files = file.listFiles();

          for (File file1 : files) {
              System.out.println(file1.getName());
              System.out.println(file1.getAbsoluteFile());
          }


      }



      /*
       * public String getName() ：获取名称
       * public String getPath() ：获取路径
       * `public String getAbsolutePath()`：获取绝对路径
       * public File getAbsoluteFile()：获取绝对路径表示的文件
       * `public String getParent()`：获取上层文件目录路径。若无，返回null
       * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
       * public long lastModified() ：获取最后一次的修改时间，毫秒值
       */
      @Test
      public void test02(){
          File file = new File("upload\\a.txt");
          System.out.println(file.getName());
          String path = file.getPath();
          System.out.println(path);
          File absoluteFile = file.getAbsoluteFile();
          System.out.println(absoluteFile);

          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
          File absoluteFile1 = file1.getAbsoluteFile();
          System.out.println(absoluteFile1);
          String path1 = file1.getPath();
          System.out.println(path1);

          //path 使用的是构建路径。
          String parent = file1.getParent();
          System.out.println("parent:"+parent);

          long length = file1.length();
          System.out.println("字节："+length);

          long l = file1.lastModified();
          Date date = new Date(l);
          System.out.println(date);

          //1.8 转换成时间 ？？？

      }

      /*
      * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
      * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
      * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

      关于路径：
      * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
      * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
        * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
        * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
       */
      @Test
      public void test01(){
          //绝对路径
          File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
          //获取名称
          System.out.println(file.getName());
          //输出
          System.out.println(file);

          //相对路径
          File file1 = new File("upload", "a.txt");// upload\\a.txt
          //获取名称
          System.out.println(file1.getName());
          //输出
          System.out.println(file1);


          //构造  public File(File parent, String child)`
          File upload = new File("upload");
          File file2 = new File(upload, "b.txt");

          //获取名称
          System.out.println(file2.getName());
          //输出
          System.out.println(file2);
      }
  }package com.lc.day17.file1;

   import org.junit.Test;

   import java.io.File;
   import java.io.IOException;
   import java.time.LocalDate;
   import java.time.format.DateTimeFormatter;
   import java.util.Date;

   /**
    * ClassName: TestFile
    * Package: com.lc.day17.file1
    * Description:
    *
    * @Author 爱扣钉-陈晨
    * @Create 2023/8/5 9:23
    * @Version 1.0
    */
   public class TestFile {


       /*
       - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
       - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
       - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
       - `public boolean delete()` ：删除文件或者文件夹
         删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
        */
       @Test
       public void test05() throws IOException {
           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

           boolean newFile = file1.createNewFile();
           System.out.println(newFile);

           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
           boolean mkdir = file2.mkdir();
           System.out.println(mkdir);

           File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

           //时间转换
           LocalDate date = LocalDate.now();

           DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

           String dateFile = date.format(dateTimeFormatter);

           File file = new File(file3, dateFile);
           System.out.println(file.mkdir());


           //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
           File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
           System.out.println(file4.mkdirs());

           System.out.println(file4.delete());

           file1.delete();
       }


       /*
       - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
       - `public boolean isDirectory()` ：此File表示的是否为目录。
       - `public boolean isFile()` ：此File表示的是否为文件。
       - public boolean canRead() ：判断是否可读
       - public boolean canWrite() ：判断是否可写
       - public boolean isHidden() ：判断是否隐藏
        */
       @Test
       public void test04(){
           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
           boolean exists = file1.exists();
           System.out.println("存在："+exists);

           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
           boolean directory = file2.isDirectory();
           System.out.println("文件夹："+directory);
           boolean file = file2.isFile();
           System.out.println("文件"+file);

           boolean b = file2.canRead();
           System.out.println("可读"+b);
           boolean w = file2.canWrite();
           System.out.println("可写"+w);

           File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
           boolean hidden = file3.isHidden();
           System.out.println("隐藏："+hidden);
       }

       /*
        * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
        * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
        */
       @Test
       public void test03(){
           //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

           File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
           String[] list = file.list();
           //遍历
           for (String s : list) {
               System.out.println("名称："+s);
           }

           //File数组
           File[] files = file.listFiles();

           for (File file1 : files) {
               System.out.println(file1.getName());
               System.out.println(file1.getAbsoluteFile());
           }


       }



       /*
        * public String getName() ：获取名称
        * public String getPath() ：获取路径
        * `public String getAbsolutePath()`：获取绝对路径
        * public File getAbsoluteFile()：获取绝对路径表示的文件
        * `public String getParent()`：获取上层文件目录路径。若无，返回null
        * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
        * public long lastModified() ：获取最后一次的修改时间，毫秒值
        */
       @Test
       public void test02(){
           File file = new File("upload\\a.txt");
           System.out.println(file.getName());
           String path = file.getPath();
           System.out.println(path);
           File absoluteFile = file.getAbsoluteFile();
           System.out.println(absoluteFile);

           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
           File absoluteFile1 = file1.getAbsoluteFile();
           System.out.println(absoluteFile1);
           String path1 = file1.getPath();
           System.out.println(path1);

           //path 使用的是构建路径。
           String parent = file1.getParent();
           System.out.println("parent:"+parent);

           long length = file1.length();
           System.out.println("字节："+length);

           long l = file1.lastModified();
           Date date = new Date(l);
           System.out.println(date);

           //1.8 转换成时间 ？？？

       }

       /*
       * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
       * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
       * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

       关于路径：
       * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
       * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
         * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
         * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
        */
       @Test
       public void test01(){
           //绝对路径
           File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
           //获取名称
           System.out.println(file.getName());
           //输出
           System.out.println(file);

           //相对路径
           File file1 = new File("upload", "a.txt");// upload\\a.txt
           //获取名称
           System.out.println(file1.getName());
           //输出
           System.out.println(file1);


           //构造  public File(File parent, String child)`
           File upload = new File("upload");
           File file2 = new File(upload, "b.txt");

           //获取名称
           System.out.println(file2.getName());
           //输出
           System.out.println(file2);
       }
   }package com.lc.day17.file1;

    import org.junit.Test;

    import java.io.File;
    import java.io.IOException;
    import java.time.LocalDate;
    import java.time.format.DateTimeFormatter;
    import java.util.Date;

    /**
     * ClassName: TestFile
     * Package: com.lc.day17.file1
     * Description:
     *
     * @Author 爱扣钉-陈晨
     * @Create 2023/8/5 9:23
     * @Version 1.0
     */
    public class TestFile {


        /*
        - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
        - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
        - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
        - `public boolean delete()` ：删除文件或者文件夹
          删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
         */
        @Test
        public void test05() throws IOException {
            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

            boolean newFile = file1.createNewFile();
            System.out.println(newFile);

            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
            boolean mkdir = file2.mkdir();
            System.out.println(mkdir);

            File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

            //时间转换
            LocalDate date = LocalDate.now();

            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

            String dateFile = date.format(dateTimeFormatter);

            File file = new File(file3, dateFile);
            System.out.println(file.mkdir());


            //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
            File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
            System.out.println(file4.mkdirs());

            System.out.println(file4.delete());

            file1.delete();
        }


        /*
        - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
        - `public boolean isDirectory()` ：此File表示的是否为目录。
        - `public boolean isFile()` ：此File表示的是否为文件。
        - public boolean canRead() ：判断是否可读
        - public boolean canWrite() ：判断是否可写
        - public boolean isHidden() ：判断是否隐藏
         */
        @Test
        public void test04(){
            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
            boolean exists = file1.exists();
            System.out.println("存在："+exists);

            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
            boolean directory = file2.isDirectory();
            System.out.println("文件夹："+directory);
            boolean file = file2.isFile();
            System.out.println("文件"+file);

            boolean b = file2.canRead();
            System.out.println("可读"+b);
            boolean w = file2.canWrite();
            System.out.println("可写"+w);

            File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
            boolean hidden = file3.isHidden();
            System.out.println("隐藏："+hidden);
        }

        /*
         * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
         * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
         */
        @Test
        public void test03(){
            //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

            File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
            String[] list = file.list();
            //遍历
            for (String s : list) {
                System.out.println("名称："+s);
            }

            //File数组
            File[] files = file.listFiles();

            for (File file1 : files) {
                System.out.println(file1.getName());
                System.out.println(file1.getAbsoluteFile());
            }


        }



        /*
         * public String getName() ：获取名称
         * public String getPath() ：获取路径
         * `public String getAbsolutePath()`：获取绝对路径
         * public File getAbsoluteFile()：获取绝对路径表示的文件
         * `public String getParent()`：获取上层文件目录路径。若无，返回null
         * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
         * public long lastModified() ：获取最后一次的修改时间，毫秒值
         */
        @Test
        public void test02(){
            File file = new File("upload\\a.txt");
            System.out.println(file.getName());
            String path = file.getPath();
            System.out.println(path);
            File absoluteFile = file.getAbsoluteFile();
            System.out.println(absoluteFile);

            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
            File absoluteFile1 = file1.getAbsoluteFile();
            System.out.println(absoluteFile1);
            String path1 = file1.getPath();
            System.out.println(path1);

            //path 使用的是构建路径。
            String parent = file1.getParent();
            System.out.println("parent:"+parent);

            long length = file1.length();
            System.out.println("字节："+length);

            long l = file1.lastModified();
            Date date = new Date(l);
            System.out.println(date);

            //1.8 转换成时间 ？？？

        }

        /*
        * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
        * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
        * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

        关于路径：
        * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
        * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
          * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
          * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
         */
        @Test
        public void test01(){
            //绝对路径
            File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
            //获取名称
            System.out.println(file.getName());
            //输出
            System.out.println(file);

            //相对路径
            File file1 = new File("upload", "a.txt");// upload\\a.txt
            //获取名称
            System.out.println(file1.getName());
            //输出
            System.out.println(file1);


            //构造  public File(File parent, String child)`
            File upload = new File("upload");
            File file2 = new File(upload, "b.txt");

            //获取名称
            System.out.println(file2.getName());
            //输出
            System.out.println(file2);
        }
    }package com.lc.day17.file1;

     import org.junit.Test;

     import java.io.File;
     import java.io.IOException;
     import java.time.LocalDate;
     import java.time.format.DateTimeFormatter;
     import java.util.Date;

     /**
      * ClassName: TestFile
      * Package: com.lc.day17.file1
      * Description:
      *
      * @Author 爱扣钉-陈晨
      * @Create 2023/8/5 9:23
      * @Version 1.0
      */
     public class TestFile {


         /*
         - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
         - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
         - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
         - `public boolean delete()` ：删除文件或者文件夹
           删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
          */
         @Test
         public void test05() throws IOException {
             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

             boolean newFile = file1.createNewFile();
             System.out.println(newFile);

             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
             boolean mkdir = file2.mkdir();
             System.out.println(mkdir);

             File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

             //时间转换
             LocalDate date = LocalDate.now();

             DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

             String dateFile = date.format(dateTimeFormatter);

             File file = new File(file3, dateFile);
             System.out.println(file.mkdir());


             //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
             File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
             System.out.println(file4.mkdirs());

             System.out.println(file4.delete());

             file1.delete();
         }


         /*
         - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
         - `public boolean isDirectory()` ：此File表示的是否为目录。
         - `public boolean isFile()` ：此File表示的是否为文件。
         - public boolean canRead() ：判断是否可读
         - public boolean canWrite() ：判断是否可写
         - public boolean isHidden() ：判断是否隐藏
          */
         @Test
         public void test04(){
             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
             boolean exists = file1.exists();
             System.out.println("存在："+exists);

             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
             boolean directory = file2.isDirectory();
             System.out.println("文件夹："+directory);
             boolean file = file2.isFile();
             System.out.println("文件"+file);

             boolean b = file2.canRead();
             System.out.println("可读"+b);
             boolean w = file2.canWrite();
             System.out.println("可写"+w);

             File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
             boolean hidden = file3.isHidden();
             System.out.println("隐藏："+hidden);
         }

         /*
          * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
          * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
          */
         @Test
         public void test03(){
             //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

             File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
             String[] list = file.list();
             //遍历
             for (String s : list) {
                 System.out.println("名称："+s);
             }

             //File数组
             File[] files = file.listFiles();

             for (File file1 : files) {
                 System.out.println(file1.getName());
                 System.out.println(file1.getAbsoluteFile());
             }


         }



         /*
          * public String getName() ：获取名称
          * public String getPath() ：获取路径
          * `public String getAbsolutePath()`：获取绝对路径
          * public File getAbsoluteFile()：获取绝对路径表示的文件
          * `public String getParent()`：获取上层文件目录路径。若无，返回null
          * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
          * public long lastModified() ：获取最后一次的修改时间，毫秒值
          */
         @Test
         public void test02(){
             File file = new File("upload\\a.txt");
             System.out.println(file.getName());
             String path = file.getPath();
             System.out.println(path);
             File absoluteFile = file.getAbsoluteFile();
             System.out.println(absoluteFile);

             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
             File absoluteFile1 = file1.getAbsoluteFile();
             System.out.println(absoluteFile1);
             String path1 = file1.getPath();
             System.out.println(path1);

             //path 使用的是构建路径。
             String parent = file1.getParent();
             System.out.println("parent:"+parent);

             long length = file1.length();
             System.out.println("字节："+length);

             long l = file1.lastModified();
             Date date = new Date(l);
             System.out.println(date);

             //1.8 转换成时间 ？？？

         }

         /*
         * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
         * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
         * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

         关于路径：
         * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
         * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
           * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
           * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
          */
         @Test
         public void test01(){
             //绝对路径
             File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
             //获取名称
             System.out.println(file.getName());
             //输出
             System.out.println(file);

             //相对路径
             File file1 = new File("upload", "a.txt");// upload\\a.txt
             //获取名称
             System.out.println(file1.getName());
             //输出
             System.out.println(file1);


             //构造  public File(File parent, String child)`
             File upload = new File("upload");
             File file2 = new File(upload, "b.txt");

             //获取名称
             System.out.println(file2.getName());
             //输出
             System.out.println(file2);
         }
     }package com.lc.day17.file1;

      import org.junit.Test;

      import java.io.File;
      import java.io.IOException;
      import java.time.LocalDate;
      import java.time.format.DateTimeFormatter;
      import java.util.Date;

      /**
       * ClassName: TestFile
       * Package: com.lc.day17.file1
       * Description:
       *
       * @Author 爱扣钉-陈晨
       * @Create 2023/8/5 9:23
       * @Version 1.0
       */
      public class TestFile {


          /*
          - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
          - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
          - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
          - `public boolean delete()` ：删除文件或者文件夹
            删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
           */
          @Test
          public void test05() throws IOException {
              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

              boolean newFile = file1.createNewFile();
              System.out.println(newFile);

              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
              boolean mkdir = file2.mkdir();
              System.out.println(mkdir);

              File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

              //时间转换
              LocalDate date = LocalDate.now();

              DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

              String dateFile = date.format(dateTimeFormatter);

              File file = new File(file3, dateFile);
              System.out.println(file.mkdir());


              //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
              File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
              System.out.println(file4.mkdirs());

              System.out.println(file4.delete());

              file1.delete();
          }


          /*
          - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
          - `public boolean isDirectory()` ：此File表示的是否为目录。
          - `public boolean isFile()` ：此File表示的是否为文件。
          - public boolean canRead() ：判断是否可读
          - public boolean canWrite() ：判断是否可写
          - public boolean isHidden() ：判断是否隐藏
           */
          @Test
          public void test04(){
              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
              boolean exists = file1.exists();
              System.out.println("存在："+exists);

              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
              boolean directory = file2.isDirectory();
              System.out.println("文件夹："+directory);
              boolean file = file2.isFile();
              System.out.println("文件"+file);

              boolean b = file2.canRead();
              System.out.println("可读"+b);
              boolean w = file2.canWrite();
              System.out.println("可写"+w);

              File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
              boolean hidden = file3.isHidden();
              System.out.println("隐藏："+hidden);
          }

          /*
           * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
           * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
           */
          @Test
          public void test03(){
              //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

              File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
              String[] list = file.list();
              //遍历
              for (String s : list) {
                  System.out.println("名称："+s);
              }

              //File数组
              File[] files = file.listFiles();

              for (File file1 : files) {
                  System.out.println(file1.getName());
                  System.out.println(file1.getAbsoluteFile());
              }


          }



          /*
           * public String getName() ：获取名称
           * public String getPath() ：获取路径
           * `public String getAbsolutePath()`：获取绝对路径
           * public File getAbsoluteFile()：获取绝对路径表示的文件
           * `public String getParent()`：获取上层文件目录路径。若无，返回null
           * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
           * public long lastModified() ：获取最后一次的修改时间，毫秒值
           */
          @Test
          public void test02(){
              File file = new File("upload\\a.txt");
              System.out.println(file.getName());
              String path = file.getPath();
              System.out.println(path);
              File absoluteFile = file.getAbsoluteFile();
              System.out.println(absoluteFile);

              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
              File absoluteFile1 = file1.getAbsoluteFile();
              System.out.println(absoluteFile1);
              String path1 = file1.getPath();
              System.out.println(path1);

              //path 使用的是构建路径。
              String parent = file1.getParent();
              System.out.println("parent:"+parent);

              long length = file1.length();
              System.out.println("字节："+length);

              long l = file1.lastModified();
              Date date = new Date(l);
              System.out.println(date);

              //1.8 转换成时间 ？？？

          }

          /*
          * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
          * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
          * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

          关于路径：
          * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
          * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
            * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
            * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
           */
          @Test
          public void test01(){
              //绝对路径
              File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
              //获取名称
              System.out.println(file.getName());
              //输出
              System.out.println(file);

              //相对路径
              File file1 = new File("upload", "a.txt");// upload\\a.txt
              //获取名称
              System.out.println(file1.getName());
              //输出
              System.out.println(file1);


              //构造  public File(File parent, String child)`
              File upload = new File("upload");
              File file2 = new File(upload, "b.txt");

              //获取名称
              System.out.println(file2.getName());
              //输出
              System.out.println(file2);
          }
      }package com.lc.day17.file1;

       import org.junit.Test;

       import java.io.File;
       import java.io.IOException;
       import java.time.LocalDate;
       import java.time.format.DateTimeFormatter;
       import java.util.Date;

       /**
        * ClassName: TestFile
        * Package: com.lc.day17.file1
        * Description:
        *
        * @Author 爱扣钉-陈晨
        * @Create 2023/8/5 9:23
        * @Version 1.0
        */
       public class TestFile {


           /*
           - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
           - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
           - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
           - `public boolean delete()` ：删除文件或者文件夹
             删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
            */
           @Test
           public void test05() throws IOException {
               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

               boolean newFile = file1.createNewFile();
               System.out.println(newFile);

               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
               boolean mkdir = file2.mkdir();
               System.out.println(mkdir);

               File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

               //时间转换
               LocalDate date = LocalDate.now();

               DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

               String dateFile = date.format(dateTimeFormatter);

               File file = new File(file3, dateFile);
               System.out.println(file.mkdir());


               //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
               File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
               System.out.println(file4.mkdirs());

               System.out.println(file4.delete());

               file1.delete();
           }


           /*
           - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
           - `public boolean isDirectory()` ：此File表示的是否为目录。
           - `public boolean isFile()` ：此File表示的是否为文件。
           - public boolean canRead() ：判断是否可读
           - public boolean canWrite() ：判断是否可写
           - public boolean isHidden() ：判断是否隐藏
            */
           @Test
           public void test04(){
               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
               boolean exists = file1.exists();
               System.out.println("存在："+exists);

               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
               boolean directory = file2.isDirectory();
               System.out.println("文件夹："+directory);
               boolean file = file2.isFile();
               System.out.println("文件"+file);

               boolean b = file2.canRead();
               System.out.println("可读"+b);
               boolean w = file2.canWrite();
               System.out.println("可写"+w);

               File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
               boolean hidden = file3.isHidden();
               System.out.println("隐藏："+hidden);
           }

           /*
            * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
            * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
            */
           @Test
           public void test03(){
               //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

               File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
               String[] list = file.list();
               //遍历
               for (String s : list) {
                   System.out.println("名称："+s);
               }

               //File数组
               File[] files = file.listFiles();

               for (File file1 : files) {
                   System.out.println(file1.getName());
                   System.out.println(file1.getAbsoluteFile());
               }


           }



           /*
            * public String getName() ：获取名称
            * public String getPath() ：获取路径
            * `public String getAbsolutePath()`：获取绝对路径
            * public File getAbsoluteFile()：获取绝对路径表示的文件
            * `public String getParent()`：获取上层文件目录路径。若无，返回null
            * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
            * public long lastModified() ：获取最后一次的修改时间，毫秒值
            */
           @Test
           public void test02(){
               File file = new File("upload\\a.txt");
               System.out.println(file.getName());
               String path = file.getPath();
               System.out.println(path);
               File absoluteFile = file.getAbsoluteFile();
               System.out.println(absoluteFile);

               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
               File absoluteFile1 = file1.getAbsoluteFile();
               System.out.println(absoluteFile1);
               String path1 = file1.getPath();
               System.out.println(path1);

               //path 使用的是构建路径。
               String parent = file1.getParent();
               System.out.println("parent:"+parent);

               long length = file1.length();
               System.out.println("字节："+length);

               long l = file1.lastModified();
               Date date = new Date(l);
               System.out.println(date);

               //1.8 转换成时间 ？？？

           }

           /*
           * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
           * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
           * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

           关于路径：
           * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
           * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
             * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
             * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
            */
           @Test
           public void test01(){
               //绝对路径
               File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
               //获取名称
               System.out.println(file.getName());
               //输出
               System.out.println(file);

               //相对路径
               File file1 = new File("upload", "a.txt");// upload\\a.txt
               //获取名称
               System.out.println(file1.getName());
               //输出
               System.out.println(file1);


               //构造  public File(File parent, String child)`
               File upload = new File("upload");
               File file2 = new File(upload, "b.txt");

               //获取名称
               System.out.println(file2.getName());
               //输出
               System.out.println(file2);
           }
       }package com.lc.day17.file1;

        import org.junit.Test;

        import java.io.File;
        import java.io.IOException;
        import java.time.LocalDate;
        import java.time.format.DateTimeFormatter;
        import java.util.Date;

        /**
         * ClassName: TestFile
         * Package: com.lc.day17.file1
         * Description:
         *
         * @Author 爱扣钉-陈晨
         * @Create 2023/8/5 9:23
         * @Version 1.0
         */
        public class TestFile {


            /*
            - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
            - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
            - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
            - `public boolean delete()` ：删除文件或者文件夹
              删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
             */
            @Test
            public void test05() throws IOException {
                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                boolean newFile = file1.createNewFile();
                System.out.println(newFile);

                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                boolean mkdir = file2.mkdir();
                System.out.println(mkdir);

                File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                //时间转换
                LocalDate date = LocalDate.now();

                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                String dateFile = date.format(dateTimeFormatter);

                File file = new File(file3, dateFile);
                System.out.println(file.mkdir());


                //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                System.out.println(file4.mkdirs());

                System.out.println(file4.delete());

                file1.delete();
            }


            /*
            - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
            - `public boolean isDirectory()` ：此File表示的是否为目录。
            - `public boolean isFile()` ：此File表示的是否为文件。
            - public boolean canRead() ：判断是否可读
            - public boolean canWrite() ：判断是否可写
            - public boolean isHidden() ：判断是否隐藏
             */
            @Test
            public void test04(){
                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                boolean exists = file1.exists();
                System.out.println("存在："+exists);

                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                boolean directory = file2.isDirectory();
                System.out.println("文件夹："+directory);
                boolean file = file2.isFile();
                System.out.println("文件"+file);

                boolean b = file2.canRead();
                System.out.println("可读"+b);
                boolean w = file2.canWrite();
                System.out.println("可写"+w);

                File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                boolean hidden = file3.isHidden();
                System.out.println("隐藏："+hidden);
            }

            /*
             * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
             * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
             */
            @Test
            public void test03(){
                //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                String[] list = file.list();
                //遍历
                for (String s : list) {
                    System.out.println("名称："+s);
                }

                //File数组
                File[] files = file.listFiles();

                for (File file1 : files) {
                    System.out.println(file1.getName());
                    System.out.println(file1.getAbsoluteFile());
                }


            }



            /*
             * public String getName() ：获取名称
             * public String getPath() ：获取路径
             * `public String getAbsolutePath()`：获取绝对路径
             * public File getAbsoluteFile()：获取绝对路径表示的文件
             * `public String getParent()`：获取上层文件目录路径。若无，返回null
             * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
             * public long lastModified() ：获取最后一次的修改时间，毫秒值
             */
            @Test
            public void test02(){
                File file = new File("upload\\a.txt");
                System.out.println(file.getName());
                String path = file.getPath();
                System.out.println(path);
                File absoluteFile = file.getAbsoluteFile();
                System.out.println(absoluteFile);

                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                File absoluteFile1 = file1.getAbsoluteFile();
                System.out.println(absoluteFile1);
                String path1 = file1.getPath();
                System.out.println(path1);

                //path 使用的是构建路径。
                String parent = file1.getParent();
                System.out.println("parent:"+parent);

                long length = file1.length();
                System.out.println("字节："+length);

                long l = file1.lastModified();
                Date date = new Date(l);
                System.out.println(date);

                //1.8 转换成时间 ？？？

            }

            /*
            * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
            * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
            * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

            关于路径：
            * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
            * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
              * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
              * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
             */
            @Test
            public void test01(){
                //绝对路径
                File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                //获取名称
                System.out.println(file.getName());
                //输出
                System.out.println(file);

                //相对路径
                File file1 = new File("upload", "a.txt");// upload\\a.txt
                //获取名称
                System.out.println(file1.getName());
                //输出
                System.out.println(file1);


                //构造  public File(File parent, String child)`
                File upload = new File("upload");
                File file2 = new File(upload, "b.txt");

                //获取名称
                System.out.println(file2.getName());
                //输出
                System.out.println(file2);
            }
        }package com.lc.day17.file1;

         import org.junit.Test;

         import java.io.File;
         import java.io.IOException;
         import java.time.LocalDate;
         import java.time.format.DateTimeFormatter;
         import java.util.Date;

         /**
          * ClassName: TestFile
          * Package: com.lc.day17.file1
          * Description:
          *
          * @Author 爱扣钉-陈晨
          * @Create 2023/8/5 9:23
          * @Version 1.0
          */
         public class TestFile {


             /*
             - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
             - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
             - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
             - `public boolean delete()` ：删除文件或者文件夹
               删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
              */
             @Test
             public void test05() throws IOException {
                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                 boolean newFile = file1.createNewFile();
                 System.out.println(newFile);

                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                 boolean mkdir = file2.mkdir();
                 System.out.println(mkdir);

                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                 //时间转换
                 LocalDate date = LocalDate.now();

                 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                 String dateFile = date.format(dateTimeFormatter);

                 File file = new File(file3, dateFile);
                 System.out.println(file.mkdir());


                 //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                 File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                 System.out.println(file4.mkdirs());

                 System.out.println(file4.delete());

                 file1.delete();
             }


             /*
             - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
             - `public boolean isDirectory()` ：此File表示的是否为目录。
             - `public boolean isFile()` ：此File表示的是否为文件。
             - public boolean canRead() ：判断是否可读
             - public boolean canWrite() ：判断是否可写
             - public boolean isHidden() ：判断是否隐藏
              */
             @Test
             public void test04(){
                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                 boolean exists = file1.exists();
                 System.out.println("存在："+exists);

                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                 boolean directory = file2.isDirectory();
                 System.out.println("文件夹："+directory);
                 boolean file = file2.isFile();
                 System.out.println("文件"+file);

                 boolean b = file2.canRead();
                 System.out.println("可读"+b);
                 boolean w = file2.canWrite();
                 System.out.println("可写"+w);

                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                 boolean hidden = file3.isHidden();
                 System.out.println("隐藏："+hidden);
             }

             /*
              * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
              * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
              */
             @Test
             public void test03(){
                 //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                 File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                 String[] list = file.list();
                 //遍历
                 for (String s : list) {
                     System.out.println("名称："+s);
                 }

                 //File数组
                 File[] files = file.listFiles();

                 for (File file1 : files) {
                     System.out.println(file1.getName());
                     System.out.println(file1.getAbsoluteFile());
                 }


             }



             /*
              * public String getName() ：获取名称
              * public String getPath() ：获取路径
              * `public String getAbsolutePath()`：获取绝对路径
              * public File getAbsoluteFile()：获取绝对路径表示的文件
              * `public String getParent()`：获取上层文件目录路径。若无，返回null
              * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
              * public long lastModified() ：获取最后一次的修改时间，毫秒值
              */
             @Test
             public void test02(){
                 File file = new File("upload\\a.txt");
                 System.out.println(file.getName());
                 String path = file.getPath();
                 System.out.println(path);
                 File absoluteFile = file.getAbsoluteFile();
                 System.out.println(absoluteFile);

                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                 File absoluteFile1 = file1.getAbsoluteFile();
                 System.out.println(absoluteFile1);
                 String path1 = file1.getPath();
                 System.out.println(path1);

                 //path 使用的是构建路径。
                 String parent = file1.getParent();
                 System.out.println("parent:"+parent);

                 long length = file1.length();
                 System.out.println("字节："+length);

                 long l = file1.lastModified();
                 Date date = new Date(l);
                 System.out.println(date);

                 //1.8 转换成时间 ？？？

             }

             /*
             * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
             * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
             * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

             关于路径：
             * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
             * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
               * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
               * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
              */
             @Test
             public void test01(){
                 //绝对路径
                 File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                 //获取名称
                 System.out.println(file.getName());
                 //输出
                 System.out.println(file);

                 //相对路径
                 File file1 = new File("upload", "a.txt");// upload\\a.txt
                 //获取名称
                 System.out.println(file1.getName());
                 //输出
                 System.out.println(file1);


                 //构造  public File(File parent, String child)`
                 File upload = new File("upload");
                 File file2 = new File(upload, "b.txt");

                 //获取名称
                 System.out.println(file2.getName());
                 //输出
                 System.out.println(file2);
             }
         }package com.lc.day17.file1;

          import org.junit.Test;

          import java.io.File;
          import java.io.IOException;
          import java.time.LocalDate;
          import java.time.format.DateTimeFormatter;
          import java.util.Date;

          /**
           * ClassName: TestFile
           * Package: com.lc.day17.file1
           * Description:
           *
           * @Author 爱扣钉-陈晨
           * @Create 2023/8/5 9:23
           * @Version 1.0
           */
          public class TestFile {


              /*
              - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
              - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
              - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
              - `public boolean delete()` ：删除文件或者文件夹
                删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
               */
              @Test
              public void test05() throws IOException {
                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                  boolean newFile = file1.createNewFile();
                  System.out.println(newFile);

                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                  boolean mkdir = file2.mkdir();
                  System.out.println(mkdir);

                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                  //时间转换
                  LocalDate date = LocalDate.now();

                  DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                  String dateFile = date.format(dateTimeFormatter);

                  File file = new File(file3, dateFile);
                  System.out.println(file.mkdir());


                  //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                  File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                  System.out.println(file4.mkdirs());

                  System.out.println(file4.delete());

                  file1.delete();
              }


              /*
              - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
              - `public boolean isDirectory()` ：此File表示的是否为目录。
              - `public boolean isFile()` ：此File表示的是否为文件。
              - public boolean canRead() ：判断是否可读
              - public boolean canWrite() ：判断是否可写
              - public boolean isHidden() ：判断是否隐藏
               */
              @Test
              public void test04(){
                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                  boolean exists = file1.exists();
                  System.out.println("存在："+exists);

                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                  boolean directory = file2.isDirectory();
                  System.out.println("文件夹："+directory);
                  boolean file = file2.isFile();
                  System.out.println("文件"+file);

                  boolean b = file2.canRead();
                  System.out.println("可读"+b);
                  boolean w = file2.canWrite();
                  System.out.println("可写"+w);

                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                  boolean hidden = file3.isHidden();
                  System.out.println("隐藏："+hidden);
              }

              /*
               * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
               * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
               */
              @Test
              public void test03(){
                  //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                  File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                  String[] list = file.list();
                  //遍历
                  for (String s : list) {
                      System.out.println("名称："+s);
                  }

                  //File数组
                  File[] files = file.listFiles();

                  for (File file1 : files) {
                      System.out.println(file1.getName());
                      System.out.println(file1.getAbsoluteFile());
                  }


              }



              /*
               * public String getName() ：获取名称
               * public String getPath() ：获取路径
               * `public String getAbsolutePath()`：获取绝对路径
               * public File getAbsoluteFile()：获取绝对路径表示的文件
               * `public String getParent()`：获取上层文件目录路径。若无，返回null
               * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
               * public long lastModified() ：获取最后一次的修改时间，毫秒值
               */
              @Test
              public void test02(){
                  File file = new File("upload\\a.txt");
                  System.out.println(file.getName());
                  String path = file.getPath();
                  System.out.println(path);
                  File absoluteFile = file.getAbsoluteFile();
                  System.out.println(absoluteFile);

                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                  File absoluteFile1 = file1.getAbsoluteFile();
                  System.out.println(absoluteFile1);
                  String path1 = file1.getPath();
                  System.out.println(path1);

                  //path 使用的是构建路径。
                  String parent = file1.getParent();
                  System.out.println("parent:"+parent);

                  long length = file1.length();
                  System.out.println("字节："+length);

                  long l = file1.lastModified();
                  Date date = new Date(l);
                  System.out.println(date);

                  //1.8 转换成时间 ？？？

              }

              /*
              * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
              * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
              * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

              关于路径：
              * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
              * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
               */
              @Test
              public void test01(){
                  //绝对路径
                  File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                  //获取名称
                  System.out.println(file.getName());
                  //输出
                  System.out.println(file);

                  //相对路径
                  File file1 = new File("upload", "a.txt");// upload\\a.txt
                  //获取名称
                  System.out.println(file1.getName());
                  //输出
                  System.out.println(file1);


                  //构造  public File(File parent, String child)`
                  File upload = new File("upload");
                  File file2 = new File(upload, "b.txt");

                  //获取名称
                  System.out.println(file2.getName());
                  //输出
                  System.out.println(file2);
              }
          }package com.lc.day17.file1;

           import org.junit.Test;

           import java.io.File;
           import java.io.IOException;
           import java.time.LocalDate;
           import java.time.format.DateTimeFormatter;
           import java.util.Date;

           /**
            * ClassName: TestFile
            * Package: com.lc.day17.file1
            * Description:
            *
            * @Author 爱扣钉-陈晨
            * @Create 2023/8/5 9:23
            * @Version 1.0
            */
           public class TestFile {


               /*
               - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
               - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
               - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
               - `public boolean delete()` ：删除文件或者文件夹
                 删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                */
               @Test
               public void test05() throws IOException {
                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                   boolean newFile = file1.createNewFile();
                   System.out.println(newFile);

                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                   boolean mkdir = file2.mkdir();
                   System.out.println(mkdir);

                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                   //时间转换
                   LocalDate date = LocalDate.now();

                   DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                   String dateFile = date.format(dateTimeFormatter);

                   File file = new File(file3, dateFile);
                   System.out.println(file.mkdir());


                   //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                   File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                   System.out.println(file4.mkdirs());

                   System.out.println(file4.delete());

                   file1.delete();
               }


               /*
               - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
               - `public boolean isDirectory()` ：此File表示的是否为目录。
               - `public boolean isFile()` ：此File表示的是否为文件。
               - public boolean canRead() ：判断是否可读
               - public boolean canWrite() ：判断是否可写
               - public boolean isHidden() ：判断是否隐藏
                */
               @Test
               public void test04(){
                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                   boolean exists = file1.exists();
                   System.out.println("存在："+exists);

                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                   boolean directory = file2.isDirectory();
                   System.out.println("文件夹："+directory);
                   boolean file = file2.isFile();
                   System.out.println("文件"+file);

                   boolean b = file2.canRead();
                   System.out.println("可读"+b);
                   boolean w = file2.canWrite();
                   System.out.println("可写"+w);

                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                   boolean hidden = file3.isHidden();
                   System.out.println("隐藏："+hidden);
               }

               /*
                * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                */
               @Test
               public void test03(){
                   //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                   File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                   String[] list = file.list();
                   //遍历
                   for (String s : list) {
                       System.out.println("名称："+s);
                   }

                   //File数组
                   File[] files = file.listFiles();

                   for (File file1 : files) {
                       System.out.println(file1.getName());
                       System.out.println(file1.getAbsoluteFile());
                   }


               }



               /*
                * public String getName() ：获取名称
                * public String getPath() ：获取路径
                * `public String getAbsolutePath()`：获取绝对路径
                * public File getAbsoluteFile()：获取绝对路径表示的文件
                * `public String getParent()`：获取上层文件目录路径。若无，返回null
                * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                * public long lastModified() ：获取最后一次的修改时间，毫秒值
                */
               @Test
               public void test02(){
                   File file = new File("upload\\a.txt");
                   System.out.println(file.getName());
                   String path = file.getPath();
                   System.out.println(path);
                   File absoluteFile = file.getAbsoluteFile();
                   System.out.println(absoluteFile);

                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                   File absoluteFile1 = file1.getAbsoluteFile();
                   System.out.println(absoluteFile1);
                   String path1 = file1.getPath();
                   System.out.println(path1);

                   //path 使用的是构建路径。
                   String parent = file1.getParent();
                   System.out.println("parent:"+parent);

                   long length = file1.length();
                   System.out.println("字节："+length);

                   long l = file1.lastModified();
                   Date date = new Date(l);
                   System.out.println(date);

                   //1.8 转换成时间 ？？？

               }

               /*
               * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
               * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
               * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

               关于路径：
               * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
               * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                 * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                 * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                */
               @Test
               public void test01(){
                   //绝对路径
                   File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                   //获取名称
                   System.out.println(file.getName());
                   //输出
                   System.out.println(file);

                   //相对路径
                   File file1 = new File("upload", "a.txt");// upload\\a.txt
                   //获取名称
                   System.out.println(file1.getName());
                   //输出
                   System.out.println(file1);


                   //构造  public File(File parent, String child)`
                   File upload = new File("upload");
                   File file2 = new File(upload, "b.txt");

                   //获取名称
                   System.out.println(file2.getName());
                   //输出
                   System.out.println(file2);
               }
           }package com.lc.day17.file1;

            import org.junit.Test;

            import java.io.File;
            import java.io.IOException;
            import java.time.LocalDate;
            import java.time.format.DateTimeFormatter;
            import java.util.Date;

            /**
             * ClassName: TestFile
             * Package: com.lc.day17.file1
             * Description:
             *
             * @Author 爱扣钉-陈晨
             * @Create 2023/8/5 9:23
             * @Version 1.0
             */
            public class TestFile {


                /*
                - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                - `public boolean delete()` ：删除文件或者文件夹
                  删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                 */
                @Test
                public void test05() throws IOException {
                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                    boolean newFile = file1.createNewFile();
                    System.out.println(newFile);

                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                    boolean mkdir = file2.mkdir();
                    System.out.println(mkdir);

                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                    //时间转换
                    LocalDate date = LocalDate.now();

                    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                    String dateFile = date.format(dateTimeFormatter);

                    File file = new File(file3, dateFile);
                    System.out.println(file.mkdir());


                    //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                    File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                    System.out.println(file4.mkdirs());

                    System.out.println(file4.delete());

                    file1.delete();
                }


                /*
                - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                - `public boolean isDirectory()` ：此File表示的是否为目录。
                - `public boolean isFile()` ：此File表示的是否为文件。
                - public boolean canRead() ：判断是否可读
                - public boolean canWrite() ：判断是否可写
                - public boolean isHidden() ：判断是否隐藏
                 */
                @Test
                public void test04(){
                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                    boolean exists = file1.exists();
                    System.out.println("存在："+exists);

                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                    boolean directory = file2.isDirectory();
                    System.out.println("文件夹："+directory);
                    boolean file = file2.isFile();
                    System.out.println("文件"+file);

                    boolean b = file2.canRead();
                    System.out.println("可读"+b);
                    boolean w = file2.canWrite();
                    System.out.println("可写"+w);

                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                    boolean hidden = file3.isHidden();
                    System.out.println("隐藏："+hidden);
                }

                /*
                 * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                 * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                 */
                @Test
                public void test03(){
                    //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                    File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                    String[] list = file.list();
                    //遍历
                    for (String s : list) {
                        System.out.println("名称："+s);
                    }

                    //File数组
                    File[] files = file.listFiles();

                    for (File file1 : files) {
                        System.out.println(file1.getName());
                        System.out.println(file1.getAbsoluteFile());
                    }


                }



                /*
                 * public String getName() ：获取名称
                 * public String getPath() ：获取路径
                 * `public String getAbsolutePath()`：获取绝对路径
                 * public File getAbsoluteFile()：获取绝对路径表示的文件
                 * `public String getParent()`：获取上层文件目录路径。若无，返回null
                 * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                 * public long lastModified() ：获取最后一次的修改时间，毫秒值
                 */
                @Test
                public void test02(){
                    File file = new File("upload\\a.txt");
                    System.out.println(file.getName());
                    String path = file.getPath();
                    System.out.println(path);
                    File absoluteFile = file.getAbsoluteFile();
                    System.out.println(absoluteFile);

                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                    File absoluteFile1 = file1.getAbsoluteFile();
                    System.out.println(absoluteFile1);
                    String path1 = file1.getPath();
                    System.out.println(path1);

                    //path 使用的是构建路径。
                    String parent = file1.getParent();
                    System.out.println("parent:"+parent);

                    long length = file1.length();
                    System.out.println("字节："+length);

                    long l = file1.lastModified();
                    Date date = new Date(l);
                    System.out.println(date);

                    //1.8 转换成时间 ？？？

                }

                /*
                * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                关于路径：
                * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                  * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                  * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                 */
                @Test
                public void test01(){
                    //绝对路径
                    File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                    //获取名称
                    System.out.println(file.getName());
                    //输出
                    System.out.println(file);

                    //相对路径
                    File file1 = new File("upload", "a.txt");// upload\\a.txt
                    //获取名称
                    System.out.println(file1.getName());
                    //输出
                    System.out.println(file1);


                    //构造  public File(File parent, String child)`
                    File upload = new File("upload");
                    File file2 = new File(upload, "b.txt");

                    //获取名称
                    System.out.println(file2.getName());
                    //输出
                    System.out.println(file2);
                }
            }package com.lc.day17.file1;

             import org.junit.Test;

             import java.io.File;
             import java.io.IOException;
             import java.time.LocalDate;
             import java.time.format.DateTimeFormatter;
             import java.util.Date;

             /**
              * ClassName: TestFile
              * Package: com.lc.day17.file1
              * Description:
              *
              * @Author 爱扣钉-陈晨
              * @Create 2023/8/5 9:23
              * @Version 1.0
              */
             public class TestFile {


                 /*
                 - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                 - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                 - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                 - `public boolean delete()` ：删除文件或者文件夹
                   删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                  */
                 @Test
                 public void test05() throws IOException {
                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                     boolean newFile = file1.createNewFile();
                     System.out.println(newFile);

                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                     boolean mkdir = file2.mkdir();
                     System.out.println(mkdir);

                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                     //时间转换
                     LocalDate date = LocalDate.now();

                     DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                     String dateFile = date.format(dateTimeFormatter);

                     File file = new File(file3, dateFile);
                     System.out.println(file.mkdir());


                     //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                     File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                     System.out.println(file4.mkdirs());

                     System.out.println(file4.delete());

                     file1.delete();
                 }


                 /*
                 - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                 - `public boolean isDirectory()` ：此File表示的是否为目录。
                 - `public boolean isFile()` ：此File表示的是否为文件。
                 - public boolean canRead() ：判断是否可读
                 - public boolean canWrite() ：判断是否可写
                 - public boolean isHidden() ：判断是否隐藏
                  */
                 @Test
                 public void test04(){
                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                     boolean exists = file1.exists();
                     System.out.println("存在："+exists);

                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                     boolean directory = file2.isDirectory();
                     System.out.println("文件夹："+directory);
                     boolean file = file2.isFile();
                     System.out.println("文件"+file);

                     boolean b = file2.canRead();
                     System.out.println("可读"+b);
                     boolean w = file2.canWrite();
                     System.out.println("可写"+w);

                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                     boolean hidden = file3.isHidden();
                     System.out.println("隐藏："+hidden);
                 }

                 /*
                  * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                  * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                  */
                 @Test
                 public void test03(){
                     //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                     File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                     String[] list = file.list();
                     //遍历
                     for (String s : list) {
                         System.out.println("名称："+s);
                     }

                     //File数组
                     File[] files = file.listFiles();

                     for (File file1 : files) {
                         System.out.println(file1.getName());
                         System.out.println(file1.getAbsoluteFile());
                     }


                 }



                 /*
                  * public String getName() ：获取名称
                  * public String getPath() ：获取路径
                  * `public String getAbsolutePath()`：获取绝对路径
                  * public File getAbsoluteFile()：获取绝对路径表示的文件
                  * `public String getParent()`：获取上层文件目录路径。若无，返回null
                  * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                  * public long lastModified() ：获取最后一次的修改时间，毫秒值
                  */
                 @Test
                 public void test02(){
                     File file = new File("upload\\a.txt");
                     System.out.println(file.getName());
                     String path = file.getPath();
                     System.out.println(path);
                     File absoluteFile = file.getAbsoluteFile();
                     System.out.println(absoluteFile);

                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                     File absoluteFile1 = file1.getAbsoluteFile();
                     System.out.println(absoluteFile1);
                     String path1 = file1.getPath();
                     System.out.println(path1);

                     //path 使用的是构建路径。
                     String parent = file1.getParent();
                     System.out.println("parent:"+parent);

                     long length = file1.length();
                     System.out.println("字节："+length);

                     long l = file1.lastModified();
                     Date date = new Date(l);
                     System.out.println(date);

                     //1.8 转换成时间 ？？？

                 }

                 /*
                 * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                 * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                 * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                 关于路径：
                 * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                 * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                   * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                   * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                  */
                 @Test
                 public void test01(){
                     //绝对路径
                     File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                     //获取名称
                     System.out.println(file.getName());
                     //输出
                     System.out.println(file);

                     //相对路径
                     File file1 = new File("upload", "a.txt");// upload\\a.txt
                     //获取名称
                     System.out.println(file1.getName());
                     //输出
                     System.out.println(file1);


                     //构造  public File(File parent, String child)`
                     File upload = new File("upload");
                     File file2 = new File(upload, "b.txt");

                     //获取名称
                     System.out.println(file2.getName());
                     //输出
                     System.out.println(file2);
                 }
             }package com.lc.day17.file1;

              import org.junit.Test;

              import java.io.File;
              import java.io.IOException;
              import java.time.LocalDate;
              import java.time.format.DateTimeFormatter;
              import java.util.Date;

              /**
               * ClassName: TestFile
               * Package: com.lc.day17.file1
               * Description:
               *
               * @Author 爱扣钉-陈晨
               * @Create 2023/8/5 9:23
               * @Version 1.0
               */
              public class TestFile {


                  /*
                  - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                  - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                  - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                  - `public boolean delete()` ：删除文件或者文件夹
                    删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                   */
                  @Test
                  public void test05() throws IOException {
                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                      boolean newFile = file1.createNewFile();
                      System.out.println(newFile);

                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                      boolean mkdir = file2.mkdir();
                      System.out.println(mkdir);

                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                      //时间转换
                      LocalDate date = LocalDate.now();

                      DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                      String dateFile = date.format(dateTimeFormatter);

                      File file = new File(file3, dateFile);
                      System.out.println(file.mkdir());


                      //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                      File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                      System.out.println(file4.mkdirs());

                      System.out.println(file4.delete());

                      file1.delete();
                  }


                  /*
                  - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                  - `public boolean isDirectory()` ：此File表示的是否为目录。
                  - `public boolean isFile()` ：此File表示的是否为文件。
                  - public boolean canRead() ：判断是否可读
                  - public boolean canWrite() ：判断是否可写
                  - public boolean isHidden() ：判断是否隐藏
                   */
                  @Test
                  public void test04(){
                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                      boolean exists = file1.exists();
                      System.out.println("存在："+exists);

                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                      boolean directory = file2.isDirectory();
                      System.out.println("文件夹："+directory);
                      boolean file = file2.isFile();
                      System.out.println("文件"+file);

                      boolean b = file2.canRead();
                      System.out.println("可读"+b);
                      boolean w = file2.canWrite();
                      System.out.println("可写"+w);

                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                      boolean hidden = file3.isHidden();
                      System.out.println("隐藏："+hidden);
                  }

                  /*
                   * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                   * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                   */
                  @Test
                  public void test03(){
                      //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                      File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                      String[] list = file.list();
                      //遍历
                      for (String s : list) {
                          System.out.println("名称："+s);
                      }

                      //File数组
                      File[] files = file.listFiles();

                      for (File file1 : files) {
                          System.out.println(file1.getName());
                          System.out.println(file1.getAbsoluteFile());
                      }


                  }



                  /*
                   * public String getName() ：获取名称
                   * public String getPath() ：获取路径
                   * `public String getAbsolutePath()`：获取绝对路径
                   * public File getAbsoluteFile()：获取绝对路径表示的文件
                   * `public String getParent()`：获取上层文件目录路径。若无，返回null
                   * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                   * public long lastModified() ：获取最后一次的修改时间，毫秒值
                   */
                  @Test
                  public void test02(){
                      File file = new File("upload\\a.txt");
                      System.out.println(file.getName());
                      String path = file.getPath();
                      System.out.println(path);
                      File absoluteFile = file.getAbsoluteFile();
                      System.out.println(absoluteFile);

                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                      File absoluteFile1 = file1.getAbsoluteFile();
                      System.out.println(absoluteFile1);
                      String path1 = file1.getPath();
                      System.out.println(path1);

                      //path 使用的是构建路径。
                      String parent = file1.getParent();
                      System.out.println("parent:"+parent);

                      long length = file1.length();
                      System.out.println("字节："+length);

                      long l = file1.lastModified();
                      Date date = new Date(l);
                      System.out.println(date);

                      //1.8 转换成时间 ？？？

                  }

                  /*
                  * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                  * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                  * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                  关于路径：
                  * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                  * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                    * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                    * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                   */
                  @Test
                  public void test01(){
                      //绝对路径
                      File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                      //获取名称
                      System.out.println(file.getName());
                      //输出
                      System.out.println(file);

                      //相对路径
                      File file1 = new File("upload", "a.txt");// upload\\a.txt
                      //获取名称
                      System.out.println(file1.getName());
                      //输出
                      System.out.println(file1);


                      //构造  public File(File parent, String child)`
                      File upload = new File("upload");
                      File file2 = new File(upload, "b.txt");

                      //获取名称
                      System.out.println(file2.getName());
                      //输出
                      System.out.println(file2);
                  }
              }package com.lc.day17.file1;

               import org.junit.Test;

               import java.io.File;
               import java.io.IOException;
               import java.time.LocalDate;
               import java.time.format.DateTimeFormatter;
               import java.util.Date;

               /**
                * ClassName: TestFile
                * Package: com.lc.day17.file1
                * Description:
                *
                * @Author 爱扣钉-陈晨
                * @Create 2023/8/5 9:23
                * @Version 1.0
                */
               public class TestFile {


                   /*
                   - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                   - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                   - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                   - `public boolean delete()` ：删除文件或者文件夹
                     删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                    */
                   @Test
                   public void test05() throws IOException {
                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                       boolean newFile = file1.createNewFile();
                       System.out.println(newFile);

                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                       boolean mkdir = file2.mkdir();
                       System.out.println(mkdir);

                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                       //时间转换
                       LocalDate date = LocalDate.now();

                       DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                       String dateFile = date.format(dateTimeFormatter);

                       File file = new File(file3, dateFile);
                       System.out.println(file.mkdir());


                       //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                       File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                       System.out.println(file4.mkdirs());

                       System.out.println(file4.delete());

                       file1.delete();
                   }


                   /*
                   - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                   - `public boolean isDirectory()` ：此File表示的是否为目录。
                   - `public boolean isFile()` ：此File表示的是否为文件。
                   - public boolean canRead() ：判断是否可读
                   - public boolean canWrite() ：判断是否可写
                   - public boolean isHidden() ：判断是否隐藏
                    */
                   @Test
                   public void test04(){
                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                       boolean exists = file1.exists();
                       System.out.println("存在："+exists);

                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                       boolean directory = file2.isDirectory();
                       System.out.println("文件夹："+directory);
                       boolean file = file2.isFile();
                       System.out.println("文件"+file);

                       boolean b = file2.canRead();
                       System.out.println("可读"+b);
                       boolean w = file2.canWrite();
                       System.out.println("可写"+w);

                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                       boolean hidden = file3.isHidden();
                       System.out.println("隐藏："+hidden);
                   }

                   /*
                    * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                    * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                    */
                   @Test
                   public void test03(){
                       //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                       File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                       String[] list = file.list();
                       //遍历
                       for (String s : list) {
                           System.out.println("名称："+s);
                       }

                       //File数组
                       File[] files = file.listFiles();

                       for (File file1 : files) {
                           System.out.println(file1.getName());
                           System.out.println(file1.getAbsoluteFile());
                       }


                   }



                   /*
                    * public String getName() ：获取名称
                    * public String getPath() ：获取路径
                    * `public String getAbsolutePath()`：获取绝对路径
                    * public File getAbsoluteFile()：获取绝对路径表示的文件
                    * `public String getParent()`：获取上层文件目录路径。若无，返回null
                    * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                    * public long lastModified() ：获取最后一次的修改时间，毫秒值
                    */
                   @Test
                   public void test02(){
                       File file = new File("upload\\a.txt");
                       System.out.println(file.getName());
                       String path = file.getPath();
                       System.out.println(path);
                       File absoluteFile = file.getAbsoluteFile();
                       System.out.println(absoluteFile);

                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                       File absoluteFile1 = file1.getAbsoluteFile();
                       System.out.println(absoluteFile1);
                       String path1 = file1.getPath();
                       System.out.println(path1);

                       //path 使用的是构建路径。
                       String parent = file1.getParent();
                       System.out.println("parent:"+parent);

                       long length = file1.length();
                       System.out.println("字节："+length);

                       long l = file1.lastModified();
                       Date date = new Date(l);
                       System.out.println(date);

                       //1.8 转换成时间 ？？？

                   }

                   /*
                   * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                   * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                   * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                   关于路径：
                   * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                   * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                     * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                     * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                    */
                   @Test
                   public void test01(){
                       //绝对路径
                       File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                       //获取名称
                       System.out.println(file.getName());
                       //输出
                       System.out.println(file);

                       //相对路径
                       File file1 = new File("upload", "a.txt");// upload\\a.txt
                       //获取名称
                       System.out.println(file1.getName());
                       //输出
                       System.out.println(file1);


                       //构造  public File(File parent, String child)`
                       File upload = new File("upload");
                       File file2 = new File(upload, "b.txt");

                       //获取名称
                       System.out.println(file2.getName());
                       //输出
                       System.out.println(file2);
                   }
               }package com.lc.day17.file1;

                import org.junit.Test;

                import java.io.File;
                import java.io.IOException;
                import java.time.LocalDate;
                import java.time.format.DateTimeFormatter;
                import java.util.Date;

                /**
                 * ClassName: TestFile
                 * Package: com.lc.day17.file1
                 * Description:
                 *
                 * @Author 爱扣钉-陈晨
                 * @Create 2023/8/5 9:23
                 * @Version 1.0
                 */
                public class TestFile {


                    /*
                    - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                    - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                    - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                    - `public boolean delete()` ：删除文件或者文件夹
                      删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                     */
                    @Test
                    public void test05() throws IOException {
                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                        boolean newFile = file1.createNewFile();
                        System.out.println(newFile);

                        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                        boolean mkdir = file2.mkdir();
                        System.out.println(mkdir);

                        File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                        //时间转换
                        LocalDate date = LocalDate.now();

                        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                        String dateFile = date.format(dateTimeFormatter);

                        File file = new File(file3, dateFile);
                        System.out.println(file.mkdir());


                        //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                        File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                        System.out.println(file4.mkdirs());

                        System.out.println(file4.delete());

                        file1.delete();
                    }


                    /*
                    - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                    - `public boolean isDirectory()` ：此File表示的是否为目录。
                    - `public boolean isFile()` ：此File表示的是否为文件。
                    - public boolean canRead() ：判断是否可读
                    - public boolean canWrite() ：判断是否可写
                    - public boolean isHidden() ：判断是否隐藏
                     */
                    @Test
                    public void test04(){
                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                        boolean exists = file1.exists();
                        System.out.println("存在："+exists);

                        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                        boolean directory = file2.isDirectory();
                        System.out.println("文件夹："+directory);
                        boolean file = file2.isFile();
                        System.out.println("文件"+file);

                        boolean b = file2.canRead();
                        System.out.println("可读"+b);
                        boolean w = file2.canWrite();
                        System.out.println("可写"+w);

                        File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                        boolean hidden = file3.isHidden();
                        System.out.println("隐藏："+hidden);
                    }

                    /*
                     * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                     * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                     */
                    @Test
                    public void test03(){
                        //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                        File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                        String[] list = file.list();
                        //遍历
                        for (String s : list) {
                            System.out.println("名称："+s);
                        }

                        //File数组
                        File[] files = file.listFiles();

                        for (File file1 : files) {
                            System.out.println(file1.getName());
                            System.out.println(file1.getAbsoluteFile());
                        }


                    }



                    /*
                     * public String getName() ：获取名称
                     * public String getPath() ：获取路径
                     * `public String getAbsolutePath()`：获取绝对路径
                     * public File getAbsoluteFile()：获取绝对路径表示的文件
                     * `public String getParent()`：获取上层文件目录路径。若无，返回null
                     * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                     * public long lastModified() ：获取最后一次的修改时间，毫秒值
                     */
                    @Test
                    public void test02(){
                        File file = new File("upload\\a.txt");
                        System.out.println(file.getName());
                        String path = file.getPath();
                        System.out.println(path);
                        File absoluteFile = file.getAbsoluteFile();
                        System.out.println(absoluteFile);

                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                        File absoluteFile1 = file1.getAbsoluteFile();
                        System.out.println(absoluteFile1);
                        String path1 = file1.getPath();
                        System.out.println(path1);

                        //path 使用的是构建路径。
                        String parent = file1.getParent();
                        System.out.println("parent:"+parent);

                        long length = file1.length();
                        System.out.println("字节："+length);

                        long l = file1.lastModified();
                        Date date = new Date(l);
                        System.out.println(date);

                        //1.8 转换成时间 ？？？

                    }

                    /*
                    * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                    * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                    * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                    关于路径：
                    * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                    * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                      * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                      * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                     */
                    @Test
                    public void test01(){
                        //绝对路径
                        File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                        //获取名称
                        System.out.println(file.getName());
                        //输出
                        System.out.println(file);

                        //相对路径
                        File file1 = new File("upload", "a.txt");// upload\\a.txt
                        //获取名称
                        System.out.println(file1.getName());
                        //输出
                        System.out.println(file1);


                        //构造  public File(File parent, String child)`
                        File upload = new File("upload");
                        File file2 = new File(upload, "b.txt");

                        //获取名称
                        System.out.println(file2.getName());
                        //输出
                        System.out.println(file2);
                    }
                }package com.lc.day17.file1;

                 import org.junit.Test;

                 import java.io.File;
                 import java.io.IOException;
                 import java.time.LocalDate;
                 import java.time.format.DateTimeFormatter;
                 import java.util.Date;

                 /**
                  * ClassName: TestFile
                  * Package: com.lc.day17.file1
                  * Description:
                  *
                  * @Author 爱扣钉-陈晨
                  * @Create 2023/8/5 9:23
                  * @Version 1.0
                  */
                 public class TestFile {


                     /*
                     - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                     - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                     - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                     - `public boolean delete()` ：删除文件或者文件夹
                       删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                      */
                     @Test
                     public void test05() throws IOException {
                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                         boolean newFile = file1.createNewFile();
                         System.out.println(newFile);

                         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                         boolean mkdir = file2.mkdir();
                         System.out.println(mkdir);

                         File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                         //时间转换
                         LocalDate date = LocalDate.now();

                         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                         String dateFile = date.format(dateTimeFormatter);

                         File file = new File(file3, dateFile);
                         System.out.println(file.mkdir());


                         //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                         File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                         System.out.println(file4.mkdirs());

                         System.out.println(file4.delete());

                         file1.delete();
                     }


                     /*
                     - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                     - `public boolean isDirectory()` ：此File表示的是否为目录。
                     - `public boolean isFile()` ：此File表示的是否为文件。
                     - public boolean canRead() ：判断是否可读
                     - public boolean canWrite() ：判断是否可写
                     - public boolean isHidden() ：判断是否隐藏
                      */
                     @Test
                     public void test04(){
                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                         boolean exists = file1.exists();
                         System.out.println("存在："+exists);

                         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                         boolean directory = file2.isDirectory();
                         System.out.println("文件夹："+directory);
                         boolean file = file2.isFile();
                         System.out.println("文件"+file);

                         boolean b = file2.canRead();
                         System.out.println("可读"+b);
                         boolean w = file2.canWrite();
                         System.out.println("可写"+w);

                         File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                         boolean hidden = file3.isHidden();
                         System.out.println("隐藏："+hidden);
                     }

                     /*
                      * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                      * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                      */
                     @Test
                     public void test03(){
                         //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                         File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                         String[] list = file.list();
                         //遍历
                         for (String s : list) {
                             System.out.println("名称："+s);
                         }

                         //File数组
                         File[] files = file.listFiles();

                         for (File file1 : files) {
                             System.out.println(file1.getName());
                             System.out.println(file1.getAbsoluteFile());
                         }


                     }



                     /*
                      * public String getName() ：获取名称
                      * public String getPath() ：获取路径
                      * `public String getAbsolutePath()`：获取绝对路径
                      * public File getAbsoluteFile()：获取绝对路径表示的文件
                      * `public String getParent()`：获取上层文件目录路径。若无，返回null
                      * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                      * public long lastModified() ：获取最后一次的修改时间，毫秒值
                      */
                     @Test
                     public void test02(){
                         File file = new File("upload\\a.txt");
                         System.out.println(file.getName());
                         String path = file.getPath();
                         System.out.println(path);
                         File absoluteFile = file.getAbsoluteFile();
                         System.out.println(absoluteFile);

                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                         File absoluteFile1 = file1.getAbsoluteFile();
                         System.out.println(absoluteFile1);
                         String path1 = file1.getPath();
                         System.out.println(path1);

                         //path 使用的是构建路径。
                         String parent = file1.getParent();
                         System.out.println("parent:"+parent);

                         long length = file1.length();
                         System.out.println("字节："+length);

                         long l = file1.lastModified();
                         Date date = new Date(l);
                         System.out.println(date);

                         //1.8 转换成时间 ？？？

                     }

                     /*
                     * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                     * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                     * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                     关于路径：
                     * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                     * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                       * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                       * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                      */
                     @Test
                     public void test01(){
                         //绝对路径
                         File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                         //获取名称
                         System.out.println(file.getName());
                         //输出
                         System.out.println(file);

                         //相对路径
                         File file1 = new File("upload", "a.txt");// upload\\a.txt
                         //获取名称
                         System.out.println(file1.getName());
                         //输出
                         System.out.println(file1);


                         //构造  public File(File parent, String child)`
                         File upload = new File("upload");
                         File file2 = new File(upload, "b.txt");

                         //获取名称
                         System.out.println(file2.getName());
                         //输出
                         System.out.println(file2);
                     }
                 }package com.lc.day17.file1;

                  import org.junit.Test;

                  import java.io.File;
                  import java.io.IOException;
                  import java.time.LocalDate;
                  import java.time.format.DateTimeFormatter;
                  import java.util.Date;

                  /**
                   * ClassName: TestFile
                   * Package: com.lc.day17.file1
                   * Description:
                   *
                   * @Author 爱扣钉-陈晨
                   * @Create 2023/8/5 9:23
                   * @Version 1.0
                   */
                  public class TestFile {


                      /*
                      - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                      - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                      - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                      - `public boolean delete()` ：删除文件或者文件夹
                        删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                       */
                      @Test
                      public void test05() throws IOException {
                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                          boolean newFile = file1.createNewFile();
                          System.out.println(newFile);

                          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                          boolean mkdir = file2.mkdir();
                          System.out.println(mkdir);

                          File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                          //时间转换
                          LocalDate date = LocalDate.now();

                          DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                          String dateFile = date.format(dateTimeFormatter);

                          File file = new File(file3, dateFile);
                          System.out.println(file.mkdir());


                          //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                          File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                          System.out.println(file4.mkdirs());

                          System.out.println(file4.delete());

                          file1.delete();
                      }


                      /*
                      - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                      - `public boolean isDirectory()` ：此File表示的是否为目录。
                      - `public boolean isFile()` ：此File表示的是否为文件。
                      - public boolean canRead() ：判断是否可读
                      - public boolean canWrite() ：判断是否可写
                      - public boolean isHidden() ：判断是否隐藏
                       */
                      @Test
                      public void test04(){
                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                          boolean exists = file1.exists();
                          System.out.println("存在："+exists);

                          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                          boolean directory = file2.isDirectory();
                          System.out.println("文件夹："+directory);
                          boolean file = file2.isFile();
                          System.out.println("文件"+file);

                          boolean b = file2.canRead();
                          System.out.println("可读"+b);
                          boolean w = file2.canWrite();
                          System.out.println("可写"+w);

                          File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                          boolean hidden = file3.isHidden();
                          System.out.println("隐藏："+hidden);
                      }

                      /*
                       * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                       * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                       */
                      @Test
                      public void test03(){
                          //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                          File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                          String[] list = file.list();
                          //遍历
                          for (String s : list) {
                              System.out.println("名称："+s);
                          }

                          //File数组
                          File[] files = file.listFiles();

                          for (File file1 : files) {
                              System.out.println(file1.getName());
                              System.out.println(file1.getAbsoluteFile());
                          }


                      }



                      /*
                       * public String getName() ：获取名称
                       * public String getPath() ：获取路径
                       * `public String getAbsolutePath()`：获取绝对路径
                       * public File getAbsoluteFile()：获取绝对路径表示的文件
                       * `public String getParent()`：获取上层文件目录路径。若无，返回null
                       * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                       * public long lastModified() ：获取最后一次的修改时间，毫秒值
                       */
                      @Test
                      public void test02(){
                          File file = new File("upload\\a.txt");
                          System.out.println(file.getName());
                          String path = file.getPath();
                          System.out.println(path);
                          File absoluteFile = file.getAbsoluteFile();
                          System.out.println(absoluteFile);

                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                          File absoluteFile1 = file1.getAbsoluteFile();
                          System.out.println(absoluteFile1);
                          String path1 = file1.getPath();
                          System.out.println(path1);

                          //path 使用的是构建路径。
                          String parent = file1.getParent();
                          System.out.println("parent:"+parent);

                          long length = file1.length();
                          System.out.println("字节："+length);

                          long l = file1.lastModified();
                          Date date = new Date(l);
                          System.out.println(date);

                          //1.8 转换成时间 ？？？

                      }

                      /*
                      * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                      * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                      * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                      关于路径：
                      * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                      * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                        * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                        * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                       */
                      @Test
                      public void test01(){
                          //绝对路径
                          File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                          //获取名称
                          System.out.println(file.getName());
                          //输出
                          System.out.println(file);

                          //相对路径
                          File file1 = new File("upload", "a.txt");// upload\\a.txt
                          //获取名称
                          System.out.println(file1.getName());
                          //输出
                          System.out.println(file1);


                          //构造  public File(File parent, String child)`
                          File upload = new File("upload");
                          File file2 = new File(upload, "b.txt");

                          //获取名称
                          System.out.println(file2.getName());
                          //输出
                          System.out.println(file2);
                      }
                  }package com.lc.day17.file1;

                   import org.junit.Test;

                   import java.io.File;
                   import java.io.IOException;
                   import java.time.LocalDate;
                   import java.time.format.DateTimeFormatter;
                   import java.util.Date;

                   /**
                    * ClassName: TestFile
                    * Package: com.lc.day17.file1
                    * Description:
                    *
                    * @Author 爱扣钉-陈晨
                    * @Create 2023/8/5 9:23
                    * @Version 1.0
                    */
                   public class TestFile {


                       /*
                       - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                       - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                       - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                       - `public boolean delete()` ：删除文件或者文件夹
                         删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                        */
                       @Test
                       public void test05() throws IOException {
                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                           boolean newFile = file1.createNewFile();
                           System.out.println(newFile);

                           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                           boolean mkdir = file2.mkdir();
                           System.out.println(mkdir);

                           File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                           //时间转换
                           LocalDate date = LocalDate.now();

                           DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                           String dateFile = date.format(dateTimeFormatter);

                           File file = new File(file3, dateFile);
                           System.out.println(file.mkdir());


                           //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                           File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                           System.out.println(file4.mkdirs());

                           System.out.println(file4.delete());

                           file1.delete();
                       }


                       /*
                       - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                       - `public boolean isDirectory()` ：此File表示的是否为目录。
                       - `public boolean isFile()` ：此File表示的是否为文件。
                       - public boolean canRead() ：判断是否可读
                       - public boolean canWrite() ：判断是否可写
                       - public boolean isHidden() ：判断是否隐藏
                        */
                       @Test
                       public void test04(){
                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                           boolean exists = file1.exists();
                           System.out.println("存在："+exists);

                           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                           boolean directory = file2.isDirectory();
                           System.out.println("文件夹："+directory);
                           boolean file = file2.isFile();
                           System.out.println("文件"+file);

                           boolean b = file2.canRead();
                           System.out.println("可读"+b);
                           boolean w = file2.canWrite();
                           System.out.println("可写"+w);

                           File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                           boolean hidden = file3.isHidden();
                           System.out.println("隐藏："+hidden);
                       }

                       /*
                        * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                        * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                        */
                       @Test
                       public void test03(){
                           //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                           File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                           String[] list = file.list();
                           //遍历
                           for (String s : list) {
                               System.out.println("名称："+s);
                           }

                           //File数组
                           File[] files = file.listFiles();

                           for (File file1 : files) {
                               System.out.println(file1.getName());
                               System.out.println(file1.getAbsoluteFile());
                           }


                       }



                       /*
                        * public String getName() ：获取名称
                        * public String getPath() ：获取路径
                        * `public String getAbsolutePath()`：获取绝对路径
                        * public File getAbsoluteFile()：获取绝对路径表示的文件
                        * `public String getParent()`：获取上层文件目录路径。若无，返回null
                        * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                        * public long lastModified() ：获取最后一次的修改时间，毫秒值
                        */
                       @Test
                       public void test02(){
                           File file = new File("upload\\a.txt");
                           System.out.println(file.getName());
                           String path = file.getPath();
                           System.out.println(path);
                           File absoluteFile = file.getAbsoluteFile();
                           System.out.println(absoluteFile);

                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                           File absoluteFile1 = file1.getAbsoluteFile();
                           System.out.println(absoluteFile1);
                           String path1 = file1.getPath();
                           System.out.println(path1);

                           //path 使用的是构建路径。
                           String parent = file1.getParent();
                           System.out.println("parent:"+parent);

                           long length = file1.length();
                           System.out.println("字节："+length);

                           long l = file1.lastModified();
                           Date date = new Date(l);
                           System.out.println(date);

                           //1.8 转换成时间 ？？？

                       }

                       /*
                       * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                       * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                       * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                       关于路径：
                       * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                       * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                         * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                         * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                        */
                       @Test
                       public void test01(){
                           //绝对路径
                           File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                           //获取名称
                           System.out.println(file.getName());
                           //输出
                           System.out.println(file);

                           //相对路径
                           File file1 = new File("upload", "a.txt");// upload\\a.txt
                           //获取名称
                           System.out.println(file1.getName());
                           //输出
                           System.out.println(file1);


                           //构造  public File(File parent, String child)`
                           File upload = new File("upload");
                           File file2 = new File(upload, "b.txt");

                           //获取名称
                           System.out.println(file2.getName());
                           //输出
                           System.out.println(file2);
                       }
                   }package com.lc.day17.file1;

                    import org.junit.Test;

                    import java.io.File;
                    import java.io.IOException;
                    import java.time.LocalDate;
                    import java.time.format.DateTimeFormatter;
                    import java.util.Date;

                    /**
                     * ClassName: TestFile
                     * Package: com.lc.day17.file1
                     * Description:
                     *
                     * @Author 爱扣钉-陈晨
                     * @Create 2023/8/5 9:23
                     * @Version 1.0
                     */
                    public class TestFile {


                        /*
                        - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                        - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                        - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                        - `public boolean delete()` ：删除文件或者文件夹
                          删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                         */
                        @Test
                        public void test05() throws IOException {
                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                            boolean newFile = file1.createNewFile();
                            System.out.println(newFile);

                            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                            boolean mkdir = file2.mkdir();
                            System.out.println(mkdir);

                            File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                            //时间转换
                            LocalDate date = LocalDate.now();

                            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                            String dateFile = date.format(dateTimeFormatter);

                            File file = new File(file3, dateFile);
                            System.out.println(file.mkdir());


                            //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                            File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                            System.out.println(file4.mkdirs());

                            System.out.println(file4.delete());

                            file1.delete();
                        }


                        /*
                        - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                        - `public boolean isDirectory()` ：此File表示的是否为目录。
                        - `public boolean isFile()` ：此File表示的是否为文件。
                        - public boolean canRead() ：判断是否可读
                        - public boolean canWrite() ：判断是否可写
                        - public boolean isHidden() ：判断是否隐藏
                         */
                        @Test
                        public void test04(){
                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                            boolean exists = file1.exists();
                            System.out.println("存在："+exists);

                            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                            boolean directory = file2.isDirectory();
                            System.out.println("文件夹："+directory);
                            boolean file = file2.isFile();
                            System.out.println("文件"+file);

                            boolean b = file2.canRead();
                            System.out.println("可读"+b);
                            boolean w = file2.canWrite();
                            System.out.println("可写"+w);

                            File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                            boolean hidden = file3.isHidden();
                            System.out.println("隐藏："+hidden);
                        }

                        /*
                         * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                         * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                         */
                        @Test
                        public void test03(){
                            //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                            File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                            String[] list = file.list();
                            //遍历
                            for (String s : list) {
                                System.out.println("名称："+s);
                            }

                            //File数组
                            File[] files = file.listFiles();

                            for (File file1 : files) {
                                System.out.println(file1.getName());
                                System.out.println(file1.getAbsoluteFile());
                            }


                        }



                        /*
                         * public String getName() ：获取名称
                         * public String getPath() ：获取路径
                         * `public String getAbsolutePath()`：获取绝对路径
                         * public File getAbsoluteFile()：获取绝对路径表示的文件
                         * `public String getParent()`：获取上层文件目录路径。若无，返回null
                         * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                         * public long lastModified() ：获取最后一次的修改时间，毫秒值
                         */
                        @Test
                        public void test02(){
                            File file = new File("upload\\a.txt");
                            System.out.println(file.getName());
                            String path = file.getPath();
                            System.out.println(path);
                            File absoluteFile = file.getAbsoluteFile();
                            System.out.println(absoluteFile);

                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                            File absoluteFile1 = file1.getAbsoluteFile();
                            System.out.println(absoluteFile1);
                            String path1 = file1.getPath();
                            System.out.println(path1);

                            //path 使用的是构建路径。
                            String parent = file1.getParent();
                            System.out.println("parent:"+parent);

                            long length = file1.length();
                            System.out.println("字节："+length);

                            long l = file1.lastModified();
                            Date date = new Date(l);
                            System.out.println(date);

                            //1.8 转换成时间 ？？？

                        }

                        /*
                        * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                        * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                        * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                        关于路径：
                        * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                        * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                          * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                          * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                         */
                        @Test
                        public void test01(){
                            //绝对路径
                            File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                            //获取名称
                            System.out.println(file.getName());
                            //输出
                            System.out.println(file);

                            //相对路径
                            File file1 = new File("upload", "a.txt");// upload\\a.txt
                            //获取名称
                            System.out.println(file1.getName());
                            //输出
                            System.out.println(file1);


                            //构造  public File(File parent, String child)`
                            File upload = new File("upload");
                            File file2 = new File(upload, "b.txt");

                            //获取名称
                            System.out.println(file2.getName());
                            //输出
                            System.out.println(file2);
                        }
                    }package com.lc.day17.file1;

                     import org.junit.Test;

                     import java.io.File;
                     import java.io.IOException;
                     import java.time.LocalDate;
                     import java.time.format.DateTimeFormatter;
                     import java.util.Date;

                     /**
                      * ClassName: TestFile
                      * Package: com.lc.day17.file1
                      * Description:
                      *
                      * @Author 爱扣钉-陈晨
                      * @Create 2023/8/5 9:23
                      * @Version 1.0
                      */
                     public class TestFile {


                         /*
                         - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                         - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                         - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                         - `public boolean delete()` ：删除文件或者文件夹
                           删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                          */
                         @Test
                         public void test05() throws IOException {
                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                             boolean newFile = file1.createNewFile();
                             System.out.println(newFile);

                             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                             boolean mkdir = file2.mkdir();
                             System.out.println(mkdir);

                             File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                             //时间转换
                             LocalDate date = LocalDate.now();

                             DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                             String dateFile = date.format(dateTimeFormatter);

                             File file = new File(file3, dateFile);
                             System.out.println(file.mkdir());


                             //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                             File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                             System.out.println(file4.mkdirs());

                             System.out.println(file4.delete());

                             file1.delete();
                         }


                         /*
                         - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                         - `public boolean isDirectory()` ：此File表示的是否为目录。
                         - `public boolean isFile()` ：此File表示的是否为文件。
                         - public boolean canRead() ：判断是否可读
                         - public boolean canWrite() ：判断是否可写
                         - public boolean isHidden() ：判断是否隐藏
                          */
                         @Test
                         public void test04(){
                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                             boolean exists = file1.exists();
                             System.out.println("存在："+exists);

                             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                             boolean directory = file2.isDirectory();
                             System.out.println("文件夹："+directory);
                             boolean file = file2.isFile();
                             System.out.println("文件"+file);

                             boolean b = file2.canRead();
                             System.out.println("可读"+b);
                             boolean w = file2.canWrite();
                             System.out.println("可写"+w);

                             File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                             boolean hidden = file3.isHidden();
                             System.out.println("隐藏："+hidden);
                         }

                         /*
                          * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                          * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                          */
                         @Test
                         public void test03(){
                             //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                             File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                             String[] list = file.list();
                             //遍历
                             for (String s : list) {
                                 System.out.println("名称："+s);
                             }

                             //File数组
                             File[] files = file.listFiles();

                             for (File file1 : files) {
                                 System.out.println(file1.getName());
                                 System.out.println(file1.getAbsoluteFile());
                             }


                         }



                         /*
                          * public String getName() ：获取名称
                          * public String getPath() ：获取路径
                          * `public String getAbsolutePath()`：获取绝对路径
                          * public File getAbsoluteFile()：获取绝对路径表示的文件
                          * `public String getParent()`：获取上层文件目录路径。若无，返回null
                          * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                          * public long lastModified() ：获取最后一次的修改时间，毫秒值
                          */
                         @Test
                         public void test02(){
                             File file = new File("upload\\a.txt");
                             System.out.println(file.getName());
                             String path = file.getPath();
                             System.out.println(path);
                             File absoluteFile = file.getAbsoluteFile();
                             System.out.println(absoluteFile);

                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                             File absoluteFile1 = file1.getAbsoluteFile();
                             System.out.println(absoluteFile1);
                             String path1 = file1.getPath();
                             System.out.println(path1);

                             //path 使用的是构建路径。
                             String parent = file1.getParent();
                             System.out.println("parent:"+parent);

                             long length = file1.length();
                             System.out.println("字节："+length);

                             long l = file1.lastModified();
                             Date date = new Date(l);
                             System.out.println(date);

                             //1.8 转换成时间 ？？？

                         }

                         /*
                         * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                         * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                         * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                         关于路径：
                         * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                         * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                           * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                           * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                          */
                         @Test
                         public void test01(){
                             //绝对路径
                             File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                             //获取名称
                             System.out.println(file.getName());
                             //输出
                             System.out.println(file);

                             //相对路径
                             File file1 = new File("upload", "a.txt");// upload\\a.txt
                             //获取名称
                             System.out.println(file1.getName());
                             //输出
                             System.out.println(file1);


                             //构造  public File(File parent, String child)`
                             File upload = new File("upload");
                             File file2 = new File(upload, "b.txt");

                             //获取名称
                             System.out.println(file2.getName());
                             //输出
                             System.out.println(file2);
                         }
                     }package com.lc.day17.file1;

                      import org.junit.Test;

                      import java.io.File;
                      import java.io.IOException;
                      import java.time.LocalDate;
                      import java.time.format.DateTimeFormatter;
                      import java.util.Date;

                      /**
                       * ClassName: TestFile
                       * Package: com.lc.day17.file1
                       * Description:
                       *
                       * @Author 爱扣钉-陈晨
                       * @Create 2023/8/5 9:23
                       * @Version 1.0
                       */
                      public class TestFile {


                          /*
                          - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                          - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                          - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                          - `public boolean delete()` ：删除文件或者文件夹
                            删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                           */
                          @Test
                          public void test05() throws IOException {
                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                              boolean newFile = file1.createNewFile();
                              System.out.println(newFile);

                              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                              boolean mkdir = file2.mkdir();
                              System.out.println(mkdir);

                              File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                              //时间转换
                              LocalDate date = LocalDate.now();

                              DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                              String dateFile = date.format(dateTimeFormatter);

                              File file = new File(file3, dateFile);
                              System.out.println(file.mkdir());


                              //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                              File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                              System.out.println(file4.mkdirs());

                              System.out.println(file4.delete());

                              file1.delete();
                          }


                          /*
                          - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                          - `public boolean isDirectory()` ：此File表示的是否为目录。
                          - `public boolean isFile()` ：此File表示的是否为文件。
                          - public boolean canRead() ：判断是否可读
                          - public boolean canWrite() ：判断是否可写
                          - public boolean isHidden() ：判断是否隐藏
                           */
                          @Test
                          public void test04(){
                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                              boolean exists = file1.exists();
                              System.out.println("存在："+exists);

                              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                              boolean directory = file2.isDirectory();
                              System.out.println("文件夹："+directory);
                              boolean file = file2.isFile();
                              System.out.println("文件"+file);

                              boolean b = file2.canRead();
                              System.out.println("可读"+b);
                              boolean w = file2.canWrite();
                              System.out.println("可写"+w);

                              File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                              boolean hidden = file3.isHidden();
                              System.out.println("隐藏："+hidden);
                          }

                          /*
                           * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                           * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                           */
                          @Test
                          public void test03(){
                              //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                              File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                              String[] list = file.list();
                              //遍历
                              for (String s : list) {
                                  System.out.println("名称："+s);
                              }

                              //File数组
                              File[] files = file.listFiles();

                              for (File file1 : files) {
                                  System.out.println(file1.getName());
                                  System.out.println(file1.getAbsoluteFile());
                              }


                          }



                          /*
                           * public String getName() ：获取名称
                           * public String getPath() ：获取路径
                           * `public String getAbsolutePath()`：获取绝对路径
                           * public File getAbsoluteFile()：获取绝对路径表示的文件
                           * `public String getParent()`：获取上层文件目录路径。若无，返回null
                           * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                           * public long lastModified() ：获取最后一次的修改时间，毫秒值
                           */
                          @Test
                          public void test02(){
                              File file = new File("upload\\a.txt");
                              System.out.println(file.getName());
                              String path = file.getPath();
                              System.out.println(path);
                              File absoluteFile = file.getAbsoluteFile();
                              System.out.println(absoluteFile);

                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                              File absoluteFile1 = file1.getAbsoluteFile();
                              System.out.println(absoluteFile1);
                              String path1 = file1.getPath();
                              System.out.println(path1);

                              //path 使用的是构建路径。
                              String parent = file1.getParent();
                              System.out.println("parent:"+parent);

                              long length = file1.length();
                              System.out.println("字节："+length);

                              long l = file1.lastModified();
                              Date date = new Date(l);
                              System.out.println(date);

                              //1.8 转换成时间 ？？？

                          }

                          /*
                          * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                          * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                          * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                          关于路径：
                          * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                          * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                            * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                            * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                           */
                          @Test
                          public void test01(){
                              //绝对路径
                              File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                              //获取名称
                              System.out.println(file.getName());
                              //输出
                              System.out.println(file);

                              //相对路径
                              File file1 = new File("upload", "a.txt");// upload\\a.txt
                              //获取名称
                              System.out.println(file1.getName());
                              //输出
                              System.out.println(file1);


                              //构造  public File(File parent, String child)`
                              File upload = new File("upload");
                              File file2 = new File(upload, "b.txt");

                              //获取名称
                              System.out.println(file2.getName());
                              //输出
                              System.out.println(file2);
                          }
                      }package com.lc.day17.file1;

                       import org.junit.Test;

                       import java.io.File;
                       import java.io.IOException;
                       import java.time.LocalDate;
                       import java.time.format.DateTimeFormatter;
                       import java.util.Date;

                       /**
                        * ClassName: TestFile
                        * Package: com.lc.day17.file1
                        * Description:
                        *
                        * @Author 爱扣钉-陈晨
                        * @Create 2023/8/5 9:23
                        * @Version 1.0
                        */
                       public class TestFile {


                           /*
                           - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                           - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                           - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                           - `public boolean delete()` ：删除文件或者文件夹
                             删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                            */
                           @Test
                           public void test05() throws IOException {
                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                               boolean newFile = file1.createNewFile();
                               System.out.println(newFile);

                               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                               boolean mkdir = file2.mkdir();
                               System.out.println(mkdir);

                               File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                               //时间转换
                               LocalDate date = LocalDate.now();

                               DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                               String dateFile = date.format(dateTimeFormatter);

                               File file = new File(file3, dateFile);
                               System.out.println(file.mkdir());


                               //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                               File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                               System.out.println(file4.mkdirs());

                               System.out.println(file4.delete());

                               file1.delete();
                           }


                           /*
                           - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                           - `public boolean isDirectory()` ：此File表示的是否为目录。
                           - `public boolean isFile()` ：此File表示的是否为文件。
                           - public boolean canRead() ：判断是否可读
                           - public boolean canWrite() ：判断是否可写
                           - public boolean isHidden() ：判断是否隐藏
                            */
                           @Test
                           public void test04(){
                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                               boolean exists = file1.exists();
                               System.out.println("存在："+exists);

                               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                               boolean directory = file2.isDirectory();
                               System.out.println("文件夹："+directory);
                               boolean file = file2.isFile();
                               System.out.println("文件"+file);

                               boolean b = file2.canRead();
                               System.out.println("可读"+b);
                               boolean w = file2.canWrite();
                               System.out.println("可写"+w);

                               File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                               boolean hidden = file3.isHidden();
                               System.out.println("隐藏："+hidden);
                           }

                           /*
                            * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                            * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                            */
                           @Test
                           public void test03(){
                               //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                               File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                               String[] list = file.list();
                               //遍历
                               for (String s : list) {
                                   System.out.println("名称："+s);
                               }

                               //File数组
                               File[] files = file.listFiles();

                               for (File file1 : files) {
                                   System.out.println(file1.getName());
                                   System.out.println(file1.getAbsoluteFile());
                               }


                           }



                           /*
                            * public String getName() ：获取名称
                            * public String getPath() ：获取路径
                            * `public String getAbsolutePath()`：获取绝对路径
                            * public File getAbsoluteFile()：获取绝对路径表示的文件
                            * `public String getParent()`：获取上层文件目录路径。若无，返回null
                            * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                            * public long lastModified() ：获取最后一次的修改时间，毫秒值
                            */
                           @Test
                           public void test02(){
                               File file = new File("upload\\a.txt");
                               System.out.println(file.getName());
                               String path = file.getPath();
                               System.out.println(path);
                               File absoluteFile = file.getAbsoluteFile();
                               System.out.println(absoluteFile);

                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                               File absoluteFile1 = file1.getAbsoluteFile();
                               System.out.println(absoluteFile1);
                               String path1 = file1.getPath();
                               System.out.println(path1);

                               //path 使用的是构建路径。
                               String parent = file1.getParent();
                               System.out.println("parent:"+parent);

                               long length = file1.length();
                               System.out.println("字节："+length);

                               long l = file1.lastModified();
                               Date date = new Date(l);
                               System.out.println(date);

                               //1.8 转换成时间 ？？？

                           }

                           /*
                           * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                           * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                           * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                           关于路径：
                           * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                           * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                             * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                             * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                            */
                           @Test
                           public void test01(){
                               //绝对路径
                               File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                               //获取名称
                               System.out.println(file.getName());
                               //输出
                               System.out.println(file);

                               //相对路径
                               File file1 = new File("upload", "a.txt");// upload\\a.txt
                               //获取名称
                               System.out.println(file1.getName());
                               //输出
                               System.out.println(file1);


                               //构造  public File(File parent, String child)`
                               File upload = new File("upload");
                               File file2 = new File(upload, "b.txt");

                               //获取名称
                               System.out.println(file2.getName());
                               //输出
                               System.out.println(file2);
                           }
                       }package com.lc.day17.file1;

                        import org.junit.Test;

                        import java.io.File;
                        import java.io.IOException;
                        import java.time.LocalDate;
                        import java.time.format.DateTimeFormatter;
                        import java.util.Date;

                        /**
                         * ClassName: TestFile
                         * Package: com.lc.day17.file1
                         * Description:
                         *
                         * @Author 爱扣钉-陈晨
                         * @Create 2023/8/5 9:23
                         * @Version 1.0
                         */
                        public class TestFile {


                            /*
                            - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                            - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                            - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                            - `public boolean delete()` ：删除文件或者文件夹
                              删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                             */
                            @Test
                            public void test05() throws IOException {
                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                boolean newFile = file1.createNewFile();
                                System.out.println(newFile);

                                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                boolean mkdir = file2.mkdir();
                                System.out.println(mkdir);

                                File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                //时间转换
                                LocalDate date = LocalDate.now();

                                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                String dateFile = date.format(dateTimeFormatter);

                                File file = new File(file3, dateFile);
                                System.out.println(file.mkdir());


                                //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                System.out.println(file4.mkdirs());

                                System.out.println(file4.delete());

                                file1.delete();
                            }


                            /*
                            - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                            - `public boolean isDirectory()` ：此File表示的是否为目录。
                            - `public boolean isFile()` ：此File表示的是否为文件。
                            - public boolean canRead() ：判断是否可读
                            - public boolean canWrite() ：判断是否可写
                            - public boolean isHidden() ：判断是否隐藏
                             */
                            @Test
                            public void test04(){
                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                boolean exists = file1.exists();
                                System.out.println("存在："+exists);

                                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                boolean directory = file2.isDirectory();
                                System.out.println("文件夹："+directory);
                                boolean file = file2.isFile();
                                System.out.println("文件"+file);

                                boolean b = file2.canRead();
                                System.out.println("可读"+b);
                                boolean w = file2.canWrite();
                                System.out.println("可写"+w);

                                File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                boolean hidden = file3.isHidden();
                                System.out.println("隐藏："+hidden);
                            }

                            /*
                             * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                             * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                             */
                            @Test
                            public void test03(){
                                //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                String[] list = file.list();
                                //遍历
                                for (String s : list) {
                                    System.out.println("名称："+s);
                                }

                                //File数组
                                File[] files = file.listFiles();

                                for (File file1 : files) {
                                    System.out.println(file1.getName());
                                    System.out.println(file1.getAbsoluteFile());
                                }


                            }



                            /*
                             * public String getName() ：获取名称
                             * public String getPath() ：获取路径
                             * `public String getAbsolutePath()`：获取绝对路径
                             * public File getAbsoluteFile()：获取绝对路径表示的文件
                             * `public String getParent()`：获取上层文件目录路径。若无，返回null
                             * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                             * public long lastModified() ：获取最后一次的修改时间，毫秒值
                             */
                            @Test
                            public void test02(){
                                File file = new File("upload\\a.txt");
                                System.out.println(file.getName());
                                String path = file.getPath();
                                System.out.println(path);
                                File absoluteFile = file.getAbsoluteFile();
                                System.out.println(absoluteFile);

                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                File absoluteFile1 = file1.getAbsoluteFile();
                                System.out.println(absoluteFile1);
                                String path1 = file1.getPath();
                                System.out.println(path1);

                                //path 使用的是构建路径。
                                String parent = file1.getParent();
                                System.out.println("parent:"+parent);

                                long length = file1.length();
                                System.out.println("字节："+length);

                                long l = file1.lastModified();
                                Date date = new Date(l);
                                System.out.println(date);

                                //1.8 转换成时间 ？？？

                            }

                            /*
                            * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                            * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                            * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                            关于路径：
                            * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                            * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                              * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                              * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                             */
                            @Test
                            public void test01(){
                                //绝对路径
                                File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                //获取名称
                                System.out.println(file.getName());
                                //输出
                                System.out.println(file);

                                //相对路径
                                File file1 = new File("upload", "a.txt");// upload\\a.txt
                                //获取名称
                                System.out.println(file1.getName());
                                //输出
                                System.out.println(file1);


                                //构造  public File(File parent, String child)`
                                File upload = new File("upload");
                                File file2 = new File(upload, "b.txt");

                                //获取名称
                                System.out.println(file2.getName());
                                //输出
                                System.out.println(file2);
                            }
                        }package com.lc.day17.file1;

                         import org.junit.Test;

                         import java.io.File;
                         import java.io.IOException;
                         import java.time.LocalDate;
                         import java.time.format.DateTimeFormatter;
                         import java.util.Date;

                         /**
                          * ClassName: TestFile
                          * Package: com.lc.day17.file1
                          * Description:
                          *
                          * @Author 爱扣钉-陈晨
                          * @Create 2023/8/5 9:23
                          * @Version 1.0
                          */
                         public class TestFile {


                             /*
                             - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                             - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                             - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                             - `public boolean delete()` ：删除文件或者文件夹
                               删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                              */
                             @Test
                             public void test05() throws IOException {
                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                 boolean newFile = file1.createNewFile();
                                 System.out.println(newFile);

                                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                 boolean mkdir = file2.mkdir();
                                 System.out.println(mkdir);

                                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                 //时间转换
                                 LocalDate date = LocalDate.now();

                                 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                 String dateFile = date.format(dateTimeFormatter);

                                 File file = new File(file3, dateFile);
                                 System.out.println(file.mkdir());


                                 //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                 File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                 System.out.println(file4.mkdirs());

                                 System.out.println(file4.delete());

                                 file1.delete();
                             }


                             /*
                             - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                             - `public boolean isDirectory()` ：此File表示的是否为目录。
                             - `public boolean isFile()` ：此File表示的是否为文件。
                             - public boolean canRead() ：判断是否可读
                             - public boolean canWrite() ：判断是否可写
                             - public boolean isHidden() ：判断是否隐藏
                              */
                             @Test
                             public void test04(){
                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                 boolean exists = file1.exists();
                                 System.out.println("存在："+exists);

                                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                 boolean directory = file2.isDirectory();
                                 System.out.println("文件夹："+directory);
                                 boolean file = file2.isFile();
                                 System.out.println("文件"+file);

                                 boolean b = file2.canRead();
                                 System.out.println("可读"+b);
                                 boolean w = file2.canWrite();
                                 System.out.println("可写"+w);

                                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                 boolean hidden = file3.isHidden();
                                 System.out.println("隐藏："+hidden);
                             }

                             /*
                              * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                              * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                              */
                             @Test
                             public void test03(){
                                 //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                 File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                 String[] list = file.list();
                                 //遍历
                                 for (String s : list) {
                                     System.out.println("名称："+s);
                                 }

                                 //File数组
                                 File[] files = file.listFiles();

                                 for (File file1 : files) {
                                     System.out.println(file1.getName());
                                     System.out.println(file1.getAbsoluteFile());
                                 }


                             }



                             /*
                              * public String getName() ：获取名称
                              * public String getPath() ：获取路径
                              * `public String getAbsolutePath()`：获取绝对路径
                              * public File getAbsoluteFile()：获取绝对路径表示的文件
                              * `public String getParent()`：获取上层文件目录路径。若无，返回null
                              * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                              * public long lastModified() ：获取最后一次的修改时间，毫秒值
                              */
                             @Test
                             public void test02(){
                                 File file = new File("upload\\a.txt");
                                 System.out.println(file.getName());
                                 String path = file.getPath();
                                 System.out.println(path);
                                 File absoluteFile = file.getAbsoluteFile();
                                 System.out.println(absoluteFile);

                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                 File absoluteFile1 = file1.getAbsoluteFile();
                                 System.out.println(absoluteFile1);
                                 String path1 = file1.getPath();
                                 System.out.println(path1);

                                 //path 使用的是构建路径。
                                 String parent = file1.getParent();
                                 System.out.println("parent:"+parent);

                                 long length = file1.length();
                                 System.out.println("字节："+length);

                                 long l = file1.lastModified();
                                 Date date = new Date(l);
                                 System.out.println(date);

                                 //1.8 转换成时间 ？？？

                             }

                             /*
                             * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                             * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                             * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                             关于路径：
                             * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                             * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                               * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                               * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                              */
                             @Test
                             public void test01(){
                                 //绝对路径
                                 File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                 //获取名称
                                 System.out.println(file.getName());
                                 //输出
                                 System.out.println(file);

                                 //相对路径
                                 File file1 = new File("upload", "a.txt");// upload\\a.txt
                                 //获取名称
                                 System.out.println(file1.getName());
                                 //输出
                                 System.out.println(file1);


                                 //构造  public File(File parent, String child)`
                                 File upload = new File("upload");
                                 File file2 = new File(upload, "b.txt");

                                 //获取名称
                                 System.out.println(file2.getName());
                                 //输出
                                 System.out.println(file2);
                             }
                         }package com.lc.day17.file1;

                          import org.junit.Test;

                          import java.io.File;
                          import java.io.IOException;
                          import java.time.LocalDate;
                          import java.time.format.DateTimeFormatter;
                          import java.util.Date;

                          /**
                           * ClassName: TestFile
                           * Package: com.lc.day17.file1
                           * Description:
                           *
                           * @Author 爱扣钉-陈晨
                           * @Create 2023/8/5 9:23
                           * @Version 1.0
                           */
                          public class TestFile {


                              /*
                              - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                              - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                              - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                              - `public boolean delete()` ：删除文件或者文件夹
                                删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                               */
                              @Test
                              public void test05() throws IOException {
                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                  boolean newFile = file1.createNewFile();
                                  System.out.println(newFile);

                                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                  boolean mkdir = file2.mkdir();
                                  System.out.println(mkdir);

                                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                  //时间转换
                                  LocalDate date = LocalDate.now();

                                  DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                  String dateFile = date.format(dateTimeFormatter);

                                  File file = new File(file3, dateFile);
                                  System.out.println(file.mkdir());


                                  //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                  File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                  System.out.println(file4.mkdirs());

                                  System.out.println(file4.delete());

                                  file1.delete();
                              }


                              /*
                              - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                              - `public boolean isDirectory()` ：此File表示的是否为目录。
                              - `public boolean isFile()` ：此File表示的是否为文件。
                              - public boolean canRead() ：判断是否可读
                              - public boolean canWrite() ：判断是否可写
                              - public boolean isHidden() ：判断是否隐藏
                               */
                              @Test
                              public void test04(){
                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                  boolean exists = file1.exists();
                                  System.out.println("存在："+exists);

                                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                  boolean directory = file2.isDirectory();
                                  System.out.println("文件夹："+directory);
                                  boolean file = file2.isFile();
                                  System.out.println("文件"+file);

                                  boolean b = file2.canRead();
                                  System.out.println("可读"+b);
                                  boolean w = file2.canWrite();
                                  System.out.println("可写"+w);

                                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                  boolean hidden = file3.isHidden();
                                  System.out.println("隐藏："+hidden);
                              }

                              /*
                               * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                               * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                               */
                              @Test
                              public void test03(){
                                  //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                  File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                  String[] list = file.list();
                                  //遍历
                                  for (String s : list) {
                                      System.out.println("名称："+s);
                                  }

                                  //File数组
                                  File[] files = file.listFiles();

                                  for (File file1 : files) {
                                      System.out.println(file1.getName());
                                      System.out.println(file1.getAbsoluteFile());
                                  }


                              }



                              /*
                               * public String getName() ：获取名称
                               * public String getPath() ：获取路径
                               * `public String getAbsolutePath()`：获取绝对路径
                               * public File getAbsoluteFile()：获取绝对路径表示的文件
                               * `public String getParent()`：获取上层文件目录路径。若无，返回null
                               * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                               * public long lastModified() ：获取最后一次的修改时间，毫秒值
                               */
                              @Test
                              public void test02(){
                                  File file = new File("upload\\a.txt");
                                  System.out.println(file.getName());
                                  String path = file.getPath();
                                  System.out.println(path);
                                  File absoluteFile = file.getAbsoluteFile();
                                  System.out.println(absoluteFile);

                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                  File absoluteFile1 = file1.getAbsoluteFile();
                                  System.out.println(absoluteFile1);
                                  String path1 = file1.getPath();
                                  System.out.println(path1);

                                  //path 使用的是构建路径。
                                  String parent = file1.getParent();
                                  System.out.println("parent:"+parent);

                                  long length = file1.length();
                                  System.out.println("字节："+length);

                                  long l = file1.lastModified();
                                  Date date = new Date(l);
                                  System.out.println(date);

                                  //1.8 转换成时间 ？？？

                              }

                              /*
                              * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                              * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                              * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                              关于路径：
                              * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                              * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                               */
                              @Test
                              public void test01(){
                                  //绝对路径
                                  File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                  //获取名称
                                  System.out.println(file.getName());
                                  //输出
                                  System.out.println(file);

                                  //相对路径
                                  File file1 = new File("upload", "a.txt");// upload\\a.txt
                                  //获取名称
                                  System.out.println(file1.getName());
                                  //输出
                                  System.out.println(file1);


                                  //构造  public File(File parent, String child)`
                                  File upload = new File("upload");
                                  File file2 = new File(upload, "b.txt");

                                  //获取名称
                                  System.out.println(file2.getName());
                                  //输出
                                  System.out.println(file2);
                              }
                          }package com.lc.day17.file1;

                           import org.junit.Test;

                           import java.io.File;
                           import java.io.IOException;
                           import java.time.LocalDate;
                           import java.time.format.DateTimeFormatter;
                           import java.util.Date;

                           /**
                            * ClassName: TestFile
                            * Package: com.lc.day17.file1
                            * Description:
                            *
                            * @Author 爱扣钉-陈晨
                            * @Create 2023/8/5 9:23
                            * @Version 1.0
                            */
                           public class TestFile {


                               /*
                               - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                               - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                               - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                               - `public boolean delete()` ：删除文件或者文件夹
                                 删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                */
                               @Test
                               public void test05() throws IOException {
                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                   boolean newFile = file1.createNewFile();
                                   System.out.println(newFile);

                                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                   boolean mkdir = file2.mkdir();
                                   System.out.println(mkdir);

                                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                   //时间转换
                                   LocalDate date = LocalDate.now();

                                   DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                   String dateFile = date.format(dateTimeFormatter);

                                   File file = new File(file3, dateFile);
                                   System.out.println(file.mkdir());


                                   //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                   File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                   System.out.println(file4.mkdirs());

                                   System.out.println(file4.delete());

                                   file1.delete();
                               }


                               /*
                               - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                               - `public boolean isDirectory()` ：此File表示的是否为目录。
                               - `public boolean isFile()` ：此File表示的是否为文件。
                               - public boolean canRead() ：判断是否可读
                               - public boolean canWrite() ：判断是否可写
                               - public boolean isHidden() ：判断是否隐藏
                                */
                               @Test
                               public void test04(){
                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                   boolean exists = file1.exists();
                                   System.out.println("存在："+exists);

                                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                   boolean directory = file2.isDirectory();
                                   System.out.println("文件夹："+directory);
                                   boolean file = file2.isFile();
                                   System.out.println("文件"+file);

                                   boolean b = file2.canRead();
                                   System.out.println("可读"+b);
                                   boolean w = file2.canWrite();
                                   System.out.println("可写"+w);

                                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                   boolean hidden = file3.isHidden();
                                   System.out.println("隐藏："+hidden);
                               }

                               /*
                                * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                */
                               @Test
                               public void test03(){
                                   //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                   File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                   String[] list = file.list();
                                   //遍历
                                   for (String s : list) {
                                       System.out.println("名称："+s);
                                   }

                                   //File数组
                                   File[] files = file.listFiles();

                                   for (File file1 : files) {
                                       System.out.println(file1.getName());
                                       System.out.println(file1.getAbsoluteFile());
                                   }


                               }



                               /*
                                * public String getName() ：获取名称
                                * public String getPath() ：获取路径
                                * `public String getAbsolutePath()`：获取绝对路径
                                * public File getAbsoluteFile()：获取绝对路径表示的文件
                                * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                */
                               @Test
                               public void test02(){
                                   File file = new File("upload\\a.txt");
                                   System.out.println(file.getName());
                                   String path = file.getPath();
                                   System.out.println(path);
                                   File absoluteFile = file.getAbsoluteFile();
                                   System.out.println(absoluteFile);

                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                   File absoluteFile1 = file1.getAbsoluteFile();
                                   System.out.println(absoluteFile1);
                                   String path1 = file1.getPath();
                                   System.out.println(path1);

                                   //path 使用的是构建路径。
                                   String parent = file1.getParent();
                                   System.out.println("parent:"+parent);

                                   long length = file1.length();
                                   System.out.println("字节："+length);

                                   long l = file1.lastModified();
                                   Date date = new Date(l);
                                   System.out.println(date);

                                   //1.8 转换成时间 ？？？

                               }

                               /*
                               * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                               * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                               * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                               关于路径：
                               * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                               * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                 * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                 * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                */
                               @Test
                               public void test01(){
                                   //绝对路径
                                   File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                   //获取名称
                                   System.out.println(file.getName());
                                   //输出
                                   System.out.println(file);

                                   //相对路径
                                   File file1 = new File("upload", "a.txt");// upload\\a.txt
                                   //获取名称
                                   System.out.println(file1.getName());
                                   //输出
                                   System.out.println(file1);


                                   //构造  public File(File parent, String child)`
                                   File upload = new File("upload");
                                   File file2 = new File(upload, "b.txt");

                                   //获取名称
                                   System.out.println(file2.getName());
                                   //输出
                                   System.out.println(file2);
                               }
                           }package com.lc.day17.file1;

                            import org.junit.Test;

                            import java.io.File;
                            import java.io.IOException;
                            import java.time.LocalDate;
                            import java.time.format.DateTimeFormatter;
                            import java.util.Date;

                            /**
                             * ClassName: TestFile
                             * Package: com.lc.day17.file1
                             * Description:
                             *
                             * @Author 爱扣钉-陈晨
                             * @Create 2023/8/5 9:23
                             * @Version 1.0
                             */
                            public class TestFile {


                                /*
                                - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                - `public boolean delete()` ：删除文件或者文件夹
                                  删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                 */
                                @Test
                                public void test05() throws IOException {
                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                    boolean newFile = file1.createNewFile();
                                    System.out.println(newFile);

                                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                    boolean mkdir = file2.mkdir();
                                    System.out.println(mkdir);

                                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                    //时间转换
                                    LocalDate date = LocalDate.now();

                                    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                    String dateFile = date.format(dateTimeFormatter);

                                    File file = new File(file3, dateFile);
                                    System.out.println(file.mkdir());


                                    //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                    File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                    System.out.println(file4.mkdirs());

                                    System.out.println(file4.delete());

                                    file1.delete();
                                }


                                /*
                                - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                - `public boolean isDirectory()` ：此File表示的是否为目录。
                                - `public boolean isFile()` ：此File表示的是否为文件。
                                - public boolean canRead() ：判断是否可读
                                - public boolean canWrite() ：判断是否可写
                                - public boolean isHidden() ：判断是否隐藏
                                 */
                                @Test
                                public void test04(){
                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                    boolean exists = file1.exists();
                                    System.out.println("存在："+exists);

                                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                    boolean directory = file2.isDirectory();
                                    System.out.println("文件夹："+directory);
                                    boolean file = file2.isFile();
                                    System.out.println("文件"+file);

                                    boolean b = file2.canRead();
                                    System.out.println("可读"+b);
                                    boolean w = file2.canWrite();
                                    System.out.println("可写"+w);

                                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                    boolean hidden = file3.isHidden();
                                    System.out.println("隐藏："+hidden);
                                }

                                /*
                                 * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                 * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                 */
                                @Test
                                public void test03(){
                                    //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                    File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                    String[] list = file.list();
                                    //遍历
                                    for (String s : list) {
                                        System.out.println("名称："+s);
                                    }

                                    //File数组
                                    File[] files = file.listFiles();

                                    for (File file1 : files) {
                                        System.out.println(file1.getName());
                                        System.out.println(file1.getAbsoluteFile());
                                    }


                                }



                                /*
                                 * public String getName() ：获取名称
                                 * public String getPath() ：获取路径
                                 * `public String getAbsolutePath()`：获取绝对路径
                                 * public File getAbsoluteFile()：获取绝对路径表示的文件
                                 * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                 * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                 * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                 */
                                @Test
                                public void test02(){
                                    File file = new File("upload\\a.txt");
                                    System.out.println(file.getName());
                                    String path = file.getPath();
                                    System.out.println(path);
                                    File absoluteFile = file.getAbsoluteFile();
                                    System.out.println(absoluteFile);

                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                    File absoluteFile1 = file1.getAbsoluteFile();
                                    System.out.println(absoluteFile1);
                                    String path1 = file1.getPath();
                                    System.out.println(path1);

                                    //path 使用的是构建路径。
                                    String parent = file1.getParent();
                                    System.out.println("parent:"+parent);

                                    long length = file1.length();
                                    System.out.println("字节："+length);

                                    long l = file1.lastModified();
                                    Date date = new Date(l);
                                    System.out.println(date);

                                    //1.8 转换成时间 ？？？

                                }

                                /*
                                * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                关于路径：
                                * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                  * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                  * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                 */
                                @Test
                                public void test01(){
                                    //绝对路径
                                    File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                    //获取名称
                                    System.out.println(file.getName());
                                    //输出
                                    System.out.println(file);

                                    //相对路径
                                    File file1 = new File("upload", "a.txt");// upload\\a.txt
                                    //获取名称
                                    System.out.println(file1.getName());
                                    //输出
                                    System.out.println(file1);


                                    //构造  public File(File parent, String child)`
                                    File upload = new File("upload");
                                    File file2 = new File(upload, "b.txt");

                                    //获取名称
                                    System.out.println(file2.getName());
                                    //输出
                                    System.out.println(file2);
                                }
                            }package com.lc.day17.file1;

                             import org.junit.Test;

                             import java.io.File;
                             import java.io.IOException;
                             import java.time.LocalDate;
                             import java.time.format.DateTimeFormatter;
                             import java.util.Date;

                             /**
                              * ClassName: TestFile
                              * Package: com.lc.day17.file1
                              * Description:
                              *
                              * @Author 爱扣钉-陈晨
                              * @Create 2023/8/5 9:23
                              * @Version 1.0
                              */
                             public class TestFile {


                                 /*
                                 - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                 - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                 - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                 - `public boolean delete()` ：删除文件或者文件夹
                                   删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                  */
                                 @Test
                                 public void test05() throws IOException {
                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                     boolean newFile = file1.createNewFile();
                                     System.out.println(newFile);

                                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                     boolean mkdir = file2.mkdir();
                                     System.out.println(mkdir);

                                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                     //时间转换
                                     LocalDate date = LocalDate.now();

                                     DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                     String dateFile = date.format(dateTimeFormatter);

                                     File file = new File(file3, dateFile);
                                     System.out.println(file.mkdir());


                                     //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                     File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                     System.out.println(file4.mkdirs());

                                     System.out.println(file4.delete());

                                     file1.delete();
                                 }


                                 /*
                                 - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                 - `public boolean isDirectory()` ：此File表示的是否为目录。
                                 - `public boolean isFile()` ：此File表示的是否为文件。
                                 - public boolean canRead() ：判断是否可读
                                 - public boolean canWrite() ：判断是否可写
                                 - public boolean isHidden() ：判断是否隐藏
                                  */
                                 @Test
                                 public void test04(){
                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                     boolean exists = file1.exists();
                                     System.out.println("存在："+exists);

                                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                     boolean directory = file2.isDirectory();
                                     System.out.println("文件夹："+directory);
                                     boolean file = file2.isFile();
                                     System.out.println("文件"+file);

                                     boolean b = file2.canRead();
                                     System.out.println("可读"+b);
                                     boolean w = file2.canWrite();
                                     System.out.println("可写"+w);

                                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                     boolean hidden = file3.isHidden();
                                     System.out.println("隐藏："+hidden);
                                 }

                                 /*
                                  * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                  * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                  */
                                 @Test
                                 public void test03(){
                                     //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                     File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                     String[] list = file.list();
                                     //遍历
                                     for (String s : list) {
                                         System.out.println("名称："+s);
                                     }

                                     //File数组
                                     File[] files = file.listFiles();

                                     for (File file1 : files) {
                                         System.out.println(file1.getName());
                                         System.out.println(file1.getAbsoluteFile());
                                     }


                                 }



                                 /*
                                  * public String getName() ：获取名称
                                  * public String getPath() ：获取路径
                                  * `public String getAbsolutePath()`：获取绝对路径
                                  * public File getAbsoluteFile()：获取绝对路径表示的文件
                                  * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                  * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                  * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                  */
                                 @Test
                                 public void test02(){
                                     File file = new File("upload\\a.txt");
                                     System.out.println(file.getName());
                                     String path = file.getPath();
                                     System.out.println(path);
                                     File absoluteFile = file.getAbsoluteFile();
                                     System.out.println(absoluteFile);

                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                     File absoluteFile1 = file1.getAbsoluteFile();
                                     System.out.println(absoluteFile1);
                                     String path1 = file1.getPath();
                                     System.out.println(path1);

                                     //path 使用的是构建路径。
                                     String parent = file1.getParent();
                                     System.out.println("parent:"+parent);

                                     long length = file1.length();
                                     System.out.println("字节："+length);

                                     long l = file1.lastModified();
                                     Date date = new Date(l);
                                     System.out.println(date);

                                     //1.8 转换成时间 ？？？

                                 }

                                 /*
                                 * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                 * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                 * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                 关于路径：
                                 * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                 * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                   * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                   * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                  */
                                 @Test
                                 public void test01(){
                                     //绝对路径
                                     File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                     //获取名称
                                     System.out.println(file.getName());
                                     //输出
                                     System.out.println(file);

                                     //相对路径
                                     File file1 = new File("upload", "a.txt");// upload\\a.txt
                                     //获取名称
                                     System.out.println(file1.getName());
                                     //输出
                                     System.out.println(file1);


                                     //构造  public File(File parent, String child)`
                                     File upload = new File("upload");
                                     File file2 = new File(upload, "b.txt");

                                     //获取名称
                                     System.out.println(file2.getName());
                                     //输出
                                     System.out.println(file2);
                                 }
                             }package com.lc.day17.file1;

                              import org.junit.Test;

                              import java.io.File;
                              import java.io.IOException;
                              import java.time.LocalDate;
                              import java.time.format.DateTimeFormatter;
                              import java.util.Date;

                              /**
                               * ClassName: TestFile
                               * Package: com.lc.day17.file1
                               * Description:
                               *
                               * @Author 爱扣钉-陈晨
                               * @Create 2023/8/5 9:23
                               * @Version 1.0
                               */
                              public class TestFile {


                                  /*
                                  - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                  - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                  - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                  - `public boolean delete()` ：删除文件或者文件夹
                                    删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                   */
                                  @Test
                                  public void test05() throws IOException {
                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                      boolean newFile = file1.createNewFile();
                                      System.out.println(newFile);

                                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                      boolean mkdir = file2.mkdir();
                                      System.out.println(mkdir);

                                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                      //时间转换
                                      LocalDate date = LocalDate.now();

                                      DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                      String dateFile = date.format(dateTimeFormatter);

                                      File file = new File(file3, dateFile);
                                      System.out.println(file.mkdir());


                                      //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                      File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                      System.out.println(file4.mkdirs());

                                      System.out.println(file4.delete());

                                      file1.delete();
                                  }


                                  /*
                                  - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                  - `public boolean isDirectory()` ：此File表示的是否为目录。
                                  - `public boolean isFile()` ：此File表示的是否为文件。
                                  - public boolean canRead() ：判断是否可读
                                  - public boolean canWrite() ：判断是否可写
                                  - public boolean isHidden() ：判断是否隐藏
                                   */
                                  @Test
                                  public void test04(){
                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                      boolean exists = file1.exists();
                                      System.out.println("存在："+exists);

                                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                      boolean directory = file2.isDirectory();
                                      System.out.println("文件夹："+directory);
                                      boolean file = file2.isFile();
                                      System.out.println("文件"+file);

                                      boolean b = file2.canRead();
                                      System.out.println("可读"+b);
                                      boolean w = file2.canWrite();
                                      System.out.println("可写"+w);

                                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                      boolean hidden = file3.isHidden();
                                      System.out.println("隐藏："+hidden);
                                  }

                                  /*
                                   * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                   * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                   */
                                  @Test
                                  public void test03(){
                                      //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                      File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                      String[] list = file.list();
                                      //遍历
                                      for (String s : list) {
                                          System.out.println("名称："+s);
                                      }

                                      //File数组
                                      File[] files = file.listFiles();

                                      for (File file1 : files) {
                                          System.out.println(file1.getName());
                                          System.out.println(file1.getAbsoluteFile());
                                      }


                                  }



                                  /*
                                   * public String getName() ：获取名称
                                   * public String getPath() ：获取路径
                                   * `public String getAbsolutePath()`：获取绝对路径
                                   * public File getAbsoluteFile()：获取绝对路径表示的文件
                                   * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                   * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                   * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                   */
                                  @Test
                                  public void test02(){
                                      File file = new File("upload\\a.txt");
                                      System.out.println(file.getName());
                                      String path = file.getPath();
                                      System.out.println(path);
                                      File absoluteFile = file.getAbsoluteFile();
                                      System.out.println(absoluteFile);

                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                      File absoluteFile1 = file1.getAbsoluteFile();
                                      System.out.println(absoluteFile1);
                                      String path1 = file1.getPath();
                                      System.out.println(path1);

                                      //path 使用的是构建路径。
                                      String parent = file1.getParent();
                                      System.out.println("parent:"+parent);

                                      long length = file1.length();
                                      System.out.println("字节："+length);

                                      long l = file1.lastModified();
                                      Date date = new Date(l);
                                      System.out.println(date);

                                      //1.8 转换成时间 ？？？

                                  }

                                  /*
                                  * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                  * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                  * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                  关于路径：
                                  * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                  * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                    * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                    * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                   */
                                  @Test
                                  public void test01(){
                                      //绝对路径
                                      File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                      //获取名称
                                      System.out.println(file.getName());
                                      //输出
                                      System.out.println(file);

                                      //相对路径
                                      File file1 = new File("upload", "a.txt");// upload\\a.txt
                                      //获取名称
                                      System.out.println(file1.getName());
                                      //输出
                                      System.out.println(file1);


                                      //构造  public File(File parent, String child)`
                                      File upload = new File("upload");
                                      File file2 = new File(upload, "b.txt");

                                      //获取名称
                                      System.out.println(file2.getName());
                                      //输出
                                      System.out.println(file2);
                                  }
                              }package com.lc.day17.file1;

                               import org.junit.Test;

                               import java.io.File;
                               import java.io.IOException;
                               import java.time.LocalDate;
                               import java.time.format.DateTimeFormatter;
                               import java.util.Date;

                               /**
                                * ClassName: TestFile
                                * Package: com.lc.day17.file1
                                * Description:
                                *
                                * @Author 爱扣钉-陈晨
                                * @Create 2023/8/5 9:23
                                * @Version 1.0
                                */
                               public class TestFile {


                                   /*
                                   - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                   - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                   - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                   - `public boolean delete()` ：删除文件或者文件夹
                                     删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                    */
                                   @Test
                                   public void test05() throws IOException {
                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                       boolean newFile = file1.createNewFile();
                                       System.out.println(newFile);

                                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                       boolean mkdir = file2.mkdir();
                                       System.out.println(mkdir);

                                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                       //时间转换
                                       LocalDate date = LocalDate.now();

                                       DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                       String dateFile = date.format(dateTimeFormatter);

                                       File file = new File(file3, dateFile);
                                       System.out.println(file.mkdir());


                                       //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                       File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                       System.out.println(file4.mkdirs());

                                       System.out.println(file4.delete());

                                       file1.delete();
                                   }


                                   /*
                                   - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                   - `public boolean isDirectory()` ：此File表示的是否为目录。
                                   - `public boolean isFile()` ：此File表示的是否为文件。
                                   - public boolean canRead() ：判断是否可读
                                   - public boolean canWrite() ：判断是否可写
                                   - public boolean isHidden() ：判断是否隐藏
                                    */
                                   @Test
                                   public void test04(){
                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                       boolean exists = file1.exists();
                                       System.out.println("存在："+exists);

                                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                       boolean directory = file2.isDirectory();
                                       System.out.println("文件夹："+directory);
                                       boolean file = file2.isFile();
                                       System.out.println("文件"+file);

                                       boolean b = file2.canRead();
                                       System.out.println("可读"+b);
                                       boolean w = file2.canWrite();
                                       System.out.println("可写"+w);

                                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                       boolean hidden = file3.isHidden();
                                       System.out.println("隐藏："+hidden);
                                   }

                                   /*
                                    * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                    * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                    */
                                   @Test
                                   public void test03(){
                                       //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                       File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                       String[] list = file.list();
                                       //遍历
                                       for (String s : list) {
                                           System.out.println("名称："+s);
                                       }

                                       //File数组
                                       File[] files = file.listFiles();

                                       for (File file1 : files) {
                                           System.out.println(file1.getName());
                                           System.out.println(file1.getAbsoluteFile());
                                       }


                                   }



                                   /*
                                    * public String getName() ：获取名称
                                    * public String getPath() ：获取路径
                                    * `public String getAbsolutePath()`：获取绝对路径
                                    * public File getAbsoluteFile()：获取绝对路径表示的文件
                                    * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                    * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                    * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                    */
                                   @Test
                                   public void test02(){
                                       File file = new File("upload\\a.txt");
                                       System.out.println(file.getName());
                                       String path = file.getPath();
                                       System.out.println(path);
                                       File absoluteFile = file.getAbsoluteFile();
                                       System.out.println(absoluteFile);

                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                       File absoluteFile1 = file1.getAbsoluteFile();
                                       System.out.println(absoluteFile1);
                                       String path1 = file1.getPath();
                                       System.out.println(path1);

                                       //path 使用的是构建路径。
                                       String parent = file1.getParent();
                                       System.out.println("parent:"+parent);

                                       long length = file1.length();
                                       System.out.println("字节："+length);

                                       long l = file1.lastModified();
                                       Date date = new Date(l);
                                       System.out.println(date);

                                       //1.8 转换成时间 ？？？

                                   }

                                   /*
                                   * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                   * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                   * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                   关于路径：
                                   * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                   * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                     * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                     * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                    */
                                   @Test
                                   public void test01(){
                                       //绝对路径
                                       File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                       //获取名称
                                       System.out.println(file.getName());
                                       //输出
                                       System.out.println(file);

                                       //相对路径
                                       File file1 = new File("upload", "a.txt");// upload\\a.txt
                                       //获取名称
                                       System.out.println(file1.getName());
                                       //输出
                                       System.out.println(file1);


                                       //构造  public File(File parent, String child)`
                                       File upload = new File("upload");
                                       File file2 = new File(upload, "b.txt");

                                       //获取名称
                                       System.out.println(file2.getName());
                                       //输出
                                       System.out.println(file2);
                                   }
                               }package com.lc.day17.file1;

                                import org.junit.Test;

                                import java.io.File;
                                import java.io.IOException;
                                import java.time.LocalDate;
                                import java.time.format.DateTimeFormatter;
                                import java.util.Date;

                                /**
                                 * ClassName: TestFile
                                 * Package: com.lc.day17.file1
                                 * Description:
                                 *
                                 * @Author 爱扣钉-陈晨
                                 * @Create 2023/8/5 9:23
                                 * @Version 1.0
                                 */
                                public class TestFile {


                                    /*
                                    - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                    - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                    - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                    - `public boolean delete()` ：删除文件或者文件夹
                                      删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                     */
                                    @Test
                                    public void test05() throws IOException {
                                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                        boolean newFile = file1.createNewFile();
                                        System.out.println(newFile);

                                        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                        boolean mkdir = file2.mkdir();
                                        System.out.println(mkdir);

                                        File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                        //时间转换
                                        LocalDate date = LocalDate.now();

                                        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                        String dateFile = date.format(dateTimeFormatter);

                                        File file = new File(file3, dateFile);
                                        System.out.println(file.mkdir());


                                        //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                        File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                        System.out.println(file4.mkdirs());

                                        System.out.println(file4.delete());

                                        file1.delete();
                                    }


                                    /*
                                    - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                    - `public boolean isDirectory()` ：此File表示的是否为目录。
                                    - `public boolean isFile()` ：此File表示的是否为文件。
                                    - public boolean canRead() ：判断是否可读
                                    - public boolean canWrite() ：判断是否可写
                                    - public boolean isHidden() ：判断是否隐藏
                                     */
                                    @Test
                                    public void test04(){
                                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                        boolean exists = file1.exists();
                                        System.out.println("存在："+exists);

                                        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                        boolean directory = file2.isDirectory();
                                        System.out.println("文件夹："+directory);
                                        boolean file = file2.isFile();
                                        System.out.println("文件"+file);

                                        boolean b = file2.canRead();
                                        System.out.println("可读"+b);
                                        boolean w = file2.canWrite();
                                        System.out.println("可写"+w);

                                        File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                        boolean hidden = file3.isHidden();
                                        System.out.println("隐藏："+hidden);
                                    }

                                    /*
                                     * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                     * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                     */
                                    @Test
                                    public void test03(){
                                        //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                        File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                        String[] list = file.list();
                                        //遍历
                                        for (String s : list) {
                                            System.out.println("名称："+s);
                                        }

                                        //File数组
                                        File[] files = file.listFiles();

                                        for (File file1 : files) {
                                            System.out.println(file1.getName());
                                            System.out.println(file1.getAbsoluteFile());
                                        }


                                    }



                                    /*
                                     * public String getName() ：获取名称
                                     * public String getPath() ：获取路径
                                     * `public String getAbsolutePath()`：获取绝对路径
                                     * public File getAbsoluteFile()：获取绝对路径表示的文件
                                     * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                     * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                     * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                     */
                                    @Test
                                    public void test02(){
                                        File file = new File("upload\\a.txt");
                                        System.out.println(file.getName());
                                        String path = file.getPath();
                                        System.out.println(path);
                                        File absoluteFile = file.getAbsoluteFile();
                                        System.out.println(absoluteFile);

                                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                        File absoluteFile1 = file1.getAbsoluteFile();
                                        System.out.println(absoluteFile1);
                                        String path1 = file1.getPath();
                                        System.out.println(path1);

                                        //path 使用的是构建路径。
                                        String parent = file1.getParent();
                                        System.out.println("parent:"+parent);

                                        long length = file1.length();
                                        System.out.println("字节："+length);

                                        long l = file1.lastModified();
                                        Date date = new Date(l);
                                        System.out.println(date);

                                        //1.8 转换成时间 ？？？

                                    }

                                    /*
                                    * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                    * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                    * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                    关于路径：
                                    * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                    * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                      * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                      * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                     */
                                    @Test
                                    public void test01(){
                                        //绝对路径
                                        File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                        //获取名称
                                        System.out.println(file.getName());
                                        //输出
                                        System.out.println(file);

                                        //相对路径
                                        File file1 = new File("upload", "a.txt");// upload\\a.txt
                                        //获取名称
                                        System.out.println(file1.getName());
                                        //输出
                                        System.out.println(file1);


                                        //构造  public File(File parent, String child)`
                                        File upload = new File("upload");
                                        File file2 = new File(upload, "b.txt");

                                        //获取名称
                                        System.out.println(file2.getName());
                                        //输出
                                        System.out.println(file2);
                                    }
                                }package com.lc.day17.file1;

                                 import org.junit.Test;

                                 import java.io.File;
                                 import java.io.IOException;
                                 import java.time.LocalDate;
                                 import java.time.format.DateTimeFormatter;
                                 import java.util.Date;

                                 /**
                                  * ClassName: TestFile
                                  * Package: com.lc.day17.file1
                                  * Description:
                                  *
                                  * @Author 爱扣钉-陈晨
                                  * @Create 2023/8/5 9:23
                                  * @Version 1.0
                                  */
                                 public class TestFile {


                                     /*
                                     - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                     - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                     - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                     - `public boolean delete()` ：删除文件或者文件夹
                                       删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                      */
                                     @Test
                                     public void test05() throws IOException {
                                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                         boolean newFile = file1.createNewFile();
                                         System.out.println(newFile);

                                         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                         boolean mkdir = file2.mkdir();
                                         System.out.println(mkdir);

                                         File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                         //时间转换
                                         LocalDate date = LocalDate.now();

                                         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                         String dateFile = date.format(dateTimeFormatter);

                                         File file = new File(file3, dateFile);
                                         System.out.println(file.mkdir());


                                         //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                         File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                         System.out.println(file4.mkdirs());

                                         System.out.println(file4.delete());

                                         file1.delete();
                                     }


                                     /*
                                     - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                     - `public boolean isDirectory()` ：此File表示的是否为目录。
                                     - `public boolean isFile()` ：此File表示的是否为文件。
                                     - public boolean canRead() ：判断是否可读
                                     - public boolean canWrite() ：判断是否可写
                                     - public boolean isHidden() ：判断是否隐藏
                                      */
                                     @Test
                                     public void test04(){
                                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                         boolean exists = file1.exists();
                                         System.out.println("存在："+exists);

                                         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                         boolean directory = file2.isDirectory();
                                         System.out.println("文件夹："+directory);
                                         boolean file = file2.isFile();
                                         System.out.println("文件"+file);

                                         boolean b = file2.canRead();
                                         System.out.println("可读"+b);
                                         boolean w = file2.canWrite();
                                         System.out.println("可写"+w);

                                         File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                         boolean hidden = file3.isHidden();
                                         System.out.println("隐藏："+hidden);
                                     }

                                     /*
                                      * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                      * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                      */
                                     @Test
                                     public void test03(){
                                         //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                         File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                         String[] list = file.list();
                                         //遍历
                                         for (String s : list) {
                                             System.out.println("名称："+s);
                                         }

                                         //File数组
                                         File[] files = file.listFiles();

                                         for (File file1 : files) {
                                             System.out.println(file1.getName());
                                             System.out.println(file1.getAbsoluteFile());
                                         }


                                     }



                                     /*
                                      * public String getName() ：获取名称
                                      * public String getPath() ：获取路径
                                      * `public String getAbsolutePath()`：获取绝对路径
                                      * public File getAbsoluteFile()：获取绝对路径表示的文件
                                      * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                      * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                      * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                      */
                                     @Test
                                     public void test02(){
                                         File file = new File("upload\\a.txt");
                                         System.out.println(file.getName());
                                         String path = file.getPath();
                                         System.out.println(path);
                                         File absoluteFile = file.getAbsoluteFile();
                                         System.out.println(absoluteFile);

                                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                         File absoluteFile1 = file1.getAbsoluteFile();
                                         System.out.println(absoluteFile1);
                                         String path1 = file1.getPath();
                                         System.out.println(path1);

                                         //path 使用的是构建路径。
                                         String parent = file1.getParent();
                                         System.out.println("parent:"+parent);

                                         long length = file1.length();
                                         System.out.println("字节："+length);

                                         long l = file1.lastModified();
                                         Date date = new Date(l);
                                         System.out.println(date);

                                         //1.8 转换成时间 ？？？

                                     }

                                     /*
                                     * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                     * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                     * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                     关于路径：
                                     * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                     * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                       * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                       * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                      */
                                     @Test
                                     public void test01(){
                                         //绝对路径
                                         File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                         //获取名称
                                         System.out.println(file.getName());
                                         //输出
                                         System.out.println(file);

                                         //相对路径
                                         File file1 = new File("upload", "a.txt");// upload\\a.txt
                                         //获取名称
                                         System.out.println(file1.getName());
                                         //输出
                                         System.out.println(file1);


                                         //构造  public File(File parent, String child)`
                                         File upload = new File("upload");
                                         File file2 = new File(upload, "b.txt");

                                         //获取名称
                                         System.out.println(file2.getName());
                                         //输出
                                         System.out.println(file2);
                                     }
                                 }package com.lc.day17.file1;

                                  import org.junit.Test;

                                  import java.io.File;
                                  import java.io.IOException;
                                  import java.time.LocalDate;
                                  import java.time.format.DateTimeFormatter;
                                  import java.util.Date;

                                  /**
                                   * ClassName: TestFile
                                   * Package: com.lc.day17.file1
                                   * Description:
                                   *
                                   * @Author 爱扣钉-陈晨
                                   * @Create 2023/8/5 9:23
                                   * @Version 1.0
                                   */
                                  public class TestFile {


                                      /*
                                      - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                      - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                      - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                      - `public boolean delete()` ：删除文件或者文件夹
                                        删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                       */
                                      @Test
                                      public void test05() throws IOException {
                                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                          boolean newFile = file1.createNewFile();
                                          System.out.println(newFile);

                                          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                          boolean mkdir = file2.mkdir();
                                          System.out.println(mkdir);

                                          File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                          //时间转换
                                          LocalDate date = LocalDate.now();

                                          DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                          String dateFile = date.format(dateTimeFormatter);

                                          File file = new File(file3, dateFile);
                                          System.out.println(file.mkdir());


                                          //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                          File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                          System.out.println(file4.mkdirs());

                                          System.out.println(file4.delete());

                                          file1.delete();
                                      }


                                      /*
                                      - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                      - `public boolean isDirectory()` ：此File表示的是否为目录。
                                      - `public boolean isFile()` ：此File表示的是否为文件。
                                      - public boolean canRead() ：判断是否可读
                                      - public boolean canWrite() ：判断是否可写
                                      - public boolean isHidden() ：判断是否隐藏
                                       */
                                      @Test
                                      public void test04(){
                                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                          boolean exists = file1.exists();
                                          System.out.println("存在："+exists);

                                          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                          boolean directory = file2.isDirectory();
                                          System.out.println("文件夹："+directory);
                                          boolean file = file2.isFile();
                                          System.out.println("文件"+file);

                                          boolean b = file2.canRead();
                                          System.out.println("可读"+b);
                                          boolean w = file2.canWrite();
                                          System.out.println("可写"+w);

                                          File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                          boolean hidden = file3.isHidden();
                                          System.out.println("隐藏："+hidden);
                                      }

                                      /*
                                       * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                       * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                       */
                                      @Test
                                      public void test03(){
                                          //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                          File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                          String[] list = file.list();
                                          //遍历
                                          for (String s : list) {
                                              System.out.println("名称："+s);
                                          }

                                          //File数组
                                          File[] files = file.listFiles();

                                          for (File file1 : files) {
                                              System.out.println(file1.getName());
                                              System.out.println(file1.getAbsoluteFile());
                                          }


                                      }



                                      /*
                                       * public String getName() ：获取名称
                                       * public String getPath() ：获取路径
                                       * `public String getAbsolutePath()`：获取绝对路径
                                       * public File getAbsoluteFile()：获取绝对路径表示的文件
                                       * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                       * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                       * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                       */
                                      @Test
                                      public void test02(){
                                          File file = new File("upload\\a.txt");
                                          System.out.println(file.getName());
                                          String path = file.getPath();
                                          System.out.println(path);
                                          File absoluteFile = file.getAbsoluteFile();
                                          System.out.println(absoluteFile);

                                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                          File absoluteFile1 = file1.getAbsoluteFile();
                                          System.out.println(absoluteFile1);
                                          String path1 = file1.getPath();
                                          System.out.println(path1);

                                          //path 使用的是构建路径。
                                          String parent = file1.getParent();
                                          System.out.println("parent:"+parent);

                                          long length = file1.length();
                                          System.out.println("字节："+length);

                                          long l = file1.lastModified();
                                          Date date = new Date(l);
                                          System.out.println(date);

                                          //1.8 转换成时间 ？？？

                                      }

                                      /*
                                      * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                      * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                      * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                      关于路径：
                                      * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                      * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                        * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                        * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                       */
                                      @Test
                                      public void test01(){
                                          //绝对路径
                                          File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                          //获取名称
                                          System.out.println(file.getName());
                                          //输出
                                          System.out.println(file);

                                          //相对路径
                                          File file1 = new File("upload", "a.txt");// upload\\a.txt
                                          //获取名称
                                          System.out.println(file1.getName());
                                          //输出
                                          System.out.println(file1);


                                          //构造  public File(File parent, String child)`
                                          File upload = new File("upload");
                                          File file2 = new File(upload, "b.txt");

                                          //获取名称
                                          System.out.println(file2.getName());
                                          //输出
                                          System.out.println(file2);
                                      }
                                  }package com.lc.day17.file1;

                                   import org.junit.Test;

                                   import java.io.File;
                                   import java.io.IOException;
                                   import java.time.LocalDate;
                                   import java.time.format.DateTimeFormatter;
                                   import java.util.Date;

                                   /**
                                    * ClassName: TestFile
                                    * Package: com.lc.day17.file1
                                    * Description:
                                    *
                                    * @Author 爱扣钉-陈晨
                                    * @Create 2023/8/5 9:23
                                    * @Version 1.0
                                    */
                                   public class TestFile {


                                       /*
                                       - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                       - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                       - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                       - `public boolean delete()` ：删除文件或者文件夹
                                         删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                        */
                                       @Test
                                       public void test05() throws IOException {
                                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                           boolean newFile = file1.createNewFile();
                                           System.out.println(newFile);

                                           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                           boolean mkdir = file2.mkdir();
                                           System.out.println(mkdir);

                                           File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                           //时间转换
                                           LocalDate date = LocalDate.now();

                                           DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                           String dateFile = date.format(dateTimeFormatter);

                                           File file = new File(file3, dateFile);
                                           System.out.println(file.mkdir());


                                           //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                           File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                           System.out.println(file4.mkdirs());

                                           System.out.println(file4.delete());

                                           file1.delete();
                                       }


                                       /*
                                       - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                       - `public boolean isDirectory()` ：此File表示的是否为目录。
                                       - `public boolean isFile()` ：此File表示的是否为文件。
                                       - public boolean canRead() ：判断是否可读
                                       - public boolean canWrite() ：判断是否可写
                                       - public boolean isHidden() ：判断是否隐藏
                                        */
                                       @Test
                                       public void test04(){
                                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                           boolean exists = file1.exists();
                                           System.out.println("存在："+exists);

                                           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                           boolean directory = file2.isDirectory();
                                           System.out.println("文件夹："+directory);
                                           boolean file = file2.isFile();
                                           System.out.println("文件"+file);

                                           boolean b = file2.canRead();
                                           System.out.println("可读"+b);
                                           boolean w = file2.canWrite();
                                           System.out.println("可写"+w);

                                           File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                           boolean hidden = file3.isHidden();
                                           System.out.println("隐藏："+hidden);
                                       }

                                       /*
                                        * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                        * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                        */
                                       @Test
                                       public void test03(){
                                           //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                           File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                           String[] list = file.list();
                                           //遍历
                                           for (String s : list) {
                                               System.out.println("名称："+s);
                                           }

                                           //File数组
                                           File[] files = file.listFiles();

                                           for (File file1 : files) {
                                               System.out.println(file1.getName());
                                               System.out.println(file1.getAbsoluteFile());
                                           }


                                       }



                                       /*
                                        * public String getName() ：获取名称
                                        * public String getPath() ：获取路径
                                        * `public String getAbsolutePath()`：获取绝对路径
                                        * public File getAbsoluteFile()：获取绝对路径表示的文件
                                        * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                        * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                        * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                        */
                                       @Test
                                       public void test02(){
                                           File file = new File("upload\\a.txt");
                                           System.out.println(file.getName());
                                           String path = file.getPath();
                                           System.out.println(path);
                                           File absoluteFile = file.getAbsoluteFile();
                                           System.out.println(absoluteFile);

                                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                           File absoluteFile1 = file1.getAbsoluteFile();
                                           System.out.println(absoluteFile1);
                                           String path1 = file1.getPath();
                                           System.out.println(path1);

                                           //path 使用的是构建路径。
                                           String parent = file1.getParent();
                                           System.out.println("parent:"+parent);

                                           long length = file1.length();
                                           System.out.println("字节："+length);

                                           long l = file1.lastModified();
                                           Date date = new Date(l);
                                           System.out.println(date);

                                           //1.8 转换成时间 ？？？

                                       }

                                       /*
                                       * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                       * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                       * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                       关于路径：
                                       * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                       * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                         * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                         * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                        */
                                       @Test
                                       public void test01(){
                                           //绝对路径
                                           File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                           //获取名称
                                           System.out.println(file.getName());
                                           //输出
                                           System.out.println(file);

                                           //相对路径
                                           File file1 = new File("upload", "a.txt");// upload\\a.txt
                                           //获取名称
                                           System.out.println(file1.getName());
                                           //输出
                                           System.out.println(file1);


                                           //构造  public File(File parent, String child)`
                                           File upload = new File("upload");
                                           File file2 = new File(upload, "b.txt");

                                           //获取名称
                                           System.out.println(file2.getName());
                                           //输出
                                           System.out.println(file2);
                                       }
                                   }package com.lc.day17.file1;

                                    import org.junit.Test;

                                    import java.io.File;
                                    import java.io.IOException;
                                    import java.time.LocalDate;
                                    import java.time.format.DateTimeFormatter;
                                    import java.util.Date;

                                    /**
                                     * ClassName: TestFile
                                     * Package: com.lc.day17.file1
                                     * Description:
                                     *
                                     * @Author 爱扣钉-陈晨
                                     * @Create 2023/8/5 9:23
                                     * @Version 1.0
                                     */
                                    public class TestFile {


                                        /*
                                        - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                        - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                        - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                        - `public boolean delete()` ：删除文件或者文件夹
                                          删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                         */
                                        @Test
                                        public void test05() throws IOException {
                                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                            boolean newFile = file1.createNewFile();
                                            System.out.println(newFile);

                                            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                            boolean mkdir = file2.mkdir();
                                            System.out.println(mkdir);

                                            File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                            //时间转换
                                            LocalDate date = LocalDate.now();

                                            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                            String dateFile = date.format(dateTimeFormatter);

                                            File file = new File(file3, dateFile);
                                            System.out.println(file.mkdir());


                                            //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                            File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                            System.out.println(file4.mkdirs());

                                            System.out.println(file4.delete());

                                            file1.delete();
                                        }


                                        /*
                                        - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                        - `public boolean isDirectory()` ：此File表示的是否为目录。
                                        - `public boolean isFile()` ：此File表示的是否为文件。
                                        - public boolean canRead() ：判断是否可读
                                        - public boolean canWrite() ：判断是否可写
                                        - public boolean isHidden() ：判断是否隐藏
                                         */
                                        @Test
                                        public void test04(){
                                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                            boolean exists = file1.exists();
                                            System.out.println("存在："+exists);

                                            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                            boolean directory = file2.isDirectory();
                                            System.out.println("文件夹："+directory);
                                            boolean file = file2.isFile();
                                            System.out.println("文件"+file);

                                            boolean b = file2.canRead();
                                            System.out.println("可读"+b);
                                            boolean w = file2.canWrite();
                                            System.out.println("可写"+w);

                                            File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                            boolean hidden = file3.isHidden();
                                            System.out.println("隐藏："+hidden);
                                        }

                                        /*
                                         * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                         * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                         */
                                        @Test
                                        public void test03(){
                                            //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                            File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                            String[] list = file.list();
                                            //遍历
                                            for (String s : list) {
                                                System.out.println("名称："+s);
                                            }

                                            //File数组
                                            File[] files = file.listFiles();

                                            for (File file1 : files) {
                                                System.out.println(file1.getName());
                                                System.out.println(file1.getAbsoluteFile());
                                            }


                                        }



                                        /*
                                         * public String getName() ：获取名称
                                         * public String getPath() ：获取路径
                                         * `public String getAbsolutePath()`：获取绝对路径
                                         * public File getAbsoluteFile()：获取绝对路径表示的文件
                                         * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                         * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                         * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                         */
                                        @Test
                                        public void test02(){
                                            File file = new File("upload\\a.txt");
                                            System.out.println(file.getName());
                                            String path = file.getPath();
                                            System.out.println(path);
                                            File absoluteFile = file.getAbsoluteFile();
                                            System.out.println(absoluteFile);

                                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                            File absoluteFile1 = file1.getAbsoluteFile();
                                            System.out.println(absoluteFile1);
                                            String path1 = file1.getPath();
                                            System.out.println(path1);

                                            //path 使用的是构建路径。
                                            String parent = file1.getParent();
                                            System.out.println("parent:"+parent);

                                            long length = file1.length();
                                            System.out.println("字节："+length);

                                            long l = file1.lastModified();
                                            Date date = new Date(l);
                                            System.out.println(date);

                                            //1.8 转换成时间 ？？？

                                        }

                                        /*
                                        * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                        * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                        * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                        关于路径：
                                        * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                        * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                          * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                          * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                         */
                                        @Test
                                        public void test01(){
                                            //绝对路径
                                            File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                            //获取名称
                                            System.out.println(file.getName());
                                            //输出
                                            System.out.println(file);

                                            //相对路径
                                            File file1 = new File("upload", "a.txt");// upload\\a.txt
                                            //获取名称
                                            System.out.println(file1.getName());
                                            //输出
                                            System.out.println(file1);


                                            //构造  public File(File parent, String child)`
                                            File upload = new File("upload");
                                            File file2 = new File(upload, "b.txt");

                                            //获取名称
                                            System.out.println(file2.getName());
                                            //输出
                                            System.out.println(file2);
                                        }
                                    }package com.lc.day17.file1;

                                     import org.junit.Test;

                                     import java.io.File;
                                     import java.io.IOException;
                                     import java.time.LocalDate;
                                     import java.time.format.DateTimeFormatter;
                                     import java.util.Date;

                                     /**
                                      * ClassName: TestFile
                                      * Package: com.lc.day17.file1
                                      * Description:
                                      *
                                      * @Author 爱扣钉-陈晨
                                      * @Create 2023/8/5 9:23
                                      * @Version 1.0
                                      */
                                     public class TestFile {


                                         /*
                                         - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                         - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                         - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                         - `public boolean delete()` ：删除文件或者文件夹
                                           删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                          */
                                         @Test
                                         public void test05() throws IOException {
                                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                             boolean newFile = file1.createNewFile();
                                             System.out.println(newFile);

                                             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                             boolean mkdir = file2.mkdir();
                                             System.out.println(mkdir);

                                             File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                             //时间转换
                                             LocalDate date = LocalDate.now();

                                             DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                             String dateFile = date.format(dateTimeFormatter);

                                             File file = new File(file3, dateFile);
                                             System.out.println(file.mkdir());


                                             //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                             File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                             System.out.println(file4.mkdirs());

                                             System.out.println(file4.delete());

                                             file1.delete();
                                         }


                                         /*
                                         - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                         - `public boolean isDirectory()` ：此File表示的是否为目录。
                                         - `public boolean isFile()` ：此File表示的是否为文件。
                                         - public boolean canRead() ：判断是否可读
                                         - public boolean canWrite() ：判断是否可写
                                         - public boolean isHidden() ：判断是否隐藏
                                          */
                                         @Test
                                         public void test04(){
                                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                             boolean exists = file1.exists();
                                             System.out.println("存在："+exists);

                                             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                             boolean directory = file2.isDirectory();
                                             System.out.println("文件夹："+directory);
                                             boolean file = file2.isFile();
                                             System.out.println("文件"+file);

                                             boolean b = file2.canRead();
                                             System.out.println("可读"+b);
                                             boolean w = file2.canWrite();
                                             System.out.println("可写"+w);

                                             File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                             boolean hidden = file3.isHidden();
                                             System.out.println("隐藏："+hidden);
                                         }

                                         /*
                                          * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                          * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                          */
                                         @Test
                                         public void test03(){
                                             //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                             File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                             String[] list = file.list();
                                             //遍历
                                             for (String s : list) {
                                                 System.out.println("名称："+s);
                                             }

                                             //File数组
                                             File[] files = file.listFiles();

                                             for (File file1 : files) {
                                                 System.out.println(file1.getName());
                                                 System.out.println(file1.getAbsoluteFile());
                                             }


                                         }



                                         /*
                                          * public String getName() ：获取名称
                                          * public String getPath() ：获取路径
                                          * `public String getAbsolutePath()`：获取绝对路径
                                          * public File getAbsoluteFile()：获取绝对路径表示的文件
                                          * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                          * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                          * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                          */
                                         @Test
                                         public void test02(){
                                             File file = new File("upload\\a.txt");
                                             System.out.println(file.getName());
                                             String path = file.getPath();
                                             System.out.println(path);
                                             File absoluteFile = file.getAbsoluteFile();
                                             System.out.println(absoluteFile);

                                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                             File absoluteFile1 = file1.getAbsoluteFile();
                                             System.out.println(absoluteFile1);
                                             String path1 = file1.getPath();
                                             System.out.println(path1);

                                             //path 使用的是构建路径。
                                             String parent = file1.getParent();
                                             System.out.println("parent:"+parent);

                                             long length = file1.length();
                                             System.out.println("字节："+length);

                                             long l = file1.lastModified();
                                             Date date = new Date(l);
                                             System.out.println(date);

                                             //1.8 转换成时间 ？？？

                                         }

                                         /*
                                         * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                         * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                         * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                         关于路径：
                                         * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                         * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                           * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                           * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                          */
                                         @Test
                                         public void test01(){
                                             //绝对路径
                                             File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                             //获取名称
                                             System.out.println(file.getName());
                                             //输出
                                             System.out.println(file);

                                             //相对路径
                                             File file1 = new File("upload", "a.txt");// upload\\a.txt
                                             //获取名称
                                             System.out.println(file1.getName());
                                             //输出
                                             System.out.println(file1);


                                             //构造  public File(File parent, String child)`
                                             File upload = new File("upload");
                                             File file2 = new File(upload, "b.txt");

                                             //获取名称
                                             System.out.println(file2.getName());
                                             //输出
                                             System.out.println(file2);
                                         }
                                     }package com.lc.day17.file1;

                                      import org.junit.Test;

                                      import java.io.File;
                                      import java.io.IOException;
                                      import java.time.LocalDate;
                                      import java.time.format.DateTimeFormatter;
                                      import java.util.Date;

                                      /**
                                       * ClassName: TestFile
                                       * Package: com.lc.day17.file1
                                       * Description:
                                       *
                                       * @Author 爱扣钉-陈晨
                                       * @Create 2023/8/5 9:23
                                       * @Version 1.0
                                       */
                                      public class TestFile {


                                          /*
                                          - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                          - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                          - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                          - `public boolean delete()` ：删除文件或者文件夹
                                            删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                           */
                                          @Test
                                          public void test05() throws IOException {
                                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                              boolean newFile = file1.createNewFile();
                                              System.out.println(newFile);

                                              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                              boolean mkdir = file2.mkdir();
                                              System.out.println(mkdir);

                                              File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                              //时间转换
                                              LocalDate date = LocalDate.now();

                                              DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                              String dateFile = date.format(dateTimeFormatter);

                                              File file = new File(file3, dateFile);
                                              System.out.println(file.mkdir());


                                              //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                              File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                              System.out.println(file4.mkdirs());

                                              System.out.println(file4.delete());

                                              file1.delete();
                                          }


                                          /*
                                          - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                          - `public boolean isDirectory()` ：此File表示的是否为目录。
                                          - `public boolean isFile()` ：此File表示的是否为文件。
                                          - public boolean canRead() ：判断是否可读
                                          - public boolean canWrite() ：判断是否可写
                                          - public boolean isHidden() ：判断是否隐藏
                                           */
                                          @Test
                                          public void test04(){
                                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                              boolean exists = file1.exists();
                                              System.out.println("存在："+exists);

                                              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                              boolean directory = file2.isDirectory();
                                              System.out.println("文件夹："+directory);
                                              boolean file = file2.isFile();
                                              System.out.println("文件"+file);

                                              boolean b = file2.canRead();
                                              System.out.println("可读"+b);
                                              boolean w = file2.canWrite();
                                              System.out.println("可写"+w);

                                              File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                              boolean hidden = file3.isHidden();
                                              System.out.println("隐藏："+hidden);
                                          }

                                          /*
                                           * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                           * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                           */
                                          @Test
                                          public void test03(){
                                              //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                              File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                              String[] list = file.list();
                                              //遍历
                                              for (String s : list) {
                                                  System.out.println("名称："+s);
                                              }

                                              //File数组
                                              File[] files = file.listFiles();

                                              for (File file1 : files) {
                                                  System.out.println(file1.getName());
                                                  System.out.println(file1.getAbsoluteFile());
                                              }


                                          }



                                          /*
                                           * public String getName() ：获取名称
                                           * public String getPath() ：获取路径
                                           * `public String getAbsolutePath()`：获取绝对路径
                                           * public File getAbsoluteFile()：获取绝对路径表示的文件
                                           * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                           * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                           * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                           */
                                          @Test
                                          public void test02(){
                                              File file = new File("upload\\a.txt");
                                              System.out.println(file.getName());
                                              String path = file.getPath();
                                              System.out.println(path);
                                              File absoluteFile = file.getAbsoluteFile();
                                              System.out.println(absoluteFile);

                                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                              File absoluteFile1 = file1.getAbsoluteFile();
                                              System.out.println(absoluteFile1);
                                              String path1 = file1.getPath();
                                              System.out.println(path1);

                                              //path 使用的是构建路径。
                                              String parent = file1.getParent();
                                              System.out.println("parent:"+parent);

                                              long length = file1.length();
                                              System.out.println("字节："+length);

                                              long l = file1.lastModified();
                                              Date date = new Date(l);
                                              System.out.println(date);

                                              //1.8 转换成时间 ？？？

                                          }

                                          /*
                                          * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                          * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                          * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                          关于路径：
                                          * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                          * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                            * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                            * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                           */
                                          @Test
                                          public void test01(){
                                              //绝对路径
                                              File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                              //获取名称
                                              System.out.println(file.getName());
                                              //输出
                                              System.out.println(file);

                                              //相对路径
                                              File file1 = new File("upload", "a.txt");// upload\\a.txt
                                              //获取名称
                                              System.out.println(file1.getName());
                                              //输出
                                              System.out.println(file1);


                                              //构造  public File(File parent, String child)`
                                              File upload = new File("upload");
                                              File file2 = new File(upload, "b.txt");

                                              //获取名称
                                              System.out.println(file2.getName());
                                              //输出
                                              System.out.println(file2);
                                          }
                                      }package com.lc.day17.file1;

                                       import org.junit.Test;

                                       import java.io.File;
                                       import java.io.IOException;
                                       import java.time.LocalDate;
                                       import java.time.format.DateTimeFormatter;
                                       import java.util.Date;

                                       /**
                                        * ClassName: TestFile
                                        * Package: com.lc.day17.file1
                                        * Description:
                                        *
                                        * @Author 爱扣钉-陈晨
                                        * @Create 2023/8/5 9:23
                                        * @Version 1.0
                                        */
                                       public class TestFile {


                                           /*
                                           - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                           - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                           - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                           - `public boolean delete()` ：删除文件或者文件夹
                                             删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                            */
                                           @Test
                                           public void test05() throws IOException {
                                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                               boolean newFile = file1.createNewFile();
                                               System.out.println(newFile);

                                               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                               boolean mkdir = file2.mkdir();
                                               System.out.println(mkdir);

                                               File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                               //时间转换
                                               LocalDate date = LocalDate.now();

                                               DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                               String dateFile = date.format(dateTimeFormatter);

                                               File file = new File(file3, dateFile);
                                               System.out.println(file.mkdir());


                                               //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                               File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                               System.out.println(file4.mkdirs());

                                               System.out.println(file4.delete());

                                               file1.delete();
                                           }


                                           /*
                                           - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                           - `public boolean isDirectory()` ：此File表示的是否为目录。
                                           - `public boolean isFile()` ：此File表示的是否为文件。
                                           - public boolean canRead() ：判断是否可读
                                           - public boolean canWrite() ：判断是否可写
                                           - public boolean isHidden() ：判断是否隐藏
                                            */
                                           @Test
                                           public void test04(){
                                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                               boolean exists = file1.exists();
                                               System.out.println("存在："+exists);

                                               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                               boolean directory = file2.isDirectory();
                                               System.out.println("文件夹："+directory);
                                               boolean file = file2.isFile();
                                               System.out.println("文件"+file);

                                               boolean b = file2.canRead();
                                               System.out.println("可读"+b);
                                               boolean w = file2.canWrite();
                                               System.out.println("可写"+w);

                                               File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                               boolean hidden = file3.isHidden();
                                               System.out.println("隐藏："+hidden);
                                           }

                                           /*
                                            * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                            * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                            */
                                           @Test
                                           public void test03(){
                                               //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                               File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                               String[] list = file.list();
                                               //遍历
                                               for (String s : list) {
                                                   System.out.println("名称："+s);
                                               }

                                               //File数组
                                               File[] files = file.listFiles();

                                               for (File file1 : files) {
                                                   System.out.println(file1.getName());
                                                   System.out.println(file1.getAbsoluteFile());
                                               }


                                           }



                                           /*
                                            * public String getName() ：获取名称
                                            * public String getPath() ：获取路径
                                            * `public String getAbsolutePath()`：获取绝对路径
                                            * public File getAbsoluteFile()：获取绝对路径表示的文件
                                            * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                            * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                            * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                            */
                                           @Test
                                           public void test02(){
                                               File file = new File("upload\\a.txt");
                                               System.out.println(file.getName());
                                               String path = file.getPath();
                                               System.out.println(path);
                                               File absoluteFile = file.getAbsoluteFile();
                                               System.out.println(absoluteFile);

                                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                               File absoluteFile1 = file1.getAbsoluteFile();
                                               System.out.println(absoluteFile1);
                                               String path1 = file1.getPath();
                                               System.out.println(path1);

                                               //path 使用的是构建路径。
                                               String parent = file1.getParent();
                                               System.out.println("parent:"+parent);

                                               long length = file1.length();
                                               System.out.println("字节："+length);

                                               long l = file1.lastModified();
                                               Date date = new Date(l);
                                               System.out.println(date);

                                               //1.8 转换成时间 ？？？

                                           }

                                           /*
                                           * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                           * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                           * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                           关于路径：
                                           * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                           * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                             * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                             * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                            */
                                           @Test
                                           public void test01(){
                                               //绝对路径
                                               File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                               //获取名称
                                               System.out.println(file.getName());
                                               //输出
                                               System.out.println(file);

                                               //相对路径
                                               File file1 = new File("upload", "a.txt");// upload\\a.txt
                                               //获取名称
                                               System.out.println(file1.getName());
                                               //输出
                                               System.out.println(file1);


                                               //构造  public File(File parent, String child)`
                                               File upload = new File("upload");
                                               File file2 = new File(upload, "b.txt");

                                               //获取名称
                                               System.out.println(file2.getName());
                                               //输出
                                               System.out.println(file2);
                                           }
                                       }package com.lc.day17.file1;

                                        import org.junit.Test;

                                        import java.io.File;
                                        import java.io.IOException;
                                        import java.time.LocalDate;
                                        import java.time.format.DateTimeFormatter;
                                        import java.util.Date;

                                        /**
                                         * ClassName: TestFile
                                         * Package: com.lc.day17.file1
                                         * Description:
                                         *
                                         * @Author 爱扣钉-陈晨
                                         * @Create 2023/8/5 9:23
                                         * @Version 1.0
                                         */
                                        public class TestFile {


                                            /*
                                            - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                            - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                            - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                            - `public boolean delete()` ：删除文件或者文件夹
                                              删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                             */
                                            @Test
                                            public void test05() throws IOException {
                                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                boolean newFile = file1.createNewFile();
                                                System.out.println(newFile);

                                                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                boolean mkdir = file2.mkdir();
                                                System.out.println(mkdir);

                                                File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                //时间转换
                                                LocalDate date = LocalDate.now();

                                                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                String dateFile = date.format(dateTimeFormatter);

                                                File file = new File(file3, dateFile);
                                                System.out.println(file.mkdir());


                                                //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                System.out.println(file4.mkdirs());

                                                System.out.println(file4.delete());

                                                file1.delete();
                                            }


                                            /*
                                            - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                            - `public boolean isDirectory()` ：此File表示的是否为目录。
                                            - `public boolean isFile()` ：此File表示的是否为文件。
                                            - public boolean canRead() ：判断是否可读
                                            - public boolean canWrite() ：判断是否可写
                                            - public boolean isHidden() ：判断是否隐藏
                                             */
                                            @Test
                                            public void test04(){
                                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                boolean exists = file1.exists();
                                                System.out.println("存在："+exists);

                                                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                boolean directory = file2.isDirectory();
                                                System.out.println("文件夹："+directory);
                                                boolean file = file2.isFile();
                                                System.out.println("文件"+file);

                                                boolean b = file2.canRead();
                                                System.out.println("可读"+b);
                                                boolean w = file2.canWrite();
                                                System.out.println("可写"+w);

                                                File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                boolean hidden = file3.isHidden();
                                                System.out.println("隐藏："+hidden);
                                            }

                                            /*
                                             * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                             * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                             */
                                            @Test
                                            public void test03(){
                                                //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                String[] list = file.list();
                                                //遍历
                                                for (String s : list) {
                                                    System.out.println("名称："+s);
                                                }

                                                //File数组
                                                File[] files = file.listFiles();

                                                for (File file1 : files) {
                                                    System.out.println(file1.getName());
                                                    System.out.println(file1.getAbsoluteFile());
                                                }


                                            }



                                            /*
                                             * public String getName() ：获取名称
                                             * public String getPath() ：获取路径
                                             * `public String getAbsolutePath()`：获取绝对路径
                                             * public File getAbsoluteFile()：获取绝对路径表示的文件
                                             * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                             * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                             * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                             */
                                            @Test
                                            public void test02(){
                                                File file = new File("upload\\a.txt");
                                                System.out.println(file.getName());
                                                String path = file.getPath();
                                                System.out.println(path);
                                                File absoluteFile = file.getAbsoluteFile();
                                                System.out.println(absoluteFile);

                                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                File absoluteFile1 = file1.getAbsoluteFile();
                                                System.out.println(absoluteFile1);
                                                String path1 = file1.getPath();
                                                System.out.println(path1);

                                                //path 使用的是构建路径。
                                                String parent = file1.getParent();
                                                System.out.println("parent:"+parent);

                                                long length = file1.length();
                                                System.out.println("字节："+length);

                                                long l = file1.lastModified();
                                                Date date = new Date(l);
                                                System.out.println(date);

                                                //1.8 转换成时间 ？？？

                                            }

                                            /*
                                            * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                            * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                            * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                            关于路径：
                                            * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                            * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                              * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                              * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                             */
                                            @Test
                                            public void test01(){
                                                //绝对路径
                                                File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                //获取名称
                                                System.out.println(file.getName());
                                                //输出
                                                System.out.println(file);

                                                //相对路径
                                                File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                //获取名称
                                                System.out.println(file1.getName());
                                                //输出
                                                System.out.println(file1);


                                                //构造  public File(File parent, String child)`
                                                File upload = new File("upload");
                                                File file2 = new File(upload, "b.txt");

                                                //获取名称
                                                System.out.println(file2.getName());
                                                //输出
                                                System.out.println(file2);
                                            }
                                        }package com.lc.day17.file1;

                                         import org.junit.Test;

                                         import java.io.File;
                                         import java.io.IOException;
                                         import java.time.LocalDate;
                                         import java.time.format.DateTimeFormatter;
                                         import java.util.Date;

                                         /**
                                          * ClassName: TestFile
                                          * Package: com.lc.day17.file1
                                          * Description:
                                          *
                                          * @Author 爱扣钉-陈晨
                                          * @Create 2023/8/5 9:23
                                          * @Version 1.0
                                          */
                                         public class TestFile {


                                             /*
                                             - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                             - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                             - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                             - `public boolean delete()` ：删除文件或者文件夹
                                               删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                              */
                                             @Test
                                             public void test05() throws IOException {
                                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                 boolean newFile = file1.createNewFile();
                                                 System.out.println(newFile);

                                                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                 boolean mkdir = file2.mkdir();
                                                 System.out.println(mkdir);

                                                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                 //时间转换
                                                 LocalDate date = LocalDate.now();

                                                 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                 String dateFile = date.format(dateTimeFormatter);

                                                 File file = new File(file3, dateFile);
                                                 System.out.println(file.mkdir());


                                                 //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                 File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                 System.out.println(file4.mkdirs());

                                                 System.out.println(file4.delete());

                                                 file1.delete();
                                             }


                                             /*
                                             - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                             - `public boolean isDirectory()` ：此File表示的是否为目录。
                                             - `public boolean isFile()` ：此File表示的是否为文件。
                                             - public boolean canRead() ：判断是否可读
                                             - public boolean canWrite() ：判断是否可写
                                             - public boolean isHidden() ：判断是否隐藏
                                              */
                                             @Test
                                             public void test04(){
                                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                 boolean exists = file1.exists();
                                                 System.out.println("存在："+exists);

                                                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                 boolean directory = file2.isDirectory();
                                                 System.out.println("文件夹："+directory);
                                                 boolean file = file2.isFile();
                                                 System.out.println("文件"+file);

                                                 boolean b = file2.canRead();
                                                 System.out.println("可读"+b);
                                                 boolean w = file2.canWrite();
                                                 System.out.println("可写"+w);

                                                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                 boolean hidden = file3.isHidden();
                                                 System.out.println("隐藏："+hidden);
                                             }

                                             /*
                                              * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                              * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                              */
                                             @Test
                                             public void test03(){
                                                 //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                 File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                 String[] list = file.list();
                                                 //遍历
                                                 for (String s : list) {
                                                     System.out.println("名称："+s);
                                                 }

                                                 //File数组
                                                 File[] files = file.listFiles();

                                                 for (File file1 : files) {
                                                     System.out.println(file1.getName());
                                                     System.out.println(file1.getAbsoluteFile());
                                                 }


                                             }



                                             /*
                                              * public String getName() ：获取名称
                                              * public String getPath() ：获取路径
                                              * `public String getAbsolutePath()`：获取绝对路径
                                              * public File getAbsoluteFile()：获取绝对路径表示的文件
                                              * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                              * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                              * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                              */
                                             @Test
                                             public void test02(){
                                                 File file = new File("upload\\a.txt");
                                                 System.out.println(file.getName());
                                                 String path = file.getPath();
                                                 System.out.println(path);
                                                 File absoluteFile = file.getAbsoluteFile();
                                                 System.out.println(absoluteFile);

                                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                 File absoluteFile1 = file1.getAbsoluteFile();
                                                 System.out.println(absoluteFile1);
                                                 String path1 = file1.getPath();
                                                 System.out.println(path1);

                                                 //path 使用的是构建路径。
                                                 String parent = file1.getParent();
                                                 System.out.println("parent:"+parent);

                                                 long length = file1.length();
                                                 System.out.println("字节："+length);

                                                 long l = file1.lastModified();
                                                 Date date = new Date(l);
                                                 System.out.println(date);

                                                 //1.8 转换成时间 ？？？

                                             }

                                             /*
                                             * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                             * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                             * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                             关于路径：
                                             * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                             * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                               * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                               * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                              */
                                             @Test
                                             public void test01(){
                                                 //绝对路径
                                                 File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                 //获取名称
                                                 System.out.println(file.getName());
                                                 //输出
                                                 System.out.println(file);

                                                 //相对路径
                                                 File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                 //获取名称
                                                 System.out.println(file1.getName());
                                                 //输出
                                                 System.out.println(file1);


                                                 //构造  public File(File parent, String child)`
                                                 File upload = new File("upload");
                                                 File file2 = new File(upload, "b.txt");

                                                 //获取名称
                                                 System.out.println(file2.getName());
                                                 //输出
                                                 System.out.println(file2);
                                             }
                                         }package com.lc.day17.file1;

                                          import org.junit.Test;

                                          import java.io.File;
                                          import java.io.IOException;
                                          import java.time.LocalDate;
                                          import java.time.format.DateTimeFormatter;
                                          import java.util.Date;

                                          /**
                                           * ClassName: TestFile
                                           * Package: com.lc.day17.file1
                                           * Description:
                                           *
                                           * @Author 爱扣钉-陈晨
                                           * @Create 2023/8/5 9:23
                                           * @Version 1.0
                                           */
                                          public class TestFile {


                                              /*
                                              - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                              - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                              - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                              - `public boolean delete()` ：删除文件或者文件夹
                                                删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                               */
                                              @Test
                                              public void test05() throws IOException {
                                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                  boolean newFile = file1.createNewFile();
                                                  System.out.println(newFile);

                                                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                  boolean mkdir = file2.mkdir();
                                                  System.out.println(mkdir);

                                                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                  //时间转换
                                                  LocalDate date = LocalDate.now();

                                                  DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                  String dateFile = date.format(dateTimeFormatter);

                                                  File file = new File(file3, dateFile);
                                                  System.out.println(file.mkdir());


                                                  //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                  File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                  System.out.println(file4.mkdirs());

                                                  System.out.println(file4.delete());

                                                  file1.delete();
                                              }


                                              /*
                                              - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                              - `public boolean isDirectory()` ：此File表示的是否为目录。
                                              - `public boolean isFile()` ：此File表示的是否为文件。
                                              - public boolean canRead() ：判断是否可读
                                              - public boolean canWrite() ：判断是否可写
                                              - public boolean isHidden() ：判断是否隐藏
                                               */
                                              @Test
                                              public void test04(){
                                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                  boolean exists = file1.exists();
                                                  System.out.println("存在："+exists);

                                                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                  boolean directory = file2.isDirectory();
                                                  System.out.println("文件夹："+directory);
                                                  boolean file = file2.isFile();
                                                  System.out.println("文件"+file);

                                                  boolean b = file2.canRead();
                                                  System.out.println("可读"+b);
                                                  boolean w = file2.canWrite();
                                                  System.out.println("可写"+w);

                                                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                  boolean hidden = file3.isHidden();
                                                  System.out.println("隐藏："+hidden);
                                              }

                                              /*
                                               * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                               * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                               */
                                              @Test
                                              public void test03(){
                                                  //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                  File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                  String[] list = file.list();
                                                  //遍历
                                                  for (String s : list) {
                                                      System.out.println("名称："+s);
                                                  }

                                                  //File数组
                                                  File[] files = file.listFiles();

                                                  for (File file1 : files) {
                                                      System.out.println(file1.getName());
                                                      System.out.println(file1.getAbsoluteFile());
                                                  }


                                              }



                                              /*
                                               * public String getName() ：获取名称
                                               * public String getPath() ：获取路径
                                               * `public String getAbsolutePath()`：获取绝对路径
                                               * public File getAbsoluteFile()：获取绝对路径表示的文件
                                               * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                               * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                               * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                               */
                                              @Test
                                              public void test02(){
                                                  File file = new File("upload\\a.txt");
                                                  System.out.println(file.getName());
                                                  String path = file.getPath();
                                                  System.out.println(path);
                                                  File absoluteFile = file.getAbsoluteFile();
                                                  System.out.println(absoluteFile);

                                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                  File absoluteFile1 = file1.getAbsoluteFile();
                                                  System.out.println(absoluteFile1);
                                                  String path1 = file1.getPath();
                                                  System.out.println(path1);

                                                  //path 使用的是构建路径。
                                                  String parent = file1.getParent();
                                                  System.out.println("parent:"+parent);

                                                  long length = file1.length();
                                                  System.out.println("字节："+length);

                                                  long l = file1.lastModified();
                                                  Date date = new Date(l);
                                                  System.out.println(date);

                                                  //1.8 转换成时间 ？？？

                                              }

                                              /*
                                              * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                              * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                              * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                              关于路径：
                                              * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                              * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                               */
                                              @Test
                                              public void test01(){
                                                  //绝对路径
                                                  File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                  //获取名称
                                                  System.out.println(file.getName());
                                                  //输出
                                                  System.out.println(file);

                                                  //相对路径
                                                  File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                  //获取名称
                                                  System.out.println(file1.getName());
                                                  //输出
                                                  System.out.println(file1);


                                                  //构造  public File(File parent, String child)`
                                                  File upload = new File("upload");
                                                  File file2 = new File(upload, "b.txt");

                                                  //获取名称
                                                  System.out.println(file2.getName());
                                                  //输出
                                                  System.out.println(file2);
                                              }
                                          }package com.lc.day17.file1;

                                           import org.junit.Test;

                                           import java.io.File;
                                           import java.io.IOException;
                                           import java.time.LocalDate;
                                           import java.time.format.DateTimeFormatter;
                                           import java.util.Date;

                                           /**
                                            * ClassName: TestFile
                                            * Package: com.lc.day17.file1
                                            * Description:
                                            *
                                            * @Author 爱扣钉-陈晨
                                            * @Create 2023/8/5 9:23
                                            * @Version 1.0
                                            */
                                           public class TestFile {


                                               /*
                                               - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                               - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                               - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                               - `public boolean delete()` ：删除文件或者文件夹
                                                 删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                */
                                               @Test
                                               public void test05() throws IOException {
                                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                   boolean newFile = file1.createNewFile();
                                                   System.out.println(newFile);

                                                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                   boolean mkdir = file2.mkdir();
                                                   System.out.println(mkdir);

                                                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                   //时间转换
                                                   LocalDate date = LocalDate.now();

                                                   DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                   String dateFile = date.format(dateTimeFormatter);

                                                   File file = new File(file3, dateFile);
                                                   System.out.println(file.mkdir());


                                                   //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                   File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                   System.out.println(file4.mkdirs());

                                                   System.out.println(file4.delete());

                                                   file1.delete();
                                               }


                                               /*
                                               - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                               - `public boolean isDirectory()` ：此File表示的是否为目录。
                                               - `public boolean isFile()` ：此File表示的是否为文件。
                                               - public boolean canRead() ：判断是否可读
                                               - public boolean canWrite() ：判断是否可写
                                               - public boolean isHidden() ：判断是否隐藏
                                                */
                                               @Test
                                               public void test04(){
                                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                   boolean exists = file1.exists();
                                                   System.out.println("存在："+exists);

                                                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                   boolean directory = file2.isDirectory();
                                                   System.out.println("文件夹："+directory);
                                                   boolean file = file2.isFile();
                                                   System.out.println("文件"+file);

                                                   boolean b = file2.canRead();
                                                   System.out.println("可读"+b);
                                                   boolean w = file2.canWrite();
                                                   System.out.println("可写"+w);

                                                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                   boolean hidden = file3.isHidden();
                                                   System.out.println("隐藏："+hidden);
                                               }

                                               /*
                                                * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                */
                                               @Test
                                               public void test03(){
                                                   //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                   File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                   String[] list = file.list();
                                                   //遍历
                                                   for (String s : list) {
                                                       System.out.println("名称："+s);
                                                   }

                                                   //File数组
                                                   File[] files = file.listFiles();

                                                   for (File file1 : files) {
                                                       System.out.println(file1.getName());
                                                       System.out.println(file1.getAbsoluteFile());
                                                   }


                                               }



                                               /*
                                                * public String getName() ：获取名称
                                                * public String getPath() ：获取路径
                                                * `public String getAbsolutePath()`：获取绝对路径
                                                * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                */
                                               @Test
                                               public void test02(){
                                                   File file = new File("upload\\a.txt");
                                                   System.out.println(file.getName());
                                                   String path = file.getPath();
                                                   System.out.println(path);
                                                   File absoluteFile = file.getAbsoluteFile();
                                                   System.out.println(absoluteFile);

                                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                   File absoluteFile1 = file1.getAbsoluteFile();
                                                   System.out.println(absoluteFile1);
                                                   String path1 = file1.getPath();
                                                   System.out.println(path1);

                                                   //path 使用的是构建路径。
                                                   String parent = file1.getParent();
                                                   System.out.println("parent:"+parent);

                                                   long length = file1.length();
                                                   System.out.println("字节："+length);

                                                   long l = file1.lastModified();
                                                   Date date = new Date(l);
                                                   System.out.println(date);

                                                   //1.8 转换成时间 ？？？

                                               }

                                               /*
                                               * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                               * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                               * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                               关于路径：
                                               * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                               * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                 * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                 * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                */
                                               @Test
                                               public void test01(){
                                                   //绝对路径
                                                   File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                   //获取名称
                                                   System.out.println(file.getName());
                                                   //输出
                                                   System.out.println(file);

                                                   //相对路径
                                                   File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                   //获取名称
                                                   System.out.println(file1.getName());
                                                   //输出
                                                   System.out.println(file1);


                                                   //构造  public File(File parent, String child)`
                                                   File upload = new File("upload");
                                                   File file2 = new File(upload, "b.txt");

                                                   //获取名称
                                                   System.out.println(file2.getName());
                                                   //输出
                                                   System.out.println(file2);
                                               }
                                           }package com.lc.day17.file1;

                                            import org.junit.Test;

                                            import java.io.File;
                                            import java.io.IOException;
                                            import java.time.LocalDate;
                                            import java.time.format.DateTimeFormatter;
                                            import java.util.Date;

                                            /**
                                             * ClassName: TestFile
                                             * Package: com.lc.day17.file1
                                             * Description:
                                             *
                                             * @Author 爱扣钉-陈晨
                                             * @Create 2023/8/5 9:23
                                             * @Version 1.0
                                             */
                                            public class TestFile {


                                                /*
                                                - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                - `public boolean delete()` ：删除文件或者文件夹
                                                  删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                 */
                                                @Test
                                                public void test05() throws IOException {
                                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                    boolean newFile = file1.createNewFile();
                                                    System.out.println(newFile);

                                                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                    boolean mkdir = file2.mkdir();
                                                    System.out.println(mkdir);

                                                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                    //时间转换
                                                    LocalDate date = LocalDate.now();

                                                    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                    String dateFile = date.format(dateTimeFormatter);

                                                    File file = new File(file3, dateFile);
                                                    System.out.println(file.mkdir());


                                                    //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                    File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                    System.out.println(file4.mkdirs());

                                                    System.out.println(file4.delete());

                                                    file1.delete();
                                                }


                                                /*
                                                - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                - `public boolean isFile()` ：此File表示的是否为文件。
                                                - public boolean canRead() ：判断是否可读
                                                - public boolean canWrite() ：判断是否可写
                                                - public boolean isHidden() ：判断是否隐藏
                                                 */
                                                @Test
                                                public void test04(){
                                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                    boolean exists = file1.exists();
                                                    System.out.println("存在："+exists);

                                                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                    boolean directory = file2.isDirectory();
                                                    System.out.println("文件夹："+directory);
                                                    boolean file = file2.isFile();
                                                    System.out.println("文件"+file);

                                                    boolean b = file2.canRead();
                                                    System.out.println("可读"+b);
                                                    boolean w = file2.canWrite();
                                                    System.out.println("可写"+w);

                                                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                    boolean hidden = file3.isHidden();
                                                    System.out.println("隐藏："+hidden);
                                                }

                                                /*
                                                 * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                 * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                 */
                                                @Test
                                                public void test03(){
                                                    //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                    File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                    String[] list = file.list();
                                                    //遍历
                                                    for (String s : list) {
                                                        System.out.println("名称："+s);
                                                    }

                                                    //File数组
                                                    File[] files = file.listFiles();

                                                    for (File file1 : files) {
                                                        System.out.println(file1.getName());
                                                        System.out.println(file1.getAbsoluteFile());
                                                    }


                                                }



                                                /*
                                                 * public String getName() ：获取名称
                                                 * public String getPath() ：获取路径
                                                 * `public String getAbsolutePath()`：获取绝对路径
                                                 * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                 * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                 * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                 * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                 */
                                                @Test
                                                public void test02(){
                                                    File file = new File("upload\\a.txt");
                                                    System.out.println(file.getName());
                                                    String path = file.getPath();
                                                    System.out.println(path);
                                                    File absoluteFile = file.getAbsoluteFile();
                                                    System.out.println(absoluteFile);

                                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                    File absoluteFile1 = file1.getAbsoluteFile();
                                                    System.out.println(absoluteFile1);
                                                    String path1 = file1.getPath();
                                                    System.out.println(path1);

                                                    //path 使用的是构建路径。
                                                    String parent = file1.getParent();
                                                    System.out.println("parent:"+parent);

                                                    long length = file1.length();
                                                    System.out.println("字节："+length);

                                                    long l = file1.lastModified();
                                                    Date date = new Date(l);
                                                    System.out.println(date);

                                                    //1.8 转换成时间 ？？？

                                                }

                                                /*
                                                * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                关于路径：
                                                * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                  * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                  * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                 */
                                                @Test
                                                public void test01(){
                                                    //绝对路径
                                                    File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                    //获取名称
                                                    System.out.println(file.getName());
                                                    //输出
                                                    System.out.println(file);

                                                    //相对路径
                                                    File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                    //获取名称
                                                    System.out.println(file1.getName());
                                                    //输出
                                                    System.out.println(file1);


                                                    //构造  public File(File parent, String child)`
                                                    File upload = new File("upload");
                                                    File file2 = new File(upload, "b.txt");

                                                    //获取名称
                                                    System.out.println(file2.getName());
                                                    //输出
                                                    System.out.println(file2);
                                                }
                                            }package com.lc.day17.file1;

                                             import org.junit.Test;

                                             import java.io.File;
                                             import java.io.IOException;
                                             import java.time.LocalDate;
                                             import java.time.format.DateTimeFormatter;
                                             import java.util.Date;

                                             /**
                                              * ClassName: TestFile
                                              * Package: com.lc.day17.file1
                                              * Description:
                                              *
                                              * @Author 爱扣钉-陈晨
                                              * @Create 2023/8/5 9:23
                                              * @Version 1.0
                                              */
                                             public class TestFile {


                                                 /*
                                                 - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                 - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                 - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                 - `public boolean delete()` ：删除文件或者文件夹
                                                   删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                  */
                                                 @Test
                                                 public void test05() throws IOException {
                                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                     boolean newFile = file1.createNewFile();
                                                     System.out.println(newFile);

                                                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                     boolean mkdir = file2.mkdir();
                                                     System.out.println(mkdir);

                                                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                     //时间转换
                                                     LocalDate date = LocalDate.now();

                                                     DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                     String dateFile = date.format(dateTimeFormatter);

                                                     File file = new File(file3, dateFile);
                                                     System.out.println(file.mkdir());


                                                     //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                     File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                     System.out.println(file4.mkdirs());

                                                     System.out.println(file4.delete());

                                                     file1.delete();
                                                 }


                                                 /*
                                                 - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                 - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                 - `public boolean isFile()` ：此File表示的是否为文件。
                                                 - public boolean canRead() ：判断是否可读
                                                 - public boolean canWrite() ：判断是否可写
                                                 - public boolean isHidden() ：判断是否隐藏
                                                  */
                                                 @Test
                                                 public void test04(){
                                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                     boolean exists = file1.exists();
                                                     System.out.println("存在："+exists);

                                                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                     boolean directory = file2.isDirectory();
                                                     System.out.println("文件夹："+directory);
                                                     boolean file = file2.isFile();
                                                     System.out.println("文件"+file);

                                                     boolean b = file2.canRead();
                                                     System.out.println("可读"+b);
                                                     boolean w = file2.canWrite();
                                                     System.out.println("可写"+w);

                                                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                     boolean hidden = file3.isHidden();
                                                     System.out.println("隐藏："+hidden);
                                                 }

                                                 /*
                                                  * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                  * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                  */
                                                 @Test
                                                 public void test03(){
                                                     //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                     File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                     String[] list = file.list();
                                                     //遍历
                                                     for (String s : list) {
                                                         System.out.println("名称："+s);
                                                     }

                                                     //File数组
                                                     File[] files = file.listFiles();

                                                     for (File file1 : files) {
                                                         System.out.println(file1.getName());
                                                         System.out.println(file1.getAbsoluteFile());
                                                     }


                                                 }



                                                 /*
                                                  * public String getName() ：获取名称
                                                  * public String getPath() ：获取路径
                                                  * `public String getAbsolutePath()`：获取绝对路径
                                                  * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                  * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                  * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                  * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                  */
                                                 @Test
                                                 public void test02(){
                                                     File file = new File("upload\\a.txt");
                                                     System.out.println(file.getName());
                                                     String path = file.getPath();
                                                     System.out.println(path);
                                                     File absoluteFile = file.getAbsoluteFile();
                                                     System.out.println(absoluteFile);

                                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                     File absoluteFile1 = file1.getAbsoluteFile();
                                                     System.out.println(absoluteFile1);
                                                     String path1 = file1.getPath();
                                                     System.out.println(path1);

                                                     //path 使用的是构建路径。
                                                     String parent = file1.getParent();
                                                     System.out.println("parent:"+parent);

                                                     long length = file1.length();
                                                     System.out.println("字节："+length);

                                                     long l = file1.lastModified();
                                                     Date date = new Date(l);
                                                     System.out.println(date);

                                                     //1.8 转换成时间 ？？？

                                                 }

                                                 /*
                                                 * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                 * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                 * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                 关于路径：
                                                 * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                 * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                   * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                   * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                  */
                                                 @Test
                                                 public void test01(){
                                                     //绝对路径
                                                     File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                     //获取名称
                                                     System.out.println(file.getName());
                                                     //输出
                                                     System.out.println(file);

                                                     //相对路径
                                                     File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                     //获取名称
                                                     System.out.println(file1.getName());
                                                     //输出
                                                     System.out.println(file1);


                                                     //构造  public File(File parent, String child)`
                                                     File upload = new File("upload");
                                                     File file2 = new File(upload, "b.txt");

                                                     //获取名称
                                                     System.out.println(file2.getName());
                                                     //输出
                                                     System.out.println(file2);
                                                 }
                                             }package com.lc.day17.file1;

                                              import org.junit.Test;

                                              import java.io.File;
                                              import java.io.IOException;
                                              import java.time.LocalDate;
                                              import java.time.format.DateTimeFormatter;
                                              import java.util.Date;

                                              /**
                                               * ClassName: TestFile
                                               * Package: com.lc.day17.file1
                                               * Description:
                                               *
                                               * @Author 爱扣钉-陈晨
                                               * @Create 2023/8/5 9:23
                                               * @Version 1.0
                                               */
                                              public class TestFile {


                                                  /*
                                                  - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                  - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                  - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                  - `public boolean delete()` ：删除文件或者文件夹
                                                    删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                   */
                                                  @Test
                                                  public void test05() throws IOException {
                                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                      boolean newFile = file1.createNewFile();
                                                      System.out.println(newFile);

                                                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                      boolean mkdir = file2.mkdir();
                                                      System.out.println(mkdir);

                                                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                      //时间转换
                                                      LocalDate date = LocalDate.now();

                                                      DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                      String dateFile = date.format(dateTimeFormatter);

                                                      File file = new File(file3, dateFile);
                                                      System.out.println(file.mkdir());


                                                      //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                      File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                      System.out.println(file4.mkdirs());

                                                      System.out.println(file4.delete());

                                                      file1.delete();
                                                  }


                                                  /*
                                                  - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                  - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                  - `public boolean isFile()` ：此File表示的是否为文件。
                                                  - public boolean canRead() ：判断是否可读
                                                  - public boolean canWrite() ：判断是否可写
                                                  - public boolean isHidden() ：判断是否隐藏
                                                   */
                                                  @Test
                                                  public void test04(){
                                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                      boolean exists = file1.exists();
                                                      System.out.println("存在："+exists);

                                                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                      boolean directory = file2.isDirectory();
                                                      System.out.println("文件夹："+directory);
                                                      boolean file = file2.isFile();
                                                      System.out.println("文件"+file);

                                                      boolean b = file2.canRead();
                                                      System.out.println("可读"+b);
                                                      boolean w = file2.canWrite();
                                                      System.out.println("可写"+w);

                                                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                      boolean hidden = file3.isHidden();
                                                      System.out.println("隐藏："+hidden);
                                                  }

                                                  /*
                                                   * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                   * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                   */
                                                  @Test
                                                  public void test03(){
                                                      //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                      File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                      String[] list = file.list();
                                                      //遍历
                                                      for (String s : list) {
                                                          System.out.println("名称："+s);
                                                      }

                                                      //File数组
                                                      File[] files = file.listFiles();

                                                      for (File file1 : files) {
                                                          System.out.println(file1.getName());
                                                          System.out.println(file1.getAbsoluteFile());
                                                      }


                                                  }



                                                  /*
                                                   * public String getName() ：获取名称
                                                   * public String getPath() ：获取路径
                                                   * `public String getAbsolutePath()`：获取绝对路径
                                                   * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                   * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                   * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                   * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                   */
                                                  @Test
                                                  public void test02(){
                                                      File file = new File("upload\\a.txt");
                                                      System.out.println(file.getName());
                                                      String path = file.getPath();
                                                      System.out.println(path);
                                                      File absoluteFile = file.getAbsoluteFile();
                                                      System.out.println(absoluteFile);

                                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                      File absoluteFile1 = file1.getAbsoluteFile();
                                                      System.out.println(absoluteFile1);
                                                      String path1 = file1.getPath();
                                                      System.out.println(path1);

                                                      //path 使用的是构建路径。
                                                      String parent = file1.getParent();
                                                      System.out.println("parent:"+parent);

                                                      long length = file1.length();
                                                      System.out.println("字节："+length);

                                                      long l = file1.lastModified();
                                                      Date date = new Date(l);
                                                      System.out.println(date);

                                                      //1.8 转换成时间 ？？？

                                                  }

                                                  /*
                                                  * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                  * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                  * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                  关于路径：
                                                  * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                  * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                    * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                    * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                   */
                                                  @Test
                                                  public void test01(){
                                                      //绝对路径
                                                      File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                      //获取名称
                                                      System.out.println(file.getName());
                                                      //输出
                                                      System.out.println(file);

                                                      //相对路径
                                                      File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                      //获取名称
                                                      System.out.println(file1.getName());
                                                      //输出
                                                      System.out.println(file1);


                                                      //构造  public File(File parent, String child)`
                                                      File upload = new File("upload");
                                                      File file2 = new File(upload, "b.txt");

                                                      //获取名称
                                                      System.out.println(file2.getName());
                                                      //输出
                                                      System.out.println(file2);
                                                  }
                                              }package com.lc.day17.file1;

                                               import org.junit.Test;

                                               import java.io.File;
                                               import java.io.IOException;
                                               import java.time.LocalDate;
                                               import java.time.format.DateTimeFormatter;
                                               import java.util.Date;

                                               /**
                                                * ClassName: TestFile
                                                * Package: com.lc.day17.file1
                                                * Description:
                                                *
                                                * @Author 爱扣钉-陈晨
                                                * @Create 2023/8/5 9:23
                                                * @Version 1.0
                                                */
                                               public class TestFile {


                                                   /*
                                                   - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                   - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                   - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                   - `public boolean delete()` ：删除文件或者文件夹
                                                     删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                    */
                                                   @Test
                                                   public void test05() throws IOException {
                                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                       boolean newFile = file1.createNewFile();
                                                       System.out.println(newFile);

                                                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                       boolean mkdir = file2.mkdir();
                                                       System.out.println(mkdir);

                                                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                       //时间转换
                                                       LocalDate date = LocalDate.now();

                                                       DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                       String dateFile = date.format(dateTimeFormatter);

                                                       File file = new File(file3, dateFile);
                                                       System.out.println(file.mkdir());


                                                       //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                       File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                       System.out.println(file4.mkdirs());

                                                       System.out.println(file4.delete());

                                                       file1.delete();
                                                   }


                                                   /*
                                                   - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                   - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                   - `public boolean isFile()` ：此File表示的是否为文件。
                                                   - public boolean canRead() ：判断是否可读
                                                   - public boolean canWrite() ：判断是否可写
                                                   - public boolean isHidden() ：判断是否隐藏
                                                    */
                                                   @Test
                                                   public void test04(){
                                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                       boolean exists = file1.exists();
                                                       System.out.println("存在："+exists);

                                                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                       boolean directory = file2.isDirectory();
                                                       System.out.println("文件夹："+directory);
                                                       boolean file = file2.isFile();
                                                       System.out.println("文件"+file);

                                                       boolean b = file2.canRead();
                                                       System.out.println("可读"+b);
                                                       boolean w = file2.canWrite();
                                                       System.out.println("可写"+w);

                                                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                       boolean hidden = file3.isHidden();
                                                       System.out.println("隐藏："+hidden);
                                                   }

                                                   /*
                                                    * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                    * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                    */
                                                   @Test
                                                   public void test03(){
                                                       //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                       File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                       String[] list = file.list();
                                                       //遍历
                                                       for (String s : list) {
                                                           System.out.println("名称："+s);
                                                       }

                                                       //File数组
                                                       File[] files = file.listFiles();

                                                       for (File file1 : files) {
                                                           System.out.println(file1.getName());
                                                           System.out.println(file1.getAbsoluteFile());
                                                       }


                                                   }



                                                   /*
                                                    * public String getName() ：获取名称
                                                    * public String getPath() ：获取路径
                                                    * `public String getAbsolutePath()`：获取绝对路径
                                                    * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                    * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                    * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                    * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                    */
                                                   @Test
                                                   public void test02(){
                                                       File file = new File("upload\\a.txt");
                                                       System.out.println(file.getName());
                                                       String path = file.getPath();
                                                       System.out.println(path);
                                                       File absoluteFile = file.getAbsoluteFile();
                                                       System.out.println(absoluteFile);

                                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                       File absoluteFile1 = file1.getAbsoluteFile();
                                                       System.out.println(absoluteFile1);
                                                       String path1 = file1.getPath();
                                                       System.out.println(path1);

                                                       //path 使用的是构建路径。
                                                       String parent = file1.getParent();
                                                       System.out.println("parent:"+parent);

                                                       long length = file1.length();
                                                       System.out.println("字节："+length);

                                                       long l = file1.lastModified();
                                                       Date date = new Date(l);
                                                       System.out.println(date);

                                                       //1.8 转换成时间 ？？？

                                                   }

                                                   /*
                                                   * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                   * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                   * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                   关于路径：
                                                   * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                   * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                     * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                     * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                    */
                                                   @Test
                                                   public void test01(){
                                                       //绝对路径
                                                       File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                       //获取名称
                                                       System.out.println(file.getName());
                                                       //输出
                                                       System.out.println(file);

                                                       //相对路径
                                                       File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                       //获取名称
                                                       System.out.println(file1.getName());
                                                       //输出
                                                       System.out.println(file1);


                                                       //构造  public File(File parent, String child)`
                                                       File upload = new File("upload");
                                                       File file2 = new File(upload, "b.txt");

                                                       //获取名称
                                                       System.out.println(file2.getName());
                                                       //输出
                                                       System.out.println(file2);
                                                   }
                                               }package com.lc.day17.file1;

                                                import org.junit.Test;

                                                import java.io.File;
                                                import java.io.IOException;
                                                import java.time.LocalDate;
                                                import java.time.format.DateTimeFormatter;
                                                import java.util.Date;

                                                /**
                                                 * ClassName: TestFile
                                                 * Package: com.lc.day17.file1
                                                 * Description:
                                                 *
                                                 * @Author 爱扣钉-陈晨
                                                 * @Create 2023/8/5 9:23
                                                 * @Version 1.0
                                                 */
                                                public class TestFile {


                                                    /*
                                                    - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                    - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                    - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                    - `public boolean delete()` ：删除文件或者文件夹
                                                      删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                     */
                                                    @Test
                                                    public void test05() throws IOException {
                                                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                        boolean newFile = file1.createNewFile();
                                                        System.out.println(newFile);

                                                        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                        boolean mkdir = file2.mkdir();
                                                        System.out.println(mkdir);

                                                        File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                        //时间转换
                                                        LocalDate date = LocalDate.now();

                                                        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                        String dateFile = date.format(dateTimeFormatter);

                                                        File file = new File(file3, dateFile);
                                                        System.out.println(file.mkdir());


                                                        //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                        File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                        System.out.println(file4.mkdirs());

                                                        System.out.println(file4.delete());

                                                        file1.delete();
                                                    }


                                                    /*
                                                    - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                    - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                    - `public boolean isFile()` ：此File表示的是否为文件。
                                                    - public boolean canRead() ：判断是否可读
                                                    - public boolean canWrite() ：判断是否可写
                                                    - public boolean isHidden() ：判断是否隐藏
                                                     */
                                                    @Test
                                                    public void test04(){
                                                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                        boolean exists = file1.exists();
                                                        System.out.println("存在："+exists);

                                                        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                        boolean directory = file2.isDirectory();
                                                        System.out.println("文件夹："+directory);
                                                        boolean file = file2.isFile();
                                                        System.out.println("文件"+file);

                                                        boolean b = file2.canRead();
                                                        System.out.println("可读"+b);
                                                        boolean w = file2.canWrite();
                                                        System.out.println("可写"+w);

                                                        File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                        boolean hidden = file3.isHidden();
                                                        System.out.println("隐藏："+hidden);
                                                    }

                                                    /*
                                                     * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                     * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                     */
                                                    @Test
                                                    public void test03(){
                                                        //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                        File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                        String[] list = file.list();
                                                        //遍历
                                                        for (String s : list) {
                                                            System.out.println("名称："+s);
                                                        }

                                                        //File数组
                                                        File[] files = file.listFiles();

                                                        for (File file1 : files) {
                                                            System.out.println(file1.getName());
                                                            System.out.println(file1.getAbsoluteFile());
                                                        }


                                                    }



                                                    /*
                                                     * public String getName() ：获取名称
                                                     * public String getPath() ：获取路径
                                                     * `public String getAbsolutePath()`：获取绝对路径
                                                     * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                     * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                     * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                     * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                     */
                                                    @Test
                                                    public void test02(){
                                                        File file = new File("upload\\a.txt");
                                                        System.out.println(file.getName());
                                                        String path = file.getPath();
                                                        System.out.println(path);
                                                        File absoluteFile = file.getAbsoluteFile();
                                                        System.out.println(absoluteFile);

                                                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                        File absoluteFile1 = file1.getAbsoluteFile();
                                                        System.out.println(absoluteFile1);
                                                        String path1 = file1.getPath();
                                                        System.out.println(path1);

                                                        //path 使用的是构建路径。
                                                        String parent = file1.getParent();
                                                        System.out.println("parent:"+parent);

                                                        long length = file1.length();
                                                        System.out.println("字节："+length);

                                                        long l = file1.lastModified();
                                                        Date date = new Date(l);
                                                        System.out.println(date);

                                                        //1.8 转换成时间 ？？？

                                                    }

                                                    /*
                                                    * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                    * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                    * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                    关于路径：
                                                    * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                    * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                      * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                      * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                     */
                                                    @Test
                                                    public void test01(){
                                                        //绝对路径
                                                        File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                        //获取名称
                                                        System.out.println(file.getName());
                                                        //输出
                                                        System.out.println(file);

                                                        //相对路径
                                                        File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                        //获取名称
                                                        System.out.println(file1.getName());
                                                        //输出
                                                        System.out.println(file1);


                                                        //构造  public File(File parent, String child)`
                                                        File upload = new File("upload");
                                                        File file2 = new File(upload, "b.txt");

                                                        //获取名称
                                                        System.out.println(file2.getName());
                                                        //输出
                                                        System.out.println(file2);
                                                    }
                                                }package com.lc.day17.file1;

                                                 import org.junit.Test;

                                                 import java.io.File;
                                                 import java.io.IOException;
                                                 import java.time.LocalDate;
                                                 import java.time.format.DateTimeFormatter;
                                                 import java.util.Date;

                                                 /**
                                                  * ClassName: TestFile
                                                  * Package: com.lc.day17.file1
                                                  * Description:
                                                  *
                                                  * @Author 爱扣钉-陈晨
                                                  * @Create 2023/8/5 9:23
                                                  * @Version 1.0
                                                  */
                                                 public class TestFile {


                                                     /*
                                                     - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                     - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                     - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                     - `public boolean delete()` ：删除文件或者文件夹
                                                       删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                      */
                                                     @Test
                                                     public void test05() throws IOException {
                                                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                         boolean newFile = file1.createNewFile();
                                                         System.out.println(newFile);

                                                         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                         boolean mkdir = file2.mkdir();
                                                         System.out.println(mkdir);

                                                         File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                         //时间转换
                                                         LocalDate date = LocalDate.now();

                                                         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                         String dateFile = date.format(dateTimeFormatter);

                                                         File file = new File(file3, dateFile);
                                                         System.out.println(file.mkdir());


                                                         //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                         File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                         System.out.println(file4.mkdirs());

                                                         System.out.println(file4.delete());

                                                         file1.delete();
                                                     }


                                                     /*
                                                     - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                     - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                     - `public boolean isFile()` ：此File表示的是否为文件。
                                                     - public boolean canRead() ：判断是否可读
                                                     - public boolean canWrite() ：判断是否可写
                                                     - public boolean isHidden() ：判断是否隐藏
                                                      */
                                                     @Test
                                                     public void test04(){
                                                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                         boolean exists = file1.exists();
                                                         System.out.println("存在："+exists);

                                                         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                         boolean directory = file2.isDirectory();
                                                         System.out.println("文件夹："+directory);
                                                         boolean file = file2.isFile();
                                                         System.out.println("文件"+file);

                                                         boolean b = file2.canRead();
                                                         System.out.println("可读"+b);
                                                         boolean w = file2.canWrite();
                                                         System.out.println("可写"+w);

                                                         File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                         boolean hidden = file3.isHidden();
                                                         System.out.println("隐藏："+hidden);
                                                     }

                                                     /*
                                                      * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                      * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                      */
                                                     @Test
                                                     public void test03(){
                                                         //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                         File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                         String[] list = file.list();
                                                         //遍历
                                                         for (String s : list) {
                                                             System.out.println("名称："+s);
                                                         }

                                                         //File数组
                                                         File[] files = file.listFiles();

                                                         for (File file1 : files) {
                                                             System.out.println(file1.getName());
                                                             System.out.println(file1.getAbsoluteFile());
                                                         }


                                                     }



                                                     /*
                                                      * public String getName() ：获取名称
                                                      * public String getPath() ：获取路径
                                                      * `public String getAbsolutePath()`：获取绝对路径
                                                      * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                      * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                      * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                      * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                      */
                                                     @Test
                                                     public void test02(){
                                                         File file = new File("upload\\a.txt");
                                                         System.out.println(file.getName());
                                                         String path = file.getPath();
                                                         System.out.println(path);
                                                         File absoluteFile = file.getAbsoluteFile();
                                                         System.out.println(absoluteFile);

                                                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                         File absoluteFile1 = file1.getAbsoluteFile();
                                                         System.out.println(absoluteFile1);
                                                         String path1 = file1.getPath();
                                                         System.out.println(path1);

                                                         //path 使用的是构建路径。
                                                         String parent = file1.getParent();
                                                         System.out.println("parent:"+parent);

                                                         long length = file1.length();
                                                         System.out.println("字节："+length);

                                                         long l = file1.lastModified();
                                                         Date date = new Date(l);
                                                         System.out.println(date);

                                                         //1.8 转换成时间 ？？？

                                                     }

                                                     /*
                                                     * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                     * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                     * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                     关于路径：
                                                     * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                     * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                       * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                       * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                      */
                                                     @Test
                                                     public void test01(){
                                                         //绝对路径
                                                         File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                         //获取名称
                                                         System.out.println(file.getName());
                                                         //输出
                                                         System.out.println(file);

                                                         //相对路径
                                                         File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                         //获取名称
                                                         System.out.println(file1.getName());
                                                         //输出
                                                         System.out.println(file1);


                                                         //构造  public File(File parent, String child)`
                                                         File upload = new File("upload");
                                                         File file2 = new File(upload, "b.txt");

                                                         //获取名称
                                                         System.out.println(file2.getName());
                                                         //输出
                                                         System.out.println(file2);
                                                     }
                                                 }package com.lc.day17.file1;

                                                  import org.junit.Test;

                                                  import java.io.File;
                                                  import java.io.IOException;
                                                  import java.time.LocalDate;
                                                  import java.time.format.DateTimeFormatter;
                                                  import java.util.Date;

                                                  /**
                                                   * ClassName: TestFile
                                                   * Package: com.lc.day17.file1
                                                   * Description:
                                                   *
                                                   * @Author 爱扣钉-陈晨
                                                   * @Create 2023/8/5 9:23
                                                   * @Version 1.0
                                                   */
                                                  public class TestFile {


                                                      /*
                                                      - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                      - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                      - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                      - `public boolean delete()` ：删除文件或者文件夹
                                                        删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                       */
                                                      @Test
                                                      public void test05() throws IOException {
                                                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                          boolean newFile = file1.createNewFile();
                                                          System.out.println(newFile);

                                                          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                          boolean mkdir = file2.mkdir();
                                                          System.out.println(mkdir);

                                                          File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                          //时间转换
                                                          LocalDate date = LocalDate.now();

                                                          DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                          String dateFile = date.format(dateTimeFormatter);

                                                          File file = new File(file3, dateFile);
                                                          System.out.println(file.mkdir());


                                                          //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                          File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                          System.out.println(file4.mkdirs());

                                                          System.out.println(file4.delete());

                                                          file1.delete();
                                                      }


                                                      /*
                                                      - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                      - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                      - `public boolean isFile()` ：此File表示的是否为文件。
                                                      - public boolean canRead() ：判断是否可读
                                                      - public boolean canWrite() ：判断是否可写
                                                      - public boolean isHidden() ：判断是否隐藏
                                                       */
                                                      @Test
                                                      public void test04(){
                                                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                          boolean exists = file1.exists();
                                                          System.out.println("存在："+exists);

                                                          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                          boolean directory = file2.isDirectory();
                                                          System.out.println("文件夹："+directory);
                                                          boolean file = file2.isFile();
                                                          System.out.println("文件"+file);

                                                          boolean b = file2.canRead();
                                                          System.out.println("可读"+b);
                                                          boolean w = file2.canWrite();
                                                          System.out.println("可写"+w);

                                                          File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                          boolean hidden = file3.isHidden();
                                                          System.out.println("隐藏："+hidden);
                                                      }

                                                      /*
                                                       * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                       * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                       */
                                                      @Test
                                                      public void test03(){
                                                          //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                          File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                          String[] list = file.list();
                                                          //遍历
                                                          for (String s : list) {
                                                              System.out.println("名称："+s);
                                                          }

                                                          //File数组
                                                          File[] files = file.listFiles();

                                                          for (File file1 : files) {
                                                              System.out.println(file1.getName());
                                                              System.out.println(file1.getAbsoluteFile());
                                                          }


                                                      }



                                                      /*
                                                       * public String getName() ：获取名称
                                                       * public String getPath() ：获取路径
                                                       * `public String getAbsolutePath()`：获取绝对路径
                                                       * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                       * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                       * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                       * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                       */
                                                      @Test
                                                      public void test02(){
                                                          File file = new File("upload\\a.txt");
                                                          System.out.println(file.getName());
                                                          String path = file.getPath();
                                                          System.out.println(path);
                                                          File absoluteFile = file.getAbsoluteFile();
                                                          System.out.println(absoluteFile);

                                                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                          File absoluteFile1 = file1.getAbsoluteFile();
                                                          System.out.println(absoluteFile1);
                                                          String path1 = file1.getPath();
                                                          System.out.println(path1);

                                                          //path 使用的是构建路径。
                                                          String parent = file1.getParent();
                                                          System.out.println("parent:"+parent);

                                                          long length = file1.length();
                                                          System.out.println("字节："+length);

                                                          long l = file1.lastModified();
                                                          Date date = new Date(l);
                                                          System.out.println(date);

                                                          //1.8 转换成时间 ？？？

                                                      }

                                                      /*
                                                      * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                      * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                      * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                      关于路径：
                                                      * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                      * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                        * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                        * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                       */
                                                      @Test
                                                      public void test01(){
                                                          //绝对路径
                                                          File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                          //获取名称
                                                          System.out.println(file.getName());
                                                          //输出
                                                          System.out.println(file);

                                                          //相对路径
                                                          File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                          //获取名称
                                                          System.out.println(file1.getName());
                                                          //输出
                                                          System.out.println(file1);


                                                          //构造  public File(File parent, String child)`
                                                          File upload = new File("upload");
                                                          File file2 = new File(upload, "b.txt");

                                                          //获取名称
                                                          System.out.println(file2.getName());
                                                          //输出
                                                          System.out.println(file2);
                                                      }
                                                  }package com.lc.day17.file1;

                                                   import org.junit.Test;

                                                   import java.io.File;
                                                   import java.io.IOException;
                                                   import java.time.LocalDate;
                                                   import java.time.format.DateTimeFormatter;
                                                   import java.util.Date;

                                                   /**
                                                    * ClassName: TestFile
                                                    * Package: com.lc.day17.file1
                                                    * Description:
                                                    *
                                                    * @Author 爱扣钉-陈晨
                                                    * @Create 2023/8/5 9:23
                                                    * @Version 1.0
                                                    */
                                                   public class TestFile {


                                                       /*
                                                       - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                       - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                       - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                       - `public boolean delete()` ：删除文件或者文件夹
                                                         删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                        */
                                                       @Test
                                                       public void test05() throws IOException {
                                                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                           boolean newFile = file1.createNewFile();
                                                           System.out.println(newFile);

                                                           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                           boolean mkdir = file2.mkdir();
                                                           System.out.println(mkdir);

                                                           File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                           //时间转换
                                                           LocalDate date = LocalDate.now();

                                                           DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                           String dateFile = date.format(dateTimeFormatter);

                                                           File file = new File(file3, dateFile);
                                                           System.out.println(file.mkdir());


                                                           //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                           File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                           System.out.println(file4.mkdirs());

                                                           System.out.println(file4.delete());

                                                           file1.delete();
                                                       }


                                                       /*
                                                       - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                       - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                       - `public boolean isFile()` ：此File表示的是否为文件。
                                                       - public boolean canRead() ：判断是否可读
                                                       - public boolean canWrite() ：判断是否可写
                                                       - public boolean isHidden() ：判断是否隐藏
                                                        */
                                                       @Test
                                                       public void test04(){
                                                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                           boolean exists = file1.exists();
                                                           System.out.println("存在："+exists);

                                                           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                           boolean directory = file2.isDirectory();
                                                           System.out.println("文件夹："+directory);
                                                           boolean file = file2.isFile();
                                                           System.out.println("文件"+file);

                                                           boolean b = file2.canRead();
                                                           System.out.println("可读"+b);
                                                           boolean w = file2.canWrite();
                                                           System.out.println("可写"+w);

                                                           File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                           boolean hidden = file3.isHidden();
                                                           System.out.println("隐藏："+hidden);
                                                       }

                                                       /*
                                                        * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                        * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                        */
                                                       @Test
                                                       public void test03(){
                                                           //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                           File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                           String[] list = file.list();
                                                           //遍历
                                                           for (String s : list) {
                                                               System.out.println("名称："+s);
                                                           }

                                                           //File数组
                                                           File[] files = file.listFiles();

                                                           for (File file1 : files) {
                                                               System.out.println(file1.getName());
                                                               System.out.println(file1.getAbsoluteFile());
                                                           }


                                                       }



                                                       /*
                                                        * public String getName() ：获取名称
                                                        * public String getPath() ：获取路径
                                                        * `public String getAbsolutePath()`：获取绝对路径
                                                        * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                        * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                        * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                        * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                        */
                                                       @Test
                                                       public void test02(){
                                                           File file = new File("upload\\a.txt");
                                                           System.out.println(file.getName());
                                                           String path = file.getPath();
                                                           System.out.println(path);
                                                           File absoluteFile = file.getAbsoluteFile();
                                                           System.out.println(absoluteFile);

                                                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                           File absoluteFile1 = file1.getAbsoluteFile();
                                                           System.out.println(absoluteFile1);
                                                           String path1 = file1.getPath();
                                                           System.out.println(path1);

                                                           //path 使用的是构建路径。
                                                           String parent = file1.getParent();
                                                           System.out.println("parent:"+parent);

                                                           long length = file1.length();
                                                           System.out.println("字节："+length);

                                                           long l = file1.lastModified();
                                                           Date date = new Date(l);
                                                           System.out.println(date);

                                                           //1.8 转换成时间 ？？？

                                                       }

                                                       /*
                                                       * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                       * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                       * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                       关于路径：
                                                       * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                       * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                         * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                         * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                        */
                                                       @Test
                                                       public void test01(){
                                                           //绝对路径
                                                           File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                           //获取名称
                                                           System.out.println(file.getName());
                                                           //输出
                                                           System.out.println(file);

                                                           //相对路径
                                                           File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                           //获取名称
                                                           System.out.println(file1.getName());
                                                           //输出
                                                           System.out.println(file1);


                                                           //构造  public File(File parent, String child)`
                                                           File upload = new File("upload");
                                                           File file2 = new File(upload, "b.txt");

                                                           //获取名称
                                                           System.out.println(file2.getName());
                                                           //输出
                                                           System.out.println(file2);
                                                       }
                                                   }package com.lc.day17.file1;

                                                    import org.junit.Test;

                                                    import java.io.File;
                                                    import java.io.IOException;
                                                    import java.time.LocalDate;
                                                    import java.time.format.DateTimeFormatter;
                                                    import java.util.Date;

                                                    /**
                                                     * ClassName: TestFile
                                                     * Package: com.lc.day17.file1
                                                     * Description:
                                                     *
                                                     * @Author 爱扣钉-陈晨
                                                     * @Create 2023/8/5 9:23
                                                     * @Version 1.0
                                                     */
                                                    public class TestFile {


                                                        /*
                                                        - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                        - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                        - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                        - `public boolean delete()` ：删除文件或者文件夹
                                                          删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                         */
                                                        @Test
                                                        public void test05() throws IOException {
                                                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                            boolean newFile = file1.createNewFile();
                                                            System.out.println(newFile);

                                                            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                            boolean mkdir = file2.mkdir();
                                                            System.out.println(mkdir);

                                                            File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                            //时间转换
                                                            LocalDate date = LocalDate.now();

                                                            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                            String dateFile = date.format(dateTimeFormatter);

                                                            File file = new File(file3, dateFile);
                                                            System.out.println(file.mkdir());


                                                            //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                            File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                            System.out.println(file4.mkdirs());

                                                            System.out.println(file4.delete());

                                                            file1.delete();
                                                        }


                                                        /*
                                                        - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                        - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                        - `public boolean isFile()` ：此File表示的是否为文件。
                                                        - public boolean canRead() ：判断是否可读
                                                        - public boolean canWrite() ：判断是否可写
                                                        - public boolean isHidden() ：判断是否隐藏
                                                         */
                                                        @Test
                                                        public void test04(){
                                                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                            boolean exists = file1.exists();
                                                            System.out.println("存在："+exists);

                                                            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                            boolean directory = file2.isDirectory();
                                                            System.out.println("文件夹："+directory);
                                                            boolean file = file2.isFile();
                                                            System.out.println("文件"+file);

                                                            boolean b = file2.canRead();
                                                            System.out.println("可读"+b);
                                                            boolean w = file2.canWrite();
                                                            System.out.println("可写"+w);

                                                            File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                            boolean hidden = file3.isHidden();
                                                            System.out.println("隐藏："+hidden);
                                                        }

                                                        /*
                                                         * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                         * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                         */
                                                        @Test
                                                        public void test03(){
                                                            //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                            File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                            String[] list = file.list();
                                                            //遍历
                                                            for (String s : list) {
                                                                System.out.println("名称："+s);
                                                            }

                                                            //File数组
                                                            File[] files = file.listFiles();

                                                            for (File file1 : files) {
                                                                System.out.println(file1.getName());
                                                                System.out.println(file1.getAbsoluteFile());
                                                            }


                                                        }



                                                        /*
                                                         * public String getName() ：获取名称
                                                         * public String getPath() ：获取路径
                                                         * `public String getAbsolutePath()`：获取绝对路径
                                                         * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                         * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                         * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                         * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                         */
                                                        @Test
                                                        public void test02(){
                                                            File file = new File("upload\\a.txt");
                                                            System.out.println(file.getName());
                                                            String path = file.getPath();
                                                            System.out.println(path);
                                                            File absoluteFile = file.getAbsoluteFile();
                                                            System.out.println(absoluteFile);

                                                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                            File absoluteFile1 = file1.getAbsoluteFile();
                                                            System.out.println(absoluteFile1);
                                                            String path1 = file1.getPath();
                                                            System.out.println(path1);

                                                            //path 使用的是构建路径。
                                                            String parent = file1.getParent();
                                                            System.out.println("parent:"+parent);

                                                            long length = file1.length();
                                                            System.out.println("字节："+length);

                                                            long l = file1.lastModified();
                                                            Date date = new Date(l);
                                                            System.out.println(date);

                                                            //1.8 转换成时间 ？？？

                                                        }

                                                        /*
                                                        * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                        * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                        * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                        关于路径：
                                                        * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                        * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                          * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                          * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                         */
                                                        @Test
                                                        public void test01(){
                                                            //绝对路径
                                                            File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                            //获取名称
                                                            System.out.println(file.getName());
                                                            //输出
                                                            System.out.println(file);

                                                            //相对路径
                                                            File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                            //获取名称
                                                            System.out.println(file1.getName());
                                                            //输出
                                                            System.out.println(file1);


                                                            //构造  public File(File parent, String child)`
                                                            File upload = new File("upload");
                                                            File file2 = new File(upload, "b.txt");

                                                            //获取名称
                                                            System.out.println(file2.getName());
                                                            //输出
                                                            System.out.println(file2);
                                                        }
                                                    }package com.lc.day17.file1;

                                                     import org.junit.Test;

                                                     import java.io.File;
                                                     import java.io.IOException;
                                                     import java.time.LocalDate;
                                                     import java.time.format.DateTimeFormatter;
                                                     import java.util.Date;

                                                     /**
                                                      * ClassName: TestFile
                                                      * Package: com.lc.day17.file1
                                                      * Description:
                                                      *
                                                      * @Author 爱扣钉-陈晨
                                                      * @Create 2023/8/5 9:23
                                                      * @Version 1.0
                                                      */
                                                     public class TestFile {


                                                         /*
                                                         - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                         - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                         - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                         - `public boolean delete()` ：删除文件或者文件夹
                                                           删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                          */
                                                         @Test
                                                         public void test05() throws IOException {
                                                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                             boolean newFile = file1.createNewFile();
                                                             System.out.println(newFile);

                                                             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                             boolean mkdir = file2.mkdir();
                                                             System.out.println(mkdir);

                                                             File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                             //时间转换
                                                             LocalDate date = LocalDate.now();

                                                             DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                             String dateFile = date.format(dateTimeFormatter);

                                                             File file = new File(file3, dateFile);
                                                             System.out.println(file.mkdir());


                                                             //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                             File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                             System.out.println(file4.mkdirs());

                                                             System.out.println(file4.delete());

                                                             file1.delete();
                                                         }


                                                         /*
                                                         - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                         - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                         - `public boolean isFile()` ：此File表示的是否为文件。
                                                         - public boolean canRead() ：判断是否可读
                                                         - public boolean canWrite() ：判断是否可写
                                                         - public boolean isHidden() ：判断是否隐藏
                                                          */
                                                         @Test
                                                         public void test04(){
                                                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                             boolean exists = file1.exists();
                                                             System.out.println("存在："+exists);

                                                             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                             boolean directory = file2.isDirectory();
                                                             System.out.println("文件夹："+directory);
                                                             boolean file = file2.isFile();
                                                             System.out.println("文件"+file);

                                                             boolean b = file2.canRead();
                                                             System.out.println("可读"+b);
                                                             boolean w = file2.canWrite();
                                                             System.out.println("可写"+w);

                                                             File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                             boolean hidden = file3.isHidden();
                                                             System.out.println("隐藏："+hidden);
                                                         }

                                                         /*
                                                          * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                          * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                          */
                                                         @Test
                                                         public void test03(){
                                                             //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                             File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                             String[] list = file.list();
                                                             //遍历
                                                             for (String s : list) {
                                                                 System.out.println("名称："+s);
                                                             }

                                                             //File数组
                                                             File[] files = file.listFiles();

                                                             for (File file1 : files) {
                                                                 System.out.println(file1.getName());
                                                                 System.out.println(file1.getAbsoluteFile());
                                                             }


                                                         }



                                                         /*
                                                          * public String getName() ：获取名称
                                                          * public String getPath() ：获取路径
                                                          * `public String getAbsolutePath()`：获取绝对路径
                                                          * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                          * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                          * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                          * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                          */
                                                         @Test
                                                         public void test02(){
                                                             File file = new File("upload\\a.txt");
                                                             System.out.println(file.getName());
                                                             String path = file.getPath();
                                                             System.out.println(path);
                                                             File absoluteFile = file.getAbsoluteFile();
                                                             System.out.println(absoluteFile);

                                                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                             File absoluteFile1 = file1.getAbsoluteFile();
                                                             System.out.println(absoluteFile1);
                                                             String path1 = file1.getPath();
                                                             System.out.println(path1);

                                                             //path 使用的是构建路径。
                                                             String parent = file1.getParent();
                                                             System.out.println("parent:"+parent);

                                                             long length = file1.length();
                                                             System.out.println("字节："+length);

                                                             long l = file1.lastModified();
                                                             Date date = new Date(l);
                                                             System.out.println(date);

                                                             //1.8 转换成时间 ？？？

                                                         }

                                                         /*
                                                         * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                         * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                         * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                         关于路径：
                                                         * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                         * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                           * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                           * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                          */
                                                         @Test
                                                         public void test01(){
                                                             //绝对路径
                                                             File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                             //获取名称
                                                             System.out.println(file.getName());
                                                             //输出
                                                             System.out.println(file);

                                                             //相对路径
                                                             File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                             //获取名称
                                                             System.out.println(file1.getName());
                                                             //输出
                                                             System.out.println(file1);


                                                             //构造  public File(File parent, String child)`
                                                             File upload = new File("upload");
                                                             File file2 = new File(upload, "b.txt");

                                                             //获取名称
                                                             System.out.println(file2.getName());
                                                             //输出
                                                             System.out.println(file2);
                                                         }
                                                     }package com.lc.day17.file1;

                                                      import org.junit.Test;

                                                      import java.io.File;
                                                      import java.io.IOException;
                                                      import java.time.LocalDate;
                                                      import java.time.format.DateTimeFormatter;
                                                      import java.util.Date;

                                                      /**
                                                       * ClassName: TestFile
                                                       * Package: com.lc.day17.file1
                                                       * Description:
                                                       *
                                                       * @Author 爱扣钉-陈晨
                                                       * @Create 2023/8/5 9:23
                                                       * @Version 1.0
                                                       */
                                                      public class TestFile {


                                                          /*
                                                          - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                          - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                          - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                          - `public boolean delete()` ：删除文件或者文件夹
                                                            删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                           */
                                                          @Test
                                                          public void test05() throws IOException {
                                                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                              boolean newFile = file1.createNewFile();
                                                              System.out.println(newFile);

                                                              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                              boolean mkdir = file2.mkdir();
                                                              System.out.println(mkdir);

                                                              File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                              //时间转换
                                                              LocalDate date = LocalDate.now();

                                                              DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                              String dateFile = date.format(dateTimeFormatter);

                                                              File file = new File(file3, dateFile);
                                                              System.out.println(file.mkdir());


                                                              //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                              File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                              System.out.println(file4.mkdirs());

                                                              System.out.println(file4.delete());

                                                              file1.delete();
                                                          }


                                                          /*
                                                          - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                          - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                          - `public boolean isFile()` ：此File表示的是否为文件。
                                                          - public boolean canRead() ：判断是否可读
                                                          - public boolean canWrite() ：判断是否可写
                                                          - public boolean isHidden() ：判断是否隐藏
                                                           */
                                                          @Test
                                                          public void test04(){
                                                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                              boolean exists = file1.exists();
                                                              System.out.println("存在："+exists);

                                                              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                              boolean directory = file2.isDirectory();
                                                              System.out.println("文件夹："+directory);
                                                              boolean file = file2.isFile();
                                                              System.out.println("文件"+file);

                                                              boolean b = file2.canRead();
                                                              System.out.println("可读"+b);
                                                              boolean w = file2.canWrite();
                                                              System.out.println("可写"+w);

                                                              File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                              boolean hidden = file3.isHidden();
                                                              System.out.println("隐藏："+hidden);
                                                          }

                                                          /*
                                                           * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                           * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                           */
                                                          @Test
                                                          public void test03(){
                                                              //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                              File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                              String[] list = file.list();
                                                              //遍历
                                                              for (String s : list) {
                                                                  System.out.println("名称："+s);
                                                              }

                                                              //File数组
                                                              File[] files = file.listFiles();

                                                              for (File file1 : files) {
                                                                  System.out.println(file1.getName());
                                                                  System.out.println(file1.getAbsoluteFile());
                                                              }


                                                          }



                                                          /*
                                                           * public String getName() ：获取名称
                                                           * public String getPath() ：获取路径
                                                           * `public String getAbsolutePath()`：获取绝对路径
                                                           * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                           * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                           * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                           * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                           */
                                                          @Test
                                                          public void test02(){
                                                              File file = new File("upload\\a.txt");
                                                              System.out.println(file.getName());
                                                              String path = file.getPath();
                                                              System.out.println(path);
                                                              File absoluteFile = file.getAbsoluteFile();
                                                              System.out.println(absoluteFile);

                                                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                              File absoluteFile1 = file1.getAbsoluteFile();
                                                              System.out.println(absoluteFile1);
                                                              String path1 = file1.getPath();
                                                              System.out.println(path1);

                                                              //path 使用的是构建路径。
                                                              String parent = file1.getParent();
                                                              System.out.println("parent:"+parent);

                                                              long length = file1.length();
                                                              System.out.println("字节："+length);

                                                              long l = file1.lastModified();
                                                              Date date = new Date(l);
                                                              System.out.println(date);

                                                              //1.8 转换成时间 ？？？

                                                          }

                                                          /*
                                                          * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                          * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                          * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                          关于路径：
                                                          * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                          * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                            * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                            * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                           */
                                                          @Test
                                                          public void test01(){
                                                              //绝对路径
                                                              File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                              //获取名称
                                                              System.out.println(file.getName());
                                                              //输出
                                                              System.out.println(file);

                                                              //相对路径
                                                              File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                              //获取名称
                                                              System.out.println(file1.getName());
                                                              //输出
                                                              System.out.println(file1);


                                                              //构造  public File(File parent, String child)`
                                                              File upload = new File("upload");
                                                              File file2 = new File(upload, "b.txt");

                                                              //获取名称
                                                              System.out.println(file2.getName());
                                                              //输出
                                                              System.out.println(file2);
                                                          }
                                                      }package com.lc.day17.file1;

                                                       import org.junit.Test;

                                                       import java.io.File;
                                                       import java.io.IOException;
                                                       import java.time.LocalDate;
                                                       import java.time.format.DateTimeFormatter;
                                                       import java.util.Date;

                                                       /**
                                                        * ClassName: TestFile
                                                        * Package: com.lc.day17.file1
                                                        * Description:
                                                        *
                                                        * @Author 爱扣钉-陈晨
                                                        * @Create 2023/8/5 9:23
                                                        * @Version 1.0
                                                        */
                                                       public class TestFile {


                                                           /*
                                                           - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                           - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                           - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                           - `public boolean delete()` ：删除文件或者文件夹
                                                             删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                            */
                                                           @Test
                                                           public void test05() throws IOException {
                                                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                               boolean newFile = file1.createNewFile();
                                                               System.out.println(newFile);

                                                               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                               boolean mkdir = file2.mkdir();
                                                               System.out.println(mkdir);

                                                               File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                               //时间转换
                                                               LocalDate date = LocalDate.now();

                                                               DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                               String dateFile = date.format(dateTimeFormatter);

                                                               File file = new File(file3, dateFile);
                                                               System.out.println(file.mkdir());


                                                               //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                               File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                               System.out.println(file4.mkdirs());

                                                               System.out.println(file4.delete());

                                                               file1.delete();
                                                           }


                                                           /*
                                                           - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                           - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                           - `public boolean isFile()` ：此File表示的是否为文件。
                                                           - public boolean canRead() ：判断是否可读
                                                           - public boolean canWrite() ：判断是否可写
                                                           - public boolean isHidden() ：判断是否隐藏
                                                            */
                                                           @Test
                                                           public void test04(){
                                                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                               boolean exists = file1.exists();
                                                               System.out.println("存在："+exists);

                                                               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                               boolean directory = file2.isDirectory();
                                                               System.out.println("文件夹："+directory);
                                                               boolean file = file2.isFile();
                                                               System.out.println("文件"+file);

                                                               boolean b = file2.canRead();
                                                               System.out.println("可读"+b);
                                                               boolean w = file2.canWrite();
                                                               System.out.println("可写"+w);

                                                               File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                               boolean hidden = file3.isHidden();
                                                               System.out.println("隐藏："+hidden);
                                                           }

                                                           /*
                                                            * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                            * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                            */
                                                           @Test
                                                           public void test03(){
                                                               //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                               File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                               String[] list = file.list();
                                                               //遍历
                                                               for (String s : list) {
                                                                   System.out.println("名称："+s);
                                                               }

                                                               //File数组
                                                               File[] files = file.listFiles();

                                                               for (File file1 : files) {
                                                                   System.out.println(file1.getName());
                                                                   System.out.println(file1.getAbsoluteFile());
                                                               }


                                                           }



                                                           /*
                                                            * public String getName() ：获取名称
                                                            * public String getPath() ：获取路径
                                                            * `public String getAbsolutePath()`：获取绝对路径
                                                            * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                            * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                            * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                            * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                            */
                                                           @Test
                                                           public void test02(){
                                                               File file = new File("upload\\a.txt");
                                                               System.out.println(file.getName());
                                                               String path = file.getPath();
                                                               System.out.println(path);
                                                               File absoluteFile = file.getAbsoluteFile();
                                                               System.out.println(absoluteFile);

                                                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                               File absoluteFile1 = file1.getAbsoluteFile();
                                                               System.out.println(absoluteFile1);
                                                               String path1 = file1.getPath();
                                                               System.out.println(path1);

                                                               //path 使用的是构建路径。
                                                               String parent = file1.getParent();
                                                               System.out.println("parent:"+parent);

                                                               long length = file1.length();
                                                               System.out.println("字节："+length);

                                                               long l = file1.lastModified();
                                                               Date date = new Date(l);
                                                               System.out.println(date);

                                                               //1.8 转换成时间 ？？？

                                                           }

                                                           /*
                                                           * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                           * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                           * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                           关于路径：
                                                           * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                           * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                             * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                             * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                            */
                                                           @Test
                                                           public void test01(){
                                                               //绝对路径
                                                               File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                               //获取名称
                                                               System.out.println(file.getName());
                                                               //输出
                                                               System.out.println(file);

                                                               //相对路径
                                                               File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                               //获取名称
                                                               System.out.println(file1.getName());
                                                               //输出
                                                               System.out.println(file1);


                                                               //构造  public File(File parent, String child)`
                                                               File upload = new File("upload");
                                                               File file2 = new File(upload, "b.txt");

                                                               //获取名称
                                                               System.out.println(file2.getName());
                                                               //输出
                                                               System.out.println(file2);
                                                           }
                                                       }package com.lc.day17.file1;

                                                        import org.junit.Test;

                                                        import java.io.File;
                                                        import java.io.IOException;
                                                        import java.time.LocalDate;
                                                        import java.time.format.DateTimeFormatter;
                                                        import java.util.Date;

                                                        /**
                                                         * ClassName: TestFile
                                                         * Package: com.lc.day17.file1
                                                         * Description:
                                                         *
                                                         * @Author 爱扣钉-陈晨
                                                         * @Create 2023/8/5 9:23
                                                         * @Version 1.0
                                                         */
                                                        public class TestFile {


                                                            /*
                                                            - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                            - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                            - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                            - `public boolean delete()` ：删除文件或者文件夹
                                                              删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                             */
                                                            @Test
                                                            public void test05() throws IOException {
                                                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                boolean newFile = file1.createNewFile();
                                                                System.out.println(newFile);

                                                                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                boolean mkdir = file2.mkdir();
                                                                System.out.println(mkdir);

                                                                File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                //时间转换
                                                                LocalDate date = LocalDate.now();

                                                                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                String dateFile = date.format(dateTimeFormatter);

                                                                File file = new File(file3, dateFile);
                                                                System.out.println(file.mkdir());


                                                                //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                System.out.println(file4.mkdirs());

                                                                System.out.println(file4.delete());

                                                                file1.delete();
                                                            }


                                                            /*
                                                            - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                            - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                            - `public boolean isFile()` ：此File表示的是否为文件。
                                                            - public boolean canRead() ：判断是否可读
                                                            - public boolean canWrite() ：判断是否可写
                                                            - public boolean isHidden() ：判断是否隐藏
                                                             */
                                                            @Test
                                                            public void test04(){
                                                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                boolean exists = file1.exists();
                                                                System.out.println("存在："+exists);

                                                                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                boolean directory = file2.isDirectory();
                                                                System.out.println("文件夹："+directory);
                                                                boolean file = file2.isFile();
                                                                System.out.println("文件"+file);

                                                                boolean b = file2.canRead();
                                                                System.out.println("可读"+b);
                                                                boolean w = file2.canWrite();
                                                                System.out.println("可写"+w);

                                                                File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                boolean hidden = file3.isHidden();
                                                                System.out.println("隐藏："+hidden);
                                                            }

                                                            /*
                                                             * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                             * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                             */
                                                            @Test
                                                            public void test03(){
                                                                //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                String[] list = file.list();
                                                                //遍历
                                                                for (String s : list) {
                                                                    System.out.println("名称："+s);
                                                                }

                                                                //File数组
                                                                File[] files = file.listFiles();

                                                                for (File file1 : files) {
                                                                    System.out.println(file1.getName());
                                                                    System.out.println(file1.getAbsoluteFile());
                                                                }


                                                            }



                                                            /*
                                                             * public String getName() ：获取名称
                                                             * public String getPath() ：获取路径
                                                             * `public String getAbsolutePath()`：获取绝对路径
                                                             * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                             * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                             * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                             * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                             */
                                                            @Test
                                                            public void test02(){
                                                                File file = new File("upload\\a.txt");
                                                                System.out.println(file.getName());
                                                                String path = file.getPath();
                                                                System.out.println(path);
                                                                File absoluteFile = file.getAbsoluteFile();
                                                                System.out.println(absoluteFile);

                                                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                File absoluteFile1 = file1.getAbsoluteFile();
                                                                System.out.println(absoluteFile1);
                                                                String path1 = file1.getPath();
                                                                System.out.println(path1);

                                                                //path 使用的是构建路径。
                                                                String parent = file1.getParent();
                                                                System.out.println("parent:"+parent);

                                                                long length = file1.length();
                                                                System.out.println("字节："+length);

                                                                long l = file1.lastModified();
                                                                Date date = new Date(l);
                                                                System.out.println(date);

                                                                //1.8 转换成时间 ？？？

                                                            }

                                                            /*
                                                            * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                            * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                            * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                            关于路径：
                                                            * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                            * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                              * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                              * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                             */
                                                            @Test
                                                            public void test01(){
                                                                //绝对路径
                                                                File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                //获取名称
                                                                System.out.println(file.getName());
                                                                //输出
                                                                System.out.println(file);

                                                                //相对路径
                                                                File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                //获取名称
                                                                System.out.println(file1.getName());
                                                                //输出
                                                                System.out.println(file1);


                                                                //构造  public File(File parent, String child)`
                                                                File upload = new File("upload");
                                                                File file2 = new File(upload, "b.txt");

                                                                //获取名称
                                                                System.out.println(file2.getName());
                                                                //输出
                                                                System.out.println(file2);
                                                            }
                                                        }package com.lc.day17.file1;

                                                         import org.junit.Test;

                                                         import java.io.File;
                                                         import java.io.IOException;
                                                         import java.time.LocalDate;
                                                         import java.time.format.DateTimeFormatter;
                                                         import java.util.Date;

                                                         /**
                                                          * ClassName: TestFile
                                                          * Package: com.lc.day17.file1
                                                          * Description:
                                                          *
                                                          * @Author 爱扣钉-陈晨
                                                          * @Create 2023/8/5 9:23
                                                          * @Version 1.0
                                                          */
                                                         public class TestFile {


                                                             /*
                                                             - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                             - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                             - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                             - `public boolean delete()` ：删除文件或者文件夹
                                                               删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                              */
                                                             @Test
                                                             public void test05() throws IOException {
                                                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                 boolean newFile = file1.createNewFile();
                                                                 System.out.println(newFile);

                                                                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                 boolean mkdir = file2.mkdir();
                                                                 System.out.println(mkdir);

                                                                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                 //时间转换
                                                                 LocalDate date = LocalDate.now();

                                                                 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                 String dateFile = date.format(dateTimeFormatter);

                                                                 File file = new File(file3, dateFile);
                                                                 System.out.println(file.mkdir());


                                                                 //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                 File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                 System.out.println(file4.mkdirs());

                                                                 System.out.println(file4.delete());

                                                                 file1.delete();
                                                             }


                                                             /*
                                                             - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                             - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                             - `public boolean isFile()` ：此File表示的是否为文件。
                                                             - public boolean canRead() ：判断是否可读
                                                             - public boolean canWrite() ：判断是否可写
                                                             - public boolean isHidden() ：判断是否隐藏
                                                              */
                                                             @Test
                                                             public void test04(){
                                                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                 boolean exists = file1.exists();
                                                                 System.out.println("存在："+exists);

                                                                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                 boolean directory = file2.isDirectory();
                                                                 System.out.println("文件夹："+directory);
                                                                 boolean file = file2.isFile();
                                                                 System.out.println("文件"+file);

                                                                 boolean b = file2.canRead();
                                                                 System.out.println("可读"+b);
                                                                 boolean w = file2.canWrite();
                                                                 System.out.println("可写"+w);

                                                                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                 boolean hidden = file3.isHidden();
                                                                 System.out.println("隐藏："+hidden);
                                                             }

                                                             /*
                                                              * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                              * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                              */
                                                             @Test
                                                             public void test03(){
                                                                 //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                 File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                 String[] list = file.list();
                                                                 //遍历
                                                                 for (String s : list) {
                                                                     System.out.println("名称："+s);
                                                                 }

                                                                 //File数组
                                                                 File[] files = file.listFiles();

                                                                 for (File file1 : files) {
                                                                     System.out.println(file1.getName());
                                                                     System.out.println(file1.getAbsoluteFile());
                                                                 }


                                                             }



                                                             /*
                                                              * public String getName() ：获取名称
                                                              * public String getPath() ：获取路径
                                                              * `public String getAbsolutePath()`：获取绝对路径
                                                              * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                              * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                              * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                              * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                              */
                                                             @Test
                                                             public void test02(){
                                                                 File file = new File("upload\\a.txt");
                                                                 System.out.println(file.getName());
                                                                 String path = file.getPath();
                                                                 System.out.println(path);
                                                                 File absoluteFile = file.getAbsoluteFile();
                                                                 System.out.println(absoluteFile);

                                                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                 File absoluteFile1 = file1.getAbsoluteFile();
                                                                 System.out.println(absoluteFile1);
                                                                 String path1 = file1.getPath();
                                                                 System.out.println(path1);

                                                                 //path 使用的是构建路径。
                                                                 String parent = file1.getParent();
                                                                 System.out.println("parent:"+parent);

                                                                 long length = file1.length();
                                                                 System.out.println("字节："+length);

                                                                 long l = file1.lastModified();
                                                                 Date date = new Date(l);
                                                                 System.out.println(date);

                                                                 //1.8 转换成时间 ？？？

                                                             }

                                                             /*
                                                             * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                             * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                             * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                             关于路径：
                                                             * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                             * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                               * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                               * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                              */
                                                             @Test
                                                             public void test01(){
                                                                 //绝对路径
                                                                 File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                 //获取名称
                                                                 System.out.println(file.getName());
                                                                 //输出
                                                                 System.out.println(file);

                                                                 //相对路径
                                                                 File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                 //获取名称
                                                                 System.out.println(file1.getName());
                                                                 //输出
                                                                 System.out.println(file1);


                                                                 //构造  public File(File parent, String child)`
                                                                 File upload = new File("upload");
                                                                 File file2 = new File(upload, "b.txt");

                                                                 //获取名称
                                                                 System.out.println(file2.getName());
                                                                 //输出
                                                                 System.out.println(file2);
                                                             }
                                                         }package com.lc.day17.file1;

                                                          import org.junit.Test;

                                                          import java.io.File;
                                                          import java.io.IOException;
                                                          import java.time.LocalDate;
                                                          import java.time.format.DateTimeFormatter;
                                                          import java.util.Date;

                                                          /**
                                                           * ClassName: TestFile
                                                           * Package: com.lc.day17.file1
                                                           * Description:
                                                           *
                                                           * @Author 爱扣钉-陈晨
                                                           * @Create 2023/8/5 9:23
                                                           * @Version 1.0
                                                           */
                                                          public class TestFile {


                                                              /*
                                                              - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                              - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                              - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                              - `public boolean delete()` ：删除文件或者文件夹
                                                                删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                               */
                                                              @Test
                                                              public void test05() throws IOException {
                                                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                  boolean newFile = file1.createNewFile();
                                                                  System.out.println(newFile);

                                                                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                  boolean mkdir = file2.mkdir();
                                                                  System.out.println(mkdir);

                                                                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                  //时间转换
                                                                  LocalDate date = LocalDate.now();

                                                                  DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                  String dateFile = date.format(dateTimeFormatter);

                                                                  File file = new File(file3, dateFile);
                                                                  System.out.println(file.mkdir());


                                                                  //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                  File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                  System.out.println(file4.mkdirs());

                                                                  System.out.println(file4.delete());

                                                                  file1.delete();
                                                              }


                                                              /*
                                                              - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                              - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                              - `public boolean isFile()` ：此File表示的是否为文件。
                                                              - public boolean canRead() ：判断是否可读
                                                              - public boolean canWrite() ：判断是否可写
                                                              - public boolean isHidden() ：判断是否隐藏
                                                               */
                                                              @Test
                                                              public void test04(){
                                                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                  boolean exists = file1.exists();
                                                                  System.out.println("存在："+exists);

                                                                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                  boolean directory = file2.isDirectory();
                                                                  System.out.println("文件夹："+directory);
                                                                  boolean file = file2.isFile();
                                                                  System.out.println("文件"+file);

                                                                  boolean b = file2.canRead();
                                                                  System.out.println("可读"+b);
                                                                  boolean w = file2.canWrite();
                                                                  System.out.println("可写"+w);

                                                                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                  boolean hidden = file3.isHidden();
                                                                  System.out.println("隐藏："+hidden);
                                                              }

                                                              /*
                                                               * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                               * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                               */
                                                              @Test
                                                              public void test03(){
                                                                  //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                  File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                  String[] list = file.list();
                                                                  //遍历
                                                                  for (String s : list) {
                                                                      System.out.println("名称："+s);
                                                                  }

                                                                  //File数组
                                                                  File[] files = file.listFiles();

                                                                  for (File file1 : files) {
                                                                      System.out.println(file1.getName());
                                                                      System.out.println(file1.getAbsoluteFile());
                                                                  }


                                                              }



                                                              /*
                                                               * public String getName() ：获取名称
                                                               * public String getPath() ：获取路径
                                                               * `public String getAbsolutePath()`：获取绝对路径
                                                               * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                               * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                               * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                               * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                               */
                                                              @Test
                                                              public void test02(){
                                                                  File file = new File("upload\\a.txt");
                                                                  System.out.println(file.getName());
                                                                  String path = file.getPath();
                                                                  System.out.println(path);
                                                                  File absoluteFile = file.getAbsoluteFile();
                                                                  System.out.println(absoluteFile);

                                                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                  File absoluteFile1 = file1.getAbsoluteFile();
                                                                  System.out.println(absoluteFile1);
                                                                  String path1 = file1.getPath();
                                                                  System.out.println(path1);

                                                                  //path 使用的是构建路径。
                                                                  String parent = file1.getParent();
                                                                  System.out.println("parent:"+parent);

                                                                  long length = file1.length();
                                                                  System.out.println("字节："+length);

                                                                  long l = file1.lastModified();
                                                                  Date date = new Date(l);
                                                                  System.out.println(date);

                                                                  //1.8 转换成时间 ？？？

                                                              }

                                                              /*
                                                              * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                              * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                              * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                              关于路径：
                                                              * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                              * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                               */
                                                              @Test
                                                              public void test01(){
                                                                  //绝对路径
                                                                  File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                  //获取名称
                                                                  System.out.println(file.getName());
                                                                  //输出
                                                                  System.out.println(file);

                                                                  //相对路径
                                                                  File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                  //获取名称
                                                                  System.out.println(file1.getName());
                                                                  //输出
                                                                  System.out.println(file1);


                                                                  //构造  public File(File parent, String child)`
                                                                  File upload = new File("upload");
                                                                  File file2 = new File(upload, "b.txt");

                                                                  //获取名称
                                                                  System.out.println(file2.getName());
                                                                  //输出
                                                                  System.out.println(file2);
                                                              }
                                                          }package com.lc.day17.file1;

                                                           import org.junit.Test;

                                                           import java.io.File;
                                                           import java.io.IOException;
                                                           import java.time.LocalDate;
                                                           import java.time.format.DateTimeFormatter;
                                                           import java.util.Date;

                                                           /**
                                                            * ClassName: TestFile
                                                            * Package: com.lc.day17.file1
                                                            * Description:
                                                            *
                                                            * @Author 爱扣钉-陈晨
                                                            * @Create 2023/8/5 9:23
                                                            * @Version 1.0
                                                            */
                                                           public class TestFile {


                                                               /*
                                                               - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                               - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                               - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                               - `public boolean delete()` ：删除文件或者文件夹
                                                                 删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                */
                                                               @Test
                                                               public void test05() throws IOException {
                                                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                   boolean newFile = file1.createNewFile();
                                                                   System.out.println(newFile);

                                                                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                   boolean mkdir = file2.mkdir();
                                                                   System.out.println(mkdir);

                                                                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                   //时间转换
                                                                   LocalDate date = LocalDate.now();

                                                                   DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                   String dateFile = date.format(dateTimeFormatter);

                                                                   File file = new File(file3, dateFile);
                                                                   System.out.println(file.mkdir());


                                                                   //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                   File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                   System.out.println(file4.mkdirs());

                                                                   System.out.println(file4.delete());

                                                                   file1.delete();
                                                               }


                                                               /*
                                                               - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                               - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                               - `public boolean isFile()` ：此File表示的是否为文件。
                                                               - public boolean canRead() ：判断是否可读
                                                               - public boolean canWrite() ：判断是否可写
                                                               - public boolean isHidden() ：判断是否隐藏
                                                                */
                                                               @Test
                                                               public void test04(){
                                                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                   boolean exists = file1.exists();
                                                                   System.out.println("存在："+exists);

                                                                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                   boolean directory = file2.isDirectory();
                                                                   System.out.println("文件夹："+directory);
                                                                   boolean file = file2.isFile();
                                                                   System.out.println("文件"+file);

                                                                   boolean b = file2.canRead();
                                                                   System.out.println("可读"+b);
                                                                   boolean w = file2.canWrite();
                                                                   System.out.println("可写"+w);

                                                                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                   boolean hidden = file3.isHidden();
                                                                   System.out.println("隐藏："+hidden);
                                                               }

                                                               /*
                                                                * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                */
                                                               @Test
                                                               public void test03(){
                                                                   //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                   File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                   String[] list = file.list();
                                                                   //遍历
                                                                   for (String s : list) {
                                                                       System.out.println("名称："+s);
                                                                   }

                                                                   //File数组
                                                                   File[] files = file.listFiles();

                                                                   for (File file1 : files) {
                                                                       System.out.println(file1.getName());
                                                                       System.out.println(file1.getAbsoluteFile());
                                                                   }


                                                               }



                                                               /*
                                                                * public String getName() ：获取名称
                                                                * public String getPath() ：获取路径
                                                                * `public String getAbsolutePath()`：获取绝对路径
                                                                * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                */
                                                               @Test
                                                               public void test02(){
                                                                   File file = new File("upload\\a.txt");
                                                                   System.out.println(file.getName());
                                                                   String path = file.getPath();
                                                                   System.out.println(path);
                                                                   File absoluteFile = file.getAbsoluteFile();
                                                                   System.out.println(absoluteFile);

                                                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                   File absoluteFile1 = file1.getAbsoluteFile();
                                                                   System.out.println(absoluteFile1);
                                                                   String path1 = file1.getPath();
                                                                   System.out.println(path1);

                                                                   //path 使用的是构建路径。
                                                                   String parent = file1.getParent();
                                                                   System.out.println("parent:"+parent);

                                                                   long length = file1.length();
                                                                   System.out.println("字节："+length);

                                                                   long l = file1.lastModified();
                                                                   Date date = new Date(l);
                                                                   System.out.println(date);

                                                                   //1.8 转换成时间 ？？？

                                                               }

                                                               /*
                                                               * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                               * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                               * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                               关于路径：
                                                               * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                               * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                 * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                 * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                */
                                                               @Test
                                                               public void test01(){
                                                                   //绝对路径
                                                                   File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                   //获取名称
                                                                   System.out.println(file.getName());
                                                                   //输出
                                                                   System.out.println(file);

                                                                   //相对路径
                                                                   File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                   //获取名称
                                                                   System.out.println(file1.getName());
                                                                   //输出
                                                                   System.out.println(file1);


                                                                   //构造  public File(File parent, String child)`
                                                                   File upload = new File("upload");
                                                                   File file2 = new File(upload, "b.txt");

                                                                   //获取名称
                                                                   System.out.println(file2.getName());
                                                                   //输出
                                                                   System.out.println(file2);
                                                               }
                                                           }package com.lc.day17.file1;

                                                            import org.junit.Test;

                                                            import java.io.File;
                                                            import java.io.IOException;
                                                            import java.time.LocalDate;
                                                            import java.time.format.DateTimeFormatter;
                                                            import java.util.Date;

                                                            /**
                                                             * ClassName: TestFile
                                                             * Package: com.lc.day17.file1
                                                             * Description:
                                                             *
                                                             * @Author 爱扣钉-陈晨
                                                             * @Create 2023/8/5 9:23
                                                             * @Version 1.0
                                                             */
                                                            public class TestFile {


                                                                /*
                                                                - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                - `public boolean delete()` ：删除文件或者文件夹
                                                                  删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                 */
                                                                @Test
                                                                public void test05() throws IOException {
                                                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                    boolean newFile = file1.createNewFile();
                                                                    System.out.println(newFile);

                                                                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                    boolean mkdir = file2.mkdir();
                                                                    System.out.println(mkdir);

                                                                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                    //时间转换
                                                                    LocalDate date = LocalDate.now();

                                                                    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                    String dateFile = date.format(dateTimeFormatter);

                                                                    File file = new File(file3, dateFile);
                                                                    System.out.println(file.mkdir());


                                                                    //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                    File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                    System.out.println(file4.mkdirs());

                                                                    System.out.println(file4.delete());

                                                                    file1.delete();
                                                                }


                                                                /*
                                                                - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                - `public boolean isFile()` ：此File表示的是否为文件。
                                                                - public boolean canRead() ：判断是否可读
                                                                - public boolean canWrite() ：判断是否可写
                                                                - public boolean isHidden() ：判断是否隐藏
                                                                 */
                                                                @Test
                                                                public void test04(){
                                                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                    boolean exists = file1.exists();
                                                                    System.out.println("存在："+exists);

                                                                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                    boolean directory = file2.isDirectory();
                                                                    System.out.println("文件夹："+directory);
                                                                    boolean file = file2.isFile();
                                                                    System.out.println("文件"+file);

                                                                    boolean b = file2.canRead();
                                                                    System.out.println("可读"+b);
                                                                    boolean w = file2.canWrite();
                                                                    System.out.println("可写"+w);

                                                                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                    boolean hidden = file3.isHidden();
                                                                    System.out.println("隐藏："+hidden);
                                                                }

                                                                /*
                                                                 * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                 * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                 */
                                                                @Test
                                                                public void test03(){
                                                                    //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                    File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                    String[] list = file.list();
                                                                    //遍历
                                                                    for (String s : list) {
                                                                        System.out.println("名称："+s);
                                                                    }

                                                                    //File数组
                                                                    File[] files = file.listFiles();

                                                                    for (File file1 : files) {
                                                                        System.out.println(file1.getName());
                                                                        System.out.println(file1.getAbsoluteFile());
                                                                    }


                                                                }



                                                                /*
                                                                 * public String getName() ：获取名称
                                                                 * public String getPath() ：获取路径
                                                                 * `public String getAbsolutePath()`：获取绝对路径
                                                                 * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                 * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                 * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                 * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                 */
                                                                @Test
                                                                public void test02(){
                                                                    File file = new File("upload\\a.txt");
                                                                    System.out.println(file.getName());
                                                                    String path = file.getPath();
                                                                    System.out.println(path);
                                                                    File absoluteFile = file.getAbsoluteFile();
                                                                    System.out.println(absoluteFile);

                                                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                    File absoluteFile1 = file1.getAbsoluteFile();
                                                                    System.out.println(absoluteFile1);
                                                                    String path1 = file1.getPath();
                                                                    System.out.println(path1);

                                                                    //path 使用的是构建路径。
                                                                    String parent = file1.getParent();
                                                                    System.out.println("parent:"+parent);

                                                                    long length = file1.length();
                                                                    System.out.println("字节："+length);

                                                                    long l = file1.lastModified();
                                                                    Date date = new Date(l);
                                                                    System.out.println(date);

                                                                    //1.8 转换成时间 ？？？

                                                                }

                                                                /*
                                                                * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                关于路径：
                                                                * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                  * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                  * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                 */
                                                                @Test
                                                                public void test01(){
                                                                    //绝对路径
                                                                    File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                    //获取名称
                                                                    System.out.println(file.getName());
                                                                    //输出
                                                                    System.out.println(file);

                                                                    //相对路径
                                                                    File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                    //获取名称
                                                                    System.out.println(file1.getName());
                                                                    //输出
                                                                    System.out.println(file1);


                                                                    //构造  public File(File parent, String child)`
                                                                    File upload = new File("upload");
                                                                    File file2 = new File(upload, "b.txt");

                                                                    //获取名称
                                                                    System.out.println(file2.getName());
                                                                    //输出
                                                                    System.out.println(file2);
                                                                }
                                                            }package com.lc.day17.file1;

                                                             import org.junit.Test;

                                                             import java.io.File;
                                                             import java.io.IOException;
                                                             import java.time.LocalDate;
                                                             import java.time.format.DateTimeFormatter;
                                                             import java.util.Date;

                                                             /**
                                                              * ClassName: TestFile
                                                              * Package: com.lc.day17.file1
                                                              * Description:
                                                              *
                                                              * @Author 爱扣钉-陈晨
                                                              * @Create 2023/8/5 9:23
                                                              * @Version 1.0
                                                              */
                                                             public class TestFile {


                                                                 /*
                                                                 - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                 - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                 - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                 - `public boolean delete()` ：删除文件或者文件夹
                                                                   删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                  */
                                                                 @Test
                                                                 public void test05() throws IOException {
                                                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                     boolean newFile = file1.createNewFile();
                                                                     System.out.println(newFile);

                                                                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                     boolean mkdir = file2.mkdir();
                                                                     System.out.println(mkdir);

                                                                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                     //时间转换
                                                                     LocalDate date = LocalDate.now();

                                                                     DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                     String dateFile = date.format(dateTimeFormatter);

                                                                     File file = new File(file3, dateFile);
                                                                     System.out.println(file.mkdir());


                                                                     //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                     File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                     System.out.println(file4.mkdirs());

                                                                     System.out.println(file4.delete());

                                                                     file1.delete();
                                                                 }


                                                                 /*
                                                                 - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                 - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                 - `public boolean isFile()` ：此File表示的是否为文件。
                                                                 - public boolean canRead() ：判断是否可读
                                                                 - public boolean canWrite() ：判断是否可写
                                                                 - public boolean isHidden() ：判断是否隐藏
                                                                  */
                                                                 @Test
                                                                 public void test04(){
                                                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                     boolean exists = file1.exists();
                                                                     System.out.println("存在："+exists);

                                                                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                     boolean directory = file2.isDirectory();
                                                                     System.out.println("文件夹："+directory);
                                                                     boolean file = file2.isFile();
                                                                     System.out.println("文件"+file);

                                                                     boolean b = file2.canRead();
                                                                     System.out.println("可读"+b);
                                                                     boolean w = file2.canWrite();
                                                                     System.out.println("可写"+w);

                                                                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                     boolean hidden = file3.isHidden();
                                                                     System.out.println("隐藏："+hidden);
                                                                 }

                                                                 /*
                                                                  * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                  * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                  */
                                                                 @Test
                                                                 public void test03(){
                                                                     //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                     File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                     String[] list = file.list();
                                                                     //遍历
                                                                     for (String s : list) {
                                                                         System.out.println("名称："+s);
                                                                     }

                                                                     //File数组
                                                                     File[] files = file.listFiles();

                                                                     for (File file1 : files) {
                                                                         System.out.println(file1.getName());
                                                                         System.out.println(file1.getAbsoluteFile());
                                                                     }


                                                                 }



                                                                 /*
                                                                  * public String getName() ：获取名称
                                                                  * public String getPath() ：获取路径
                                                                  * `public String getAbsolutePath()`：获取绝对路径
                                                                  * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                  * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                  * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                  * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                  */
                                                                 @Test
                                                                 public void test02(){
                                                                     File file = new File("upload\\a.txt");
                                                                     System.out.println(file.getName());
                                                                     String path = file.getPath();
                                                                     System.out.println(path);
                                                                     File absoluteFile = file.getAbsoluteFile();
                                                                     System.out.println(absoluteFile);

                                                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                     File absoluteFile1 = file1.getAbsoluteFile();
                                                                     System.out.println(absoluteFile1);
                                                                     String path1 = file1.getPath();
                                                                     System.out.println(path1);

                                                                     //path 使用的是构建路径。
                                                                     String parent = file1.getParent();
                                                                     System.out.println("parent:"+parent);

                                                                     long length = file1.length();
                                                                     System.out.println("字节："+length);

                                                                     long l = file1.lastModified();
                                                                     Date date = new Date(l);
                                                                     System.out.println(date);

                                                                     //1.8 转换成时间 ？？？

                                                                 }

                                                                 /*
                                                                 * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                 * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                 * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                 关于路径：
                                                                 * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                 * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                   * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                   * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                  */
                                                                 @Test
                                                                 public void test01(){
                                                                     //绝对路径
                                                                     File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                     //获取名称
                                                                     System.out.println(file.getName());
                                                                     //输出
                                                                     System.out.println(file);

                                                                     //相对路径
                                                                     File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                     //获取名称
                                                                     System.out.println(file1.getName());
                                                                     //输出
                                                                     System.out.println(file1);


                                                                     //构造  public File(File parent, String child)`
                                                                     File upload = new File("upload");
                                                                     File file2 = new File(upload, "b.txt");

                                                                     //获取名称
                                                                     System.out.println(file2.getName());
                                                                     //输出
                                                                     System.out.println(file2);
                                                                 }
                                                             }package com.lc.day17.file1;

                                                              import org.junit.Test;

                                                              import java.io.File;
                                                              import java.io.IOException;
                                                              import java.time.LocalDate;
                                                              import java.time.format.DateTimeFormatter;
                                                              import java.util.Date;

                                                              /**
                                                               * ClassName: TestFile
                                                               * Package: com.lc.day17.file1
                                                               * Description:
                                                               *
                                                               * @Author 爱扣钉-陈晨
                                                               * @Create 2023/8/5 9:23
                                                               * @Version 1.0
                                                               */
                                                              public class TestFile {


                                                                  /*
                                                                  - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                  - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                  - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                  - `public boolean delete()` ：删除文件或者文件夹
                                                                    删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                   */
                                                                  @Test
                                                                  public void test05() throws IOException {
                                                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                      boolean newFile = file1.createNewFile();
                                                                      System.out.println(newFile);

                                                                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                      boolean mkdir = file2.mkdir();
                                                                      System.out.println(mkdir);

                                                                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                      //时间转换
                                                                      LocalDate date = LocalDate.now();

                                                                      DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                      String dateFile = date.format(dateTimeFormatter);

                                                                      File file = new File(file3, dateFile);
                                                                      System.out.println(file.mkdir());


                                                                      //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                      File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                      System.out.println(file4.mkdirs());

                                                                      System.out.println(file4.delete());

                                                                      file1.delete();
                                                                  }


                                                                  /*
                                                                  - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                  - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                  - `public boolean isFile()` ：此File表示的是否为文件。
                                                                  - public boolean canRead() ：判断是否可读
                                                                  - public boolean canWrite() ：判断是否可写
                                                                  - public boolean isHidden() ：判断是否隐藏
                                                                   */
                                                                  @Test
                                                                  public void test04(){
                                                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                      boolean exists = file1.exists();
                                                                      System.out.println("存在："+exists);

                                                                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                      boolean directory = file2.isDirectory();
                                                                      System.out.println("文件夹："+directory);
                                                                      boolean file = file2.isFile();
                                                                      System.out.println("文件"+file);

                                                                      boolean b = file2.canRead();
                                                                      System.out.println("可读"+b);
                                                                      boolean w = file2.canWrite();
                                                                      System.out.println("可写"+w);

                                                                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                      boolean hidden = file3.isHidden();
                                                                      System.out.println("隐藏："+hidden);
                                                                  }

                                                                  /*
                                                                   * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                   * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                   */
                                                                  @Test
                                                                  public void test03(){
                                                                      //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                      File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                      String[] list = file.list();
                                                                      //遍历
                                                                      for (String s : list) {
                                                                          System.out.println("名称："+s);
                                                                      }

                                                                      //File数组
                                                                      File[] files = file.listFiles();

                                                                      for (File file1 : files) {
                                                                          System.out.println(file1.getName());
                                                                          System.out.println(file1.getAbsoluteFile());
                                                                      }


                                                                  }



                                                                  /*
                                                                   * public String getName() ：获取名称
                                                                   * public String getPath() ：获取路径
                                                                   * `public String getAbsolutePath()`：获取绝对路径
                                                                   * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                   * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                   * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                   * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                   */
                                                                  @Test
                                                                  public void test02(){
                                                                      File file = new File("upload\\a.txt");
                                                                      System.out.println(file.getName());
                                                                      String path = file.getPath();
                                                                      System.out.println(path);
                                                                      File absoluteFile = file.getAbsoluteFile();
                                                                      System.out.println(absoluteFile);

                                                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                      File absoluteFile1 = file1.getAbsoluteFile();
                                                                      System.out.println(absoluteFile1);
                                                                      String path1 = file1.getPath();
                                                                      System.out.println(path1);

                                                                      //path 使用的是构建路径。
                                                                      String parent = file1.getParent();
                                                                      System.out.println("parent:"+parent);

                                                                      long length = file1.length();
                                                                      System.out.println("字节："+length);

                                                                      long l = file1.lastModified();
                                                                      Date date = new Date(l);
                                                                      System.out.println(date);

                                                                      //1.8 转换成时间 ？？？

                                                                  }

                                                                  /*
                                                                  * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                  * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                  * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                  关于路径：
                                                                  * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                  * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                    * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                    * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                   */
                                                                  @Test
                                                                  public void test01(){
                                                                      //绝对路径
                                                                      File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                      //获取名称
                                                                      System.out.println(file.getName());
                                                                      //输出
                                                                      System.out.println(file);

                                                                      //相对路径
                                                                      File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                      //获取名称
                                                                      System.out.println(file1.getName());
                                                                      //输出
                                                                      System.out.println(file1);


                                                                      //构造  public File(File parent, String child)`
                                                                      File upload = new File("upload");
                                                                      File file2 = new File(upload, "b.txt");

                                                                      //获取名称
                                                                      System.out.println(file2.getName());
                                                                      //输出
                                                                      System.out.println(file2);
                                                                  }
                                                              }package com.lc.day17.file1;

                                                               import org.junit.Test;

                                                               import java.io.File;
                                                               import java.io.IOException;
                                                               import java.time.LocalDate;
                                                               import java.time.format.DateTimeFormatter;
                                                               import java.util.Date;

                                                               /**
                                                                * ClassName: TestFile
                                                                * Package: com.lc.day17.file1
                                                                * Description:
                                                                *
                                                                * @Author 爱扣钉-陈晨
                                                                * @Create 2023/8/5 9:23
                                                                * @Version 1.0
                                                                */
                                                               public class TestFile {


                                                                   /*
                                                                   - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                   - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                   - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                   - `public boolean delete()` ：删除文件或者文件夹
                                                                     删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                    */
                                                                   @Test
                                                                   public void test05() throws IOException {
                                                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                       boolean newFile = file1.createNewFile();
                                                                       System.out.println(newFile);

                                                                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                       boolean mkdir = file2.mkdir();
                                                                       System.out.println(mkdir);

                                                                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                       //时间转换
                                                                       LocalDate date = LocalDate.now();

                                                                       DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                       String dateFile = date.format(dateTimeFormatter);

                                                                       File file = new File(file3, dateFile);
                                                                       System.out.println(file.mkdir());


                                                                       //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                       File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                       System.out.println(file4.mkdirs());

                                                                       System.out.println(file4.delete());

                                                                       file1.delete();
                                                                   }


                                                                   /*
                                                                   - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                   - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                   - `public boolean isFile()` ：此File表示的是否为文件。
                                                                   - public boolean canRead() ：判断是否可读
                                                                   - public boolean canWrite() ：判断是否可写
                                                                   - public boolean isHidden() ：判断是否隐藏
                                                                    */
                                                                   @Test
                                                                   public void test04(){
                                                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                       boolean exists = file1.exists();
                                                                       System.out.println("存在："+exists);

                                                                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                       boolean directory = file2.isDirectory();
                                                                       System.out.println("文件夹："+directory);
                                                                       boolean file = file2.isFile();
                                                                       System.out.println("文件"+file);

                                                                       boolean b = file2.canRead();
                                                                       System.out.println("可读"+b);
                                                                       boolean w = file2.canWrite();
                                                                       System.out.println("可写"+w);

                                                                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                       boolean hidden = file3.isHidden();
                                                                       System.out.println("隐藏："+hidden);
                                                                   }

                                                                   /*
                                                                    * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                    * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                    */
                                                                   @Test
                                                                   public void test03(){
                                                                       //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                       File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                       String[] list = file.list();
                                                                       //遍历
                                                                       for (String s : list) {
                                                                           System.out.println("名称："+s);
                                                                       }

                                                                       //File数组
                                                                       File[] files = file.listFiles();

                                                                       for (File file1 : files) {
                                                                           System.out.println(file1.getName());
                                                                           System.out.println(file1.getAbsoluteFile());
                                                                       }


                                                                   }



                                                                   /*
                                                                    * public String getName() ：获取名称
                                                                    * public String getPath() ：获取路径
                                                                    * `public String getAbsolutePath()`：获取绝对路径
                                                                    * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                    * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                    * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                    * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                    */
                                                                   @Test
                                                                   public void test02(){
                                                                       File file = new File("upload\\a.txt");
                                                                       System.out.println(file.getName());
                                                                       String path = file.getPath();
                                                                       System.out.println(path);
                                                                       File absoluteFile = file.getAbsoluteFile();
                                                                       System.out.println(absoluteFile);

                                                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                       File absoluteFile1 = file1.getAbsoluteFile();
                                                                       System.out.println(absoluteFile1);
                                                                       String path1 = file1.getPath();
                                                                       System.out.println(path1);

                                                                       //path 使用的是构建路径。
                                                                       String parent = file1.getParent();
                                                                       System.out.println("parent:"+parent);

                                                                       long length = file1.length();
                                                                       System.out.println("字节："+length);

                                                                       long l = file1.lastModified();
                                                                       Date date = new Date(l);
                                                                       System.out.println(date);

                                                                       //1.8 转换成时间 ？？？

                                                                   }

                                                                   /*
                                                                   * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                   * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                   * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                   关于路径：
                                                                   * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                   * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                     * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                     * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                    */
                                                                   @Test
                                                                   public void test01(){
                                                                       //绝对路径
                                                                       File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                       //获取名称
                                                                       System.out.println(file.getName());
                                                                       //输出
                                                                       System.out.println(file);

                                                                       //相对路径
                                                                       File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                       //获取名称
                                                                       System.out.println(file1.getName());
                                                                       //输出
                                                                       System.out.println(file1);


                                                                       //构造  public File(File parent, String child)`
                                                                       File upload = new File("upload");
                                                                       File file2 = new File(upload, "b.txt");

                                                                       //获取名称
                                                                       System.out.println(file2.getName());
                                                                       //输出
                                                                       System.out.println(file2);
                                                                   }
                                                               }package com.lc.day17.file1;

                                                                import org.junit.Test;

                                                                import java.io.File;
                                                                import java.io.IOException;
                                                                import java.time.LocalDate;
                                                                import java.time.format.DateTimeFormatter;
                                                                import java.util.Date;

                                                                /**
                                                                 * ClassName: TestFile
                                                                 * Package: com.lc.day17.file1
                                                                 * Description:
                                                                 *
                                                                 * @Author 爱扣钉-陈晨
                                                                 * @Create 2023/8/5 9:23
                                                                 * @Version 1.0
                                                                 */
                                                                public class TestFile {


                                                                    /*
                                                                    - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                    - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                    - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                    - `public boolean delete()` ：删除文件或者文件夹
                                                                      删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                     */
                                                                    @Test
                                                                    public void test05() throws IOException {
                                                                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                        boolean newFile = file1.createNewFile();
                                                                        System.out.println(newFile);

                                                                        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                        boolean mkdir = file2.mkdir();
                                                                        System.out.println(mkdir);

                                                                        File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                        //时间转换
                                                                        LocalDate date = LocalDate.now();

                                                                        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                        String dateFile = date.format(dateTimeFormatter);

                                                                        File file = new File(file3, dateFile);
                                                                        System.out.println(file.mkdir());


                                                                        //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                        File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                        System.out.println(file4.mkdirs());

                                                                        System.out.println(file4.delete());

                                                                        file1.delete();
                                                                    }


                                                                    /*
                                                                    - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                    - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                    - `public boolean isFile()` ：此File表示的是否为文件。
                                                                    - public boolean canRead() ：判断是否可读
                                                                    - public boolean canWrite() ：判断是否可写
                                                                    - public boolean isHidden() ：判断是否隐藏
                                                                     */
                                                                    @Test
                                                                    public void test04(){
                                                                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                        boolean exists = file1.exists();
                                                                        System.out.println("存在："+exists);

                                                                        File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                        boolean directory = file2.isDirectory();
                                                                        System.out.println("文件夹："+directory);
                                                                        boolean file = file2.isFile();
                                                                        System.out.println("文件"+file);

                                                                        boolean b = file2.canRead();
                                                                        System.out.println("可读"+b);
                                                                        boolean w = file2.canWrite();
                                                                        System.out.println("可写"+w);

                                                                        File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                        boolean hidden = file3.isHidden();
                                                                        System.out.println("隐藏："+hidden);
                                                                    }

                                                                    /*
                                                                     * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                     * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                     */
                                                                    @Test
                                                                    public void test03(){
                                                                        //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                        File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                        String[] list = file.list();
                                                                        //遍历
                                                                        for (String s : list) {
                                                                            System.out.println("名称："+s);
                                                                        }

                                                                        //File数组
                                                                        File[] files = file.listFiles();

                                                                        for (File file1 : files) {
                                                                            System.out.println(file1.getName());
                                                                            System.out.println(file1.getAbsoluteFile());
                                                                        }


                                                                    }



                                                                    /*
                                                                     * public String getName() ：获取名称
                                                                     * public String getPath() ：获取路径
                                                                     * `public String getAbsolutePath()`：获取绝对路径
                                                                     * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                     * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                     * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                     * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                     */
                                                                    @Test
                                                                    public void test02(){
                                                                        File file = new File("upload\\a.txt");
                                                                        System.out.println(file.getName());
                                                                        String path = file.getPath();
                                                                        System.out.println(path);
                                                                        File absoluteFile = file.getAbsoluteFile();
                                                                        System.out.println(absoluteFile);

                                                                        File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                        File absoluteFile1 = file1.getAbsoluteFile();
                                                                        System.out.println(absoluteFile1);
                                                                        String path1 = file1.getPath();
                                                                        System.out.println(path1);

                                                                        //path 使用的是构建路径。
                                                                        String parent = file1.getParent();
                                                                        System.out.println("parent:"+parent);

                                                                        long length = file1.length();
                                                                        System.out.println("字节："+length);

                                                                        long l = file1.lastModified();
                                                                        Date date = new Date(l);
                                                                        System.out.println(date);

                                                                        //1.8 转换成时间 ？？？

                                                                    }

                                                                    /*
                                                                    * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                    * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                    * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                    关于路径：
                                                                    * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                    * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                      * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                      * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                     */
                                                                    @Test
                                                                    public void test01(){
                                                                        //绝对路径
                                                                        File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                        //获取名称
                                                                        System.out.println(file.getName());
                                                                        //输出
                                                                        System.out.println(file);

                                                                        //相对路径
                                                                        File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                        //获取名称
                                                                        System.out.println(file1.getName());
                                                                        //输出
                                                                        System.out.println(file1);


                                                                        //构造  public File(File parent, String child)`
                                                                        File upload = new File("upload");
                                                                        File file2 = new File(upload, "b.txt");

                                                                        //获取名称
                                                                        System.out.println(file2.getName());
                                                                        //输出
                                                                        System.out.println(file2);
                                                                    }
                                                                }package com.lc.day17.file1;

                                                                 import org.junit.Test;

                                                                 import java.io.File;
                                                                 import java.io.IOException;
                                                                 import java.time.LocalDate;
                                                                 import java.time.format.DateTimeFormatter;
                                                                 import java.util.Date;

                                                                 /**
                                                                  * ClassName: TestFile
                                                                  * Package: com.lc.day17.file1
                                                                  * Description:
                                                                  *
                                                                  * @Author 爱扣钉-陈晨
                                                                  * @Create 2023/8/5 9:23
                                                                  * @Version 1.0
                                                                  */
                                                                 public class TestFile {


                                                                     /*
                                                                     - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                     - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                     - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                     - `public boolean delete()` ：删除文件或者文件夹
                                                                       删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                      */
                                                                     @Test
                                                                     public void test05() throws IOException {
                                                                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                         boolean newFile = file1.createNewFile();
                                                                         System.out.println(newFile);

                                                                         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                         boolean mkdir = file2.mkdir();
                                                                         System.out.println(mkdir);

                                                                         File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                         //时间转换
                                                                         LocalDate date = LocalDate.now();

                                                                         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                         String dateFile = date.format(dateTimeFormatter);

                                                                         File file = new File(file3, dateFile);
                                                                         System.out.println(file.mkdir());


                                                                         //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                         File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                         System.out.println(file4.mkdirs());

                                                                         System.out.println(file4.delete());

                                                                         file1.delete();
                                                                     }


                                                                     /*
                                                                     - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                     - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                     - `public boolean isFile()` ：此File表示的是否为文件。
                                                                     - public boolean canRead() ：判断是否可读
                                                                     - public boolean canWrite() ：判断是否可写
                                                                     - public boolean isHidden() ：判断是否隐藏
                                                                      */
                                                                     @Test
                                                                     public void test04(){
                                                                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                         boolean exists = file1.exists();
                                                                         System.out.println("存在："+exists);

                                                                         File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                         boolean directory = file2.isDirectory();
                                                                         System.out.println("文件夹："+directory);
                                                                         boolean file = file2.isFile();
                                                                         System.out.println("文件"+file);

                                                                         boolean b = file2.canRead();
                                                                         System.out.println("可读"+b);
                                                                         boolean w = file2.canWrite();
                                                                         System.out.println("可写"+w);

                                                                         File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                         boolean hidden = file3.isHidden();
                                                                         System.out.println("隐藏："+hidden);
                                                                     }

                                                                     /*
                                                                      * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                      * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                      */
                                                                     @Test
                                                                     public void test03(){
                                                                         //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                         File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                         String[] list = file.list();
                                                                         //遍历
                                                                         for (String s : list) {
                                                                             System.out.println("名称："+s);
                                                                         }

                                                                         //File数组
                                                                         File[] files = file.listFiles();

                                                                         for (File file1 : files) {
                                                                             System.out.println(file1.getName());
                                                                             System.out.println(file1.getAbsoluteFile());
                                                                         }


                                                                     }



                                                                     /*
                                                                      * public String getName() ：获取名称
                                                                      * public String getPath() ：获取路径
                                                                      * `public String getAbsolutePath()`：获取绝对路径
                                                                      * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                      * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                      * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                      * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                      */
                                                                     @Test
                                                                     public void test02(){
                                                                         File file = new File("upload\\a.txt");
                                                                         System.out.println(file.getName());
                                                                         String path = file.getPath();
                                                                         System.out.println(path);
                                                                         File absoluteFile = file.getAbsoluteFile();
                                                                         System.out.println(absoluteFile);

                                                                         File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                         File absoluteFile1 = file1.getAbsoluteFile();
                                                                         System.out.println(absoluteFile1);
                                                                         String path1 = file1.getPath();
                                                                         System.out.println(path1);

                                                                         //path 使用的是构建路径。
                                                                         String parent = file1.getParent();
                                                                         System.out.println("parent:"+parent);

                                                                         long length = file1.length();
                                                                         System.out.println("字节："+length);

                                                                         long l = file1.lastModified();
                                                                         Date date = new Date(l);
                                                                         System.out.println(date);

                                                                         //1.8 转换成时间 ？？？

                                                                     }

                                                                     /*
                                                                     * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                     * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                     * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                     关于路径：
                                                                     * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                     * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                       * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                       * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                      */
                                                                     @Test
                                                                     public void test01(){
                                                                         //绝对路径
                                                                         File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                         //获取名称
                                                                         System.out.println(file.getName());
                                                                         //输出
                                                                         System.out.println(file);

                                                                         //相对路径
                                                                         File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                         //获取名称
                                                                         System.out.println(file1.getName());
                                                                         //输出
                                                                         System.out.println(file1);


                                                                         //构造  public File(File parent, String child)`
                                                                         File upload = new File("upload");
                                                                         File file2 = new File(upload, "b.txt");

                                                                         //获取名称
                                                                         System.out.println(file2.getName());
                                                                         //输出
                                                                         System.out.println(file2);
                                                                     }
                                                                 }package com.lc.day17.file1;

                                                                  import org.junit.Test;

                                                                  import java.io.File;
                                                                  import java.io.IOException;
                                                                  import java.time.LocalDate;
                                                                  import java.time.format.DateTimeFormatter;
                                                                  import java.util.Date;

                                                                  /**
                                                                   * ClassName: TestFile
                                                                   * Package: com.lc.day17.file1
                                                                   * Description:
                                                                   *
                                                                   * @Author 爱扣钉-陈晨
                                                                   * @Create 2023/8/5 9:23
                                                                   * @Version 1.0
                                                                   */
                                                                  public class TestFile {


                                                                      /*
                                                                      - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                      - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                      - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                      - `public boolean delete()` ：删除文件或者文件夹
                                                                        删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                       */
                                                                      @Test
                                                                      public void test05() throws IOException {
                                                                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                          boolean newFile = file1.createNewFile();
                                                                          System.out.println(newFile);

                                                                          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                          boolean mkdir = file2.mkdir();
                                                                          System.out.println(mkdir);

                                                                          File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                          //时间转换
                                                                          LocalDate date = LocalDate.now();

                                                                          DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                          String dateFile = date.format(dateTimeFormatter);

                                                                          File file = new File(file3, dateFile);
                                                                          System.out.println(file.mkdir());


                                                                          //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                          File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                          System.out.println(file4.mkdirs());

                                                                          System.out.println(file4.delete());

                                                                          file1.delete();
                                                                      }


                                                                      /*
                                                                      - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                      - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                      - `public boolean isFile()` ：此File表示的是否为文件。
                                                                      - public boolean canRead() ：判断是否可读
                                                                      - public boolean canWrite() ：判断是否可写
                                                                      - public boolean isHidden() ：判断是否隐藏
                                                                       */
                                                                      @Test
                                                                      public void test04(){
                                                                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                          boolean exists = file1.exists();
                                                                          System.out.println("存在："+exists);

                                                                          File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                          boolean directory = file2.isDirectory();
                                                                          System.out.println("文件夹："+directory);
                                                                          boolean file = file2.isFile();
                                                                          System.out.println("文件"+file);

                                                                          boolean b = file2.canRead();
                                                                          System.out.println("可读"+b);
                                                                          boolean w = file2.canWrite();
                                                                          System.out.println("可写"+w);

                                                                          File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                          boolean hidden = file3.isHidden();
                                                                          System.out.println("隐藏："+hidden);
                                                                      }

                                                                      /*
                                                                       * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                       * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                       */
                                                                      @Test
                                                                      public void test03(){
                                                                          //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                          File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                          String[] list = file.list();
                                                                          //遍历
                                                                          for (String s : list) {
                                                                              System.out.println("名称："+s);
                                                                          }

                                                                          //File数组
                                                                          File[] files = file.listFiles();

                                                                          for (File file1 : files) {
                                                                              System.out.println(file1.getName());
                                                                              System.out.println(file1.getAbsoluteFile());
                                                                          }


                                                                      }



                                                                      /*
                                                                       * public String getName() ：获取名称
                                                                       * public String getPath() ：获取路径
                                                                       * `public String getAbsolutePath()`：获取绝对路径
                                                                       * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                       * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                       * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                       * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                       */
                                                                      @Test
                                                                      public void test02(){
                                                                          File file = new File("upload\\a.txt");
                                                                          System.out.println(file.getName());
                                                                          String path = file.getPath();
                                                                          System.out.println(path);
                                                                          File absoluteFile = file.getAbsoluteFile();
                                                                          System.out.println(absoluteFile);

                                                                          File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                          File absoluteFile1 = file1.getAbsoluteFile();
                                                                          System.out.println(absoluteFile1);
                                                                          String path1 = file1.getPath();
                                                                          System.out.println(path1);

                                                                          //path 使用的是构建路径。
                                                                          String parent = file1.getParent();
                                                                          System.out.println("parent:"+parent);

                                                                          long length = file1.length();
                                                                          System.out.println("字节："+length);

                                                                          long l = file1.lastModified();
                                                                          Date date = new Date(l);
                                                                          System.out.println(date);

                                                                          //1.8 转换成时间 ？？？

                                                                      }

                                                                      /*
                                                                      * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                      * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                      * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                      关于路径：
                                                                      * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                      * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                        * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                        * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                       */
                                                                      @Test
                                                                      public void test01(){
                                                                          //绝对路径
                                                                          File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                          //获取名称
                                                                          System.out.println(file.getName());
                                                                          //输出
                                                                          System.out.println(file);

                                                                          //相对路径
                                                                          File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                          //获取名称
                                                                          System.out.println(file1.getName());
                                                                          //输出
                                                                          System.out.println(file1);


                                                                          //构造  public File(File parent, String child)`
                                                                          File upload = new File("upload");
                                                                          File file2 = new File(upload, "b.txt");

                                                                          //获取名称
                                                                          System.out.println(file2.getName());
                                                                          //输出
                                                                          System.out.println(file2);
                                                                      }
                                                                  }package com.lc.day17.file1;

                                                                   import org.junit.Test;

                                                                   import java.io.File;
                                                                   import java.io.IOException;
                                                                   import java.time.LocalDate;
                                                                   import java.time.format.DateTimeFormatter;
                                                                   import java.util.Date;

                                                                   /**
                                                                    * ClassName: TestFile
                                                                    * Package: com.lc.day17.file1
                                                                    * Description:
                                                                    *
                                                                    * @Author 爱扣钉-陈晨
                                                                    * @Create 2023/8/5 9:23
                                                                    * @Version 1.0
                                                                    */
                                                                   public class TestFile {


                                                                       /*
                                                                       - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                       - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                       - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                       - `public boolean delete()` ：删除文件或者文件夹
                                                                         删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                        */
                                                                       @Test
                                                                       public void test05() throws IOException {
                                                                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                           boolean newFile = file1.createNewFile();
                                                                           System.out.println(newFile);

                                                                           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                           boolean mkdir = file2.mkdir();
                                                                           System.out.println(mkdir);

                                                                           File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                           //时间转换
                                                                           LocalDate date = LocalDate.now();

                                                                           DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                           String dateFile = date.format(dateTimeFormatter);

                                                                           File file = new File(file3, dateFile);
                                                                           System.out.println(file.mkdir());


                                                                           //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                           File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                           System.out.println(file4.mkdirs());

                                                                           System.out.println(file4.delete());

                                                                           file1.delete();
                                                                       }


                                                                       /*
                                                                       - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                       - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                       - `public boolean isFile()` ：此File表示的是否为文件。
                                                                       - public boolean canRead() ：判断是否可读
                                                                       - public boolean canWrite() ：判断是否可写
                                                                       - public boolean isHidden() ：判断是否隐藏
                                                                        */
                                                                       @Test
                                                                       public void test04(){
                                                                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                           boolean exists = file1.exists();
                                                                           System.out.println("存在："+exists);

                                                                           File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                           boolean directory = file2.isDirectory();
                                                                           System.out.println("文件夹："+directory);
                                                                           boolean file = file2.isFile();
                                                                           System.out.println("文件"+file);

                                                                           boolean b = file2.canRead();
                                                                           System.out.println("可读"+b);
                                                                           boolean w = file2.canWrite();
                                                                           System.out.println("可写"+w);

                                                                           File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                           boolean hidden = file3.isHidden();
                                                                           System.out.println("隐藏："+hidden);
                                                                       }

                                                                       /*
                                                                        * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                        * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                        */
                                                                       @Test
                                                                       public void test03(){
                                                                           //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                           File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                           String[] list = file.list();
                                                                           //遍历
                                                                           for (String s : list) {
                                                                               System.out.println("名称："+s);
                                                                           }

                                                                           //File数组
                                                                           File[] files = file.listFiles();

                                                                           for (File file1 : files) {
                                                                               System.out.println(file1.getName());
                                                                               System.out.println(file1.getAbsoluteFile());
                                                                           }


                                                                       }



                                                                       /*
                                                                        * public String getName() ：获取名称
                                                                        * public String getPath() ：获取路径
                                                                        * `public String getAbsolutePath()`：获取绝对路径
                                                                        * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                        * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                        * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                        * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                        */
                                                                       @Test
                                                                       public void test02(){
                                                                           File file = new File("upload\\a.txt");
                                                                           System.out.println(file.getName());
                                                                           String path = file.getPath();
                                                                           System.out.println(path);
                                                                           File absoluteFile = file.getAbsoluteFile();
                                                                           System.out.println(absoluteFile);

                                                                           File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                           File absoluteFile1 = file1.getAbsoluteFile();
                                                                           System.out.println(absoluteFile1);
                                                                           String path1 = file1.getPath();
                                                                           System.out.println(path1);

                                                                           //path 使用的是构建路径。
                                                                           String parent = file1.getParent();
                                                                           System.out.println("parent:"+parent);

                                                                           long length = file1.length();
                                                                           System.out.println("字节："+length);

                                                                           long l = file1.lastModified();
                                                                           Date date = new Date(l);
                                                                           System.out.println(date);

                                                                           //1.8 转换成时间 ？？？

                                                                       }

                                                                       /*
                                                                       * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                       * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                       * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                       关于路径：
                                                                       * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                       * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                         * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                         * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                        */
                                                                       @Test
                                                                       public void test01(){
                                                                           //绝对路径
                                                                           File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                           //获取名称
                                                                           System.out.println(file.getName());
                                                                           //输出
                                                                           System.out.println(file);

                                                                           //相对路径
                                                                           File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                           //获取名称
                                                                           System.out.println(file1.getName());
                                                                           //输出
                                                                           System.out.println(file1);


                                                                           //构造  public File(File parent, String child)`
                                                                           File upload = new File("upload");
                                                                           File file2 = new File(upload, "b.txt");

                                                                           //获取名称
                                                                           System.out.println(file2.getName());
                                                                           //输出
                                                                           System.out.println(file2);
                                                                       }
                                                                   }package com.lc.day17.file1;

                                                                    import org.junit.Test;

                                                                    import java.io.File;
                                                                    import java.io.IOException;
                                                                    import java.time.LocalDate;
                                                                    import java.time.format.DateTimeFormatter;
                                                                    import java.util.Date;

                                                                    /**
                                                                     * ClassName: TestFile
                                                                     * Package: com.lc.day17.file1
                                                                     * Description:
                                                                     *
                                                                     * @Author 爱扣钉-陈晨
                                                                     * @Create 2023/8/5 9:23
                                                                     * @Version 1.0
                                                                     */
                                                                    public class TestFile {


                                                                        /*
                                                                        - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                        - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                        - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                        - `public boolean delete()` ：删除文件或者文件夹
                                                                          删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                         */
                                                                        @Test
                                                                        public void test05() throws IOException {
                                                                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                            boolean newFile = file1.createNewFile();
                                                                            System.out.println(newFile);

                                                                            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                            boolean mkdir = file2.mkdir();
                                                                            System.out.println(mkdir);

                                                                            File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                            //时间转换
                                                                            LocalDate date = LocalDate.now();

                                                                            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                            String dateFile = date.format(dateTimeFormatter);

                                                                            File file = new File(file3, dateFile);
                                                                            System.out.println(file.mkdir());


                                                                            //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                            File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                            System.out.println(file4.mkdirs());

                                                                            System.out.println(file4.delete());

                                                                            file1.delete();
                                                                        }


                                                                        /*
                                                                        - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                        - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                        - `public boolean isFile()` ：此File表示的是否为文件。
                                                                        - public boolean canRead() ：判断是否可读
                                                                        - public boolean canWrite() ：判断是否可写
                                                                        - public boolean isHidden() ：判断是否隐藏
                                                                         */
                                                                        @Test
                                                                        public void test04(){
                                                                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                            boolean exists = file1.exists();
                                                                            System.out.println("存在："+exists);

                                                                            File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                            boolean directory = file2.isDirectory();
                                                                            System.out.println("文件夹："+directory);
                                                                            boolean file = file2.isFile();
                                                                            System.out.println("文件"+file);

                                                                            boolean b = file2.canRead();
                                                                            System.out.println("可读"+b);
                                                                            boolean w = file2.canWrite();
                                                                            System.out.println("可写"+w);

                                                                            File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                            boolean hidden = file3.isHidden();
                                                                            System.out.println("隐藏："+hidden);
                                                                        }

                                                                        /*
                                                                         * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                         * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                         */
                                                                        @Test
                                                                        public void test03(){
                                                                            //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                            File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                            String[] list = file.list();
                                                                            //遍历
                                                                            for (String s : list) {
                                                                                System.out.println("名称："+s);
                                                                            }

                                                                            //File数组
                                                                            File[] files = file.listFiles();

                                                                            for (File file1 : files) {
                                                                                System.out.println(file1.getName());
                                                                                System.out.println(file1.getAbsoluteFile());
                                                                            }


                                                                        }



                                                                        /*
                                                                         * public String getName() ：获取名称
                                                                         * public String getPath() ：获取路径
                                                                         * `public String getAbsolutePath()`：获取绝对路径
                                                                         * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                         * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                         * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                         * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                         */
                                                                        @Test
                                                                        public void test02(){
                                                                            File file = new File("upload\\a.txt");
                                                                            System.out.println(file.getName());
                                                                            String path = file.getPath();
                                                                            System.out.println(path);
                                                                            File absoluteFile = file.getAbsoluteFile();
                                                                            System.out.println(absoluteFile);

                                                                            File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                            File absoluteFile1 = file1.getAbsoluteFile();
                                                                            System.out.println(absoluteFile1);
                                                                            String path1 = file1.getPath();
                                                                            System.out.println(path1);

                                                                            //path 使用的是构建路径。
                                                                            String parent = file1.getParent();
                                                                            System.out.println("parent:"+parent);

                                                                            long length = file1.length();
                                                                            System.out.println("字节："+length);

                                                                            long l = file1.lastModified();
                                                                            Date date = new Date(l);
                                                                            System.out.println(date);

                                                                            //1.8 转换成时间 ？？？

                                                                        }

                                                                        /*
                                                                        * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                        * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                        * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                        关于路径：
                                                                        * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                        * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                          * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                          * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                         */
                                                                        @Test
                                                                        public void test01(){
                                                                            //绝对路径
                                                                            File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                            //获取名称
                                                                            System.out.println(file.getName());
                                                                            //输出
                                                                            System.out.println(file);

                                                                            //相对路径
                                                                            File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                            //获取名称
                                                                            System.out.println(file1.getName());
                                                                            //输出
                                                                            System.out.println(file1);


                                                                            //构造  public File(File parent, String child)`
                                                                            File upload = new File("upload");
                                                                            File file2 = new File(upload, "b.txt");

                                                                            //获取名称
                                                                            System.out.println(file2.getName());
                                                                            //输出
                                                                            System.out.println(file2);
                                                                        }
                                                                    }package com.lc.day17.file1;

                                                                     import org.junit.Test;

                                                                     import java.io.File;
                                                                     import java.io.IOException;
                                                                     import java.time.LocalDate;
                                                                     import java.time.format.DateTimeFormatter;
                                                                     import java.util.Date;

                                                                     /**
                                                                      * ClassName: TestFile
                                                                      * Package: com.lc.day17.file1
                                                                      * Description:
                                                                      *
                                                                      * @Author 爱扣钉-陈晨
                                                                      * @Create 2023/8/5 9:23
                                                                      * @Version 1.0
                                                                      */
                                                                     public class TestFile {


                                                                         /*
                                                                         - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                         - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                         - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                         - `public boolean delete()` ：删除文件或者文件夹
                                                                           删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                          */
                                                                         @Test
                                                                         public void test05() throws IOException {
                                                                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                             boolean newFile = file1.createNewFile();
                                                                             System.out.println(newFile);

                                                                             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                             boolean mkdir = file2.mkdir();
                                                                             System.out.println(mkdir);

                                                                             File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                             //时间转换
                                                                             LocalDate date = LocalDate.now();

                                                                             DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                             String dateFile = date.format(dateTimeFormatter);

                                                                             File file = new File(file3, dateFile);
                                                                             System.out.println(file.mkdir());


                                                                             //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                             File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                             System.out.println(file4.mkdirs());

                                                                             System.out.println(file4.delete());

                                                                             file1.delete();
                                                                         }


                                                                         /*
                                                                         - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                         - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                         - `public boolean isFile()` ：此File表示的是否为文件。
                                                                         - public boolean canRead() ：判断是否可读
                                                                         - public boolean canWrite() ：判断是否可写
                                                                         - public boolean isHidden() ：判断是否隐藏
                                                                          */
                                                                         @Test
                                                                         public void test04(){
                                                                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                             boolean exists = file1.exists();
                                                                             System.out.println("存在："+exists);

                                                                             File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                             boolean directory = file2.isDirectory();
                                                                             System.out.println("文件夹："+directory);
                                                                             boolean file = file2.isFile();
                                                                             System.out.println("文件"+file);

                                                                             boolean b = file2.canRead();
                                                                             System.out.println("可读"+b);
                                                                             boolean w = file2.canWrite();
                                                                             System.out.println("可写"+w);

                                                                             File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                             boolean hidden = file3.isHidden();
                                                                             System.out.println("隐藏："+hidden);
                                                                         }

                                                                         /*
                                                                          * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                          * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                          */
                                                                         @Test
                                                                         public void test03(){
                                                                             //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                             File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                             String[] list = file.list();
                                                                             //遍历
                                                                             for (String s : list) {
                                                                                 System.out.println("名称："+s);
                                                                             }

                                                                             //File数组
                                                                             File[] files = file.listFiles();

                                                                             for (File file1 : files) {
                                                                                 System.out.println(file1.getName());
                                                                                 System.out.println(file1.getAbsoluteFile());
                                                                             }


                                                                         }



                                                                         /*
                                                                          * public String getName() ：获取名称
                                                                          * public String getPath() ：获取路径
                                                                          * `public String getAbsolutePath()`：获取绝对路径
                                                                          * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                          * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                          * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                          * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                          */
                                                                         @Test
                                                                         public void test02(){
                                                                             File file = new File("upload\\a.txt");
                                                                             System.out.println(file.getName());
                                                                             String path = file.getPath();
                                                                             System.out.println(path);
                                                                             File absoluteFile = file.getAbsoluteFile();
                                                                             System.out.println(absoluteFile);

                                                                             File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                             File absoluteFile1 = file1.getAbsoluteFile();
                                                                             System.out.println(absoluteFile1);
                                                                             String path1 = file1.getPath();
                                                                             System.out.println(path1);

                                                                             //path 使用的是构建路径。
                                                                             String parent = file1.getParent();
                                                                             System.out.println("parent:"+parent);

                                                                             long length = file1.length();
                                                                             System.out.println("字节："+length);

                                                                             long l = file1.lastModified();
                                                                             Date date = new Date(l);
                                                                             System.out.println(date);

                                                                             //1.8 转换成时间 ？？？

                                                                         }

                                                                         /*
                                                                         * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                         * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                         * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                         关于路径：
                                                                         * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                         * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                           * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                           * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                          */
                                                                         @Test
                                                                         public void test01(){
                                                                             //绝对路径
                                                                             File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                             //获取名称
                                                                             System.out.println(file.getName());
                                                                             //输出
                                                                             System.out.println(file);

                                                                             //相对路径
                                                                             File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                             //获取名称
                                                                             System.out.println(file1.getName());
                                                                             //输出
                                                                             System.out.println(file1);


                                                                             //构造  public File(File parent, String child)`
                                                                             File upload = new File("upload");
                                                                             File file2 = new File(upload, "b.txt");

                                                                             //获取名称
                                                                             System.out.println(file2.getName());
                                                                             //输出
                                                                             System.out.println(file2);
                                                                         }
                                                                     }package com.lc.day17.file1;

                                                                      import org.junit.Test;

                                                                      import java.io.File;
                                                                      import java.io.IOException;
                                                                      import java.time.LocalDate;
                                                                      import java.time.format.DateTimeFormatter;
                                                                      import java.util.Date;

                                                                      /**
                                                                       * ClassName: TestFile
                                                                       * Package: com.lc.day17.file1
                                                                       * Description:
                                                                       *
                                                                       * @Author 爱扣钉-陈晨
                                                                       * @Create 2023/8/5 9:23
                                                                       * @Version 1.0
                                                                       */
                                                                      public class TestFile {


                                                                          /*
                                                                          - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                          - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                          - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                          - `public boolean delete()` ：删除文件或者文件夹
                                                                            删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                           */
                                                                          @Test
                                                                          public void test05() throws IOException {
                                                                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                              boolean newFile = file1.createNewFile();
                                                                              System.out.println(newFile);

                                                                              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                              boolean mkdir = file2.mkdir();
                                                                              System.out.println(mkdir);

                                                                              File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                              //时间转换
                                                                              LocalDate date = LocalDate.now();

                                                                              DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                              String dateFile = date.format(dateTimeFormatter);

                                                                              File file = new File(file3, dateFile);
                                                                              System.out.println(file.mkdir());


                                                                              //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                              File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                              System.out.println(file4.mkdirs());

                                                                              System.out.println(file4.delete());

                                                                              file1.delete();
                                                                          }


                                                                          /*
                                                                          - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                          - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                          - `public boolean isFile()` ：此File表示的是否为文件。
                                                                          - public boolean canRead() ：判断是否可读
                                                                          - public boolean canWrite() ：判断是否可写
                                                                          - public boolean isHidden() ：判断是否隐藏
                                                                           */
                                                                          @Test
                                                                          public void test04(){
                                                                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                              boolean exists = file1.exists();
                                                                              System.out.println("存在："+exists);

                                                                              File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                              boolean directory = file2.isDirectory();
                                                                              System.out.println("文件夹："+directory);
                                                                              boolean file = file2.isFile();
                                                                              System.out.println("文件"+file);

                                                                              boolean b = file2.canRead();
                                                                              System.out.println("可读"+b);
                                                                              boolean w = file2.canWrite();
                                                                              System.out.println("可写"+w);

                                                                              File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                              boolean hidden = file3.isHidden();
                                                                              System.out.println("隐藏："+hidden);
                                                                          }

                                                                          /*
                                                                           * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                           * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                           */
                                                                          @Test
                                                                          public void test03(){
                                                                              //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                              File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                              String[] list = file.list();
                                                                              //遍历
                                                                              for (String s : list) {
                                                                                  System.out.println("名称："+s);
                                                                              }

                                                                              //File数组
                                                                              File[] files = file.listFiles();

                                                                              for (File file1 : files) {
                                                                                  System.out.println(file1.getName());
                                                                                  System.out.println(file1.getAbsoluteFile());
                                                                              }


                                                                          }



                                                                          /*
                                                                           * public String getName() ：获取名称
                                                                           * public String getPath() ：获取路径
                                                                           * `public String getAbsolutePath()`：获取绝对路径
                                                                           * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                           * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                           * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                           * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                           */
                                                                          @Test
                                                                          public void test02(){
                                                                              File file = new File("upload\\a.txt");
                                                                              System.out.println(file.getName());
                                                                              String path = file.getPath();
                                                                              System.out.println(path);
                                                                              File absoluteFile = file.getAbsoluteFile();
                                                                              System.out.println(absoluteFile);

                                                                              File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                              File absoluteFile1 = file1.getAbsoluteFile();
                                                                              System.out.println(absoluteFile1);
                                                                              String path1 = file1.getPath();
                                                                              System.out.println(path1);

                                                                              //path 使用的是构建路径。
                                                                              String parent = file1.getParent();
                                                                              System.out.println("parent:"+parent);

                                                                              long length = file1.length();
                                                                              System.out.println("字节："+length);

                                                                              long l = file1.lastModified();
                                                                              Date date = new Date(l);
                                                                              System.out.println(date);

                                                                              //1.8 转换成时间 ？？？

                                                                          }

                                                                          /*
                                                                          * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                          * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                          * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                          关于路径：
                                                                          * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                          * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                            * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                            * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                           */
                                                                          @Test
                                                                          public void test01(){
                                                                              //绝对路径
                                                                              File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                              //获取名称
                                                                              System.out.println(file.getName());
                                                                              //输出
                                                                              System.out.println(file);

                                                                              //相对路径
                                                                              File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                              //获取名称
                                                                              System.out.println(file1.getName());
                                                                              //输出
                                                                              System.out.println(file1);


                                                                              //构造  public File(File parent, String child)`
                                                                              File upload = new File("upload");
                                                                              File file2 = new File(upload, "b.txt");

                                                                              //获取名称
                                                                              System.out.println(file2.getName());
                                                                              //输出
                                                                              System.out.println(file2);
                                                                          }
                                                                      }package com.lc.day17.file1;

                                                                       import org.junit.Test;

                                                                       import java.io.File;
                                                                       import java.io.IOException;
                                                                       import java.time.LocalDate;
                                                                       import java.time.format.DateTimeFormatter;
                                                                       import java.util.Date;

                                                                       /**
                                                                        * ClassName: TestFile
                                                                        * Package: com.lc.day17.file1
                                                                        * Description:
                                                                        *
                                                                        * @Author 爱扣钉-陈晨
                                                                        * @Create 2023/8/5 9:23
                                                                        * @Version 1.0
                                                                        */
                                                                       public class TestFile {


                                                                           /*
                                                                           - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                           - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                           - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                           - `public boolean delete()` ：删除文件或者文件夹
                                                                             删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                            */
                                                                           @Test
                                                                           public void test05() throws IOException {
                                                                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                               boolean newFile = file1.createNewFile();
                                                                               System.out.println(newFile);

                                                                               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                               boolean mkdir = file2.mkdir();
                                                                               System.out.println(mkdir);

                                                                               File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                               //时间转换
                                                                               LocalDate date = LocalDate.now();

                                                                               DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                               String dateFile = date.format(dateTimeFormatter);

                                                                               File file = new File(file3, dateFile);
                                                                               System.out.println(file.mkdir());


                                                                               //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                               File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                               System.out.println(file4.mkdirs());

                                                                               System.out.println(file4.delete());

                                                                               file1.delete();
                                                                           }


                                                                           /*
                                                                           - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                           - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                           - `public boolean isFile()` ：此File表示的是否为文件。
                                                                           - public boolean canRead() ：判断是否可读
                                                                           - public boolean canWrite() ：判断是否可写
                                                                           - public boolean isHidden() ：判断是否隐藏
                                                                            */
                                                                           @Test
                                                                           public void test04(){
                                                                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                               boolean exists = file1.exists();
                                                                               System.out.println("存在："+exists);

                                                                               File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                               boolean directory = file2.isDirectory();
                                                                               System.out.println("文件夹："+directory);
                                                                               boolean file = file2.isFile();
                                                                               System.out.println("文件"+file);

                                                                               boolean b = file2.canRead();
                                                                               System.out.println("可读"+b);
                                                                               boolean w = file2.canWrite();
                                                                               System.out.println("可写"+w);

                                                                               File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                               boolean hidden = file3.isHidden();
                                                                               System.out.println("隐藏："+hidden);
                                                                           }

                                                                           /*
                                                                            * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                            * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                            */
                                                                           @Test
                                                                           public void test03(){
                                                                               //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                               File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                               String[] list = file.list();
                                                                               //遍历
                                                                               for (String s : list) {
                                                                                   System.out.println("名称："+s);
                                                                               }

                                                                               //File数组
                                                                               File[] files = file.listFiles();

                                                                               for (File file1 : files) {
                                                                                   System.out.println(file1.getName());
                                                                                   System.out.println(file1.getAbsoluteFile());
                                                                               }


                                                                           }



                                                                           /*
                                                                            * public String getName() ：获取名称
                                                                            * public String getPath() ：获取路径
                                                                            * `public String getAbsolutePath()`：获取绝对路径
                                                                            * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                            * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                            * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                            * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                            */
                                                                           @Test
                                                                           public void test02(){
                                                                               File file = new File("upload\\a.txt");
                                                                               System.out.println(file.getName());
                                                                               String path = file.getPath();
                                                                               System.out.println(path);
                                                                               File absoluteFile = file.getAbsoluteFile();
                                                                               System.out.println(absoluteFile);

                                                                               File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                               File absoluteFile1 = file1.getAbsoluteFile();
                                                                               System.out.println(absoluteFile1);
                                                                               String path1 = file1.getPath();
                                                                               System.out.println(path1);

                                                                               //path 使用的是构建路径。
                                                                               String parent = file1.getParent();
                                                                               System.out.println("parent:"+parent);

                                                                               long length = file1.length();
                                                                               System.out.println("字节："+length);

                                                                               long l = file1.lastModified();
                                                                               Date date = new Date(l);
                                                                               System.out.println(date);

                                                                               //1.8 转换成时间 ？？？

                                                                           }

                                                                           /*
                                                                           * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                           * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                           * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                           关于路径：
                                                                           * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                           * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                             * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                             * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                            */
                                                                           @Test
                                                                           public void test01(){
                                                                               //绝对路径
                                                                               File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                               //获取名称
                                                                               System.out.println(file.getName());
                                                                               //输出
                                                                               System.out.println(file);

                                                                               //相对路径
                                                                               File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                               //获取名称
                                                                               System.out.println(file1.getName());
                                                                               //输出
                                                                               System.out.println(file1);


                                                                               //构造  public File(File parent, String child)`
                                                                               File upload = new File("upload");
                                                                               File file2 = new File(upload, "b.txt");

                                                                               //获取名称
                                                                               System.out.println(file2.getName());
                                                                               //输出
                                                                               System.out.println(file2);
                                                                           }
                                                                       }package com.lc.day17.file1;

                                                                        import org.junit.Test;

                                                                        import java.io.File;
                                                                        import java.io.IOException;
                                                                        import java.time.LocalDate;
                                                                        import java.time.format.DateTimeFormatter;
                                                                        import java.util.Date;

                                                                        /**
                                                                         * ClassName: TestFile
                                                                         * Package: com.lc.day17.file1
                                                                         * Description:
                                                                         *
                                                                         * @Author 爱扣钉-陈晨
                                                                         * @Create 2023/8/5 9:23
                                                                         * @Version 1.0
                                                                         */
                                                                        public class TestFile {


                                                                            /*
                                                                            - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                            - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                            - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                            - `public boolean delete()` ：删除文件或者文件夹
                                                                              删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                             */
                                                                            @Test
                                                                            public void test05() throws IOException {
                                                                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                                boolean newFile = file1.createNewFile();
                                                                                System.out.println(newFile);

                                                                                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                                boolean mkdir = file2.mkdir();
                                                                                System.out.println(mkdir);

                                                                                File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                                //时间转换
                                                                                LocalDate date = LocalDate.now();

                                                                                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                                String dateFile = date.format(dateTimeFormatter);

                                                                                File file = new File(file3, dateFile);
                                                                                System.out.println(file.mkdir());


                                                                                //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                                File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                                System.out.println(file4.mkdirs());

                                                                                System.out.println(file4.delete());

                                                                                file1.delete();
                                                                            }


                                                                            /*
                                                                            - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                            - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                            - `public boolean isFile()` ：此File表示的是否为文件。
                                                                            - public boolean canRead() ：判断是否可读
                                                                            - public boolean canWrite() ：判断是否可写
                                                                            - public boolean isHidden() ：判断是否隐藏
                                                                             */
                                                                            @Test
                                                                            public void test04(){
                                                                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                                boolean exists = file1.exists();
                                                                                System.out.println("存在："+exists);

                                                                                File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                boolean directory = file2.isDirectory();
                                                                                System.out.println("文件夹："+directory);
                                                                                boolean file = file2.isFile();
                                                                                System.out.println("文件"+file);

                                                                                boolean b = file2.canRead();
                                                                                System.out.println("可读"+b);
                                                                                boolean w = file2.canWrite();
                                                                                System.out.println("可写"+w);

                                                                                File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                                boolean hidden = file3.isHidden();
                                                                                System.out.println("隐藏："+hidden);
                                                                            }

                                                                            /*
                                                                             * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                             * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                             */
                                                                            @Test
                                                                            public void test03(){
                                                                                //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                                File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                                String[] list = file.list();
                                                                                //遍历
                                                                                for (String s : list) {
                                                                                    System.out.println("名称："+s);
                                                                                }

                                                                                //File数组
                                                                                File[] files = file.listFiles();

                                                                                for (File file1 : files) {
                                                                                    System.out.println(file1.getName());
                                                                                    System.out.println(file1.getAbsoluteFile());
                                                                                }


                                                                            }



                                                                            /*
                                                                             * public String getName() ：获取名称
                                                                             * public String getPath() ：获取路径
                                                                             * `public String getAbsolutePath()`：获取绝对路径
                                                                             * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                             * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                             * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                             * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                             */
                                                                            @Test
                                                                            public void test02(){
                                                                                File file = new File("upload\\a.txt");
                                                                                System.out.println(file.getName());
                                                                                String path = file.getPath();
                                                                                System.out.println(path);
                                                                                File absoluteFile = file.getAbsoluteFile();
                                                                                System.out.println(absoluteFile);

                                                                                File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                File absoluteFile1 = file1.getAbsoluteFile();
                                                                                System.out.println(absoluteFile1);
                                                                                String path1 = file1.getPath();
                                                                                System.out.println(path1);

                                                                                //path 使用的是构建路径。
                                                                                String parent = file1.getParent();
                                                                                System.out.println("parent:"+parent);

                                                                                long length = file1.length();
                                                                                System.out.println("字节："+length);

                                                                                long l = file1.lastModified();
                                                                                Date date = new Date(l);
                                                                                System.out.println(date);

                                                                                //1.8 转换成时间 ？？？

                                                                            }

                                                                            /*
                                                                            * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                            * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                            * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                            关于路径：
                                                                            * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                            * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                              * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                              * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                             */
                                                                            @Test
                                                                            public void test01(){
                                                                                //绝对路径
                                                                                File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                //获取名称
                                                                                System.out.println(file.getName());
                                                                                //输出
                                                                                System.out.println(file);

                                                                                //相对路径
                                                                                File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                                //获取名称
                                                                                System.out.println(file1.getName());
                                                                                //输出
                                                                                System.out.println(file1);


                                                                                //构造  public File(File parent, String child)`
                                                                                File upload = new File("upload");
                                                                                File file2 = new File(upload, "b.txt");

                                                                                //获取名称
                                                                                System.out.println(file2.getName());
                                                                                //输出
                                                                                System.out.println(file2);
                                                                            }
                                                                        }package com.lc.day17.file1;

                                                                         import org.junit.Test;

                                                                         import java.io.File;
                                                                         import java.io.IOException;
                                                                         import java.time.LocalDate;
                                                                         import java.time.format.DateTimeFormatter;
                                                                         import java.util.Date;

                                                                         /**
                                                                          * ClassName: TestFile
                                                                          * Package: com.lc.day17.file1
                                                                          * Description:
                                                                          *
                                                                          * @Author 爱扣钉-陈晨
                                                                          * @Create 2023/8/5 9:23
                                                                          * @Version 1.0
                                                                          */
                                                                         public class TestFile {


                                                                             /*
                                                                             - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                             - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                             - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                             - `public boolean delete()` ：删除文件或者文件夹
                                                                               删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                              */
                                                                             @Test
                                                                             public void test05() throws IOException {
                                                                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                                 boolean newFile = file1.createNewFile();
                                                                                 System.out.println(newFile);

                                                                                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                                 boolean mkdir = file2.mkdir();
                                                                                 System.out.println(mkdir);

                                                                                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                                 //时间转换
                                                                                 LocalDate date = LocalDate.now();

                                                                                 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                                 String dateFile = date.format(dateTimeFormatter);

                                                                                 File file = new File(file3, dateFile);
                                                                                 System.out.println(file.mkdir());


                                                                                 //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                                 File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                                 System.out.println(file4.mkdirs());

                                                                                 System.out.println(file4.delete());

                                                                                 file1.delete();
                                                                             }


                                                                             /*
                                                                             - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                             - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                             - `public boolean isFile()` ：此File表示的是否为文件。
                                                                             - public boolean canRead() ：判断是否可读
                                                                             - public boolean canWrite() ：判断是否可写
                                                                             - public boolean isHidden() ：判断是否隐藏
                                                                              */
                                                                             @Test
                                                                             public void test04(){
                                                                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                                 boolean exists = file1.exists();
                                                                                 System.out.println("存在："+exists);

                                                                                 File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                 boolean directory = file2.isDirectory();
                                                                                 System.out.println("文件夹："+directory);
                                                                                 boolean file = file2.isFile();
                                                                                 System.out.println("文件"+file);

                                                                                 boolean b = file2.canRead();
                                                                                 System.out.println("可读"+b);
                                                                                 boolean w = file2.canWrite();
                                                                                 System.out.println("可写"+w);

                                                                                 File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                                 boolean hidden = file3.isHidden();
                                                                                 System.out.println("隐藏："+hidden);
                                                                             }

                                                                             /*
                                                                              * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                              * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                              */
                                                                             @Test
                                                                             public void test03(){
                                                                                 //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                                 File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                                 String[] list = file.list();
                                                                                 //遍历
                                                                                 for (String s : list) {
                                                                                     System.out.println("名称："+s);
                                                                                 }

                                                                                 //File数组
                                                                                 File[] files = file.listFiles();

                                                                                 for (File file1 : files) {
                                                                                     System.out.println(file1.getName());
                                                                                     System.out.println(file1.getAbsoluteFile());
                                                                                 }


                                                                             }



                                                                             /*
                                                                              * public String getName() ：获取名称
                                                                              * public String getPath() ：获取路径
                                                                              * `public String getAbsolutePath()`：获取绝对路径
                                                                              * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                              * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                              * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                              * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                              */
                                                                             @Test
                                                                             public void test02(){
                                                                                 File file = new File("upload\\a.txt");
                                                                                 System.out.println(file.getName());
                                                                                 String path = file.getPath();
                                                                                 System.out.println(path);
                                                                                 File absoluteFile = file.getAbsoluteFile();
                                                                                 System.out.println(absoluteFile);

                                                                                 File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                 File absoluteFile1 = file1.getAbsoluteFile();
                                                                                 System.out.println(absoluteFile1);
                                                                                 String path1 = file1.getPath();
                                                                                 System.out.println(path1);

                                                                                 //path 使用的是构建路径。
                                                                                 String parent = file1.getParent();
                                                                                 System.out.println("parent:"+parent);

                                                                                 long length = file1.length();
                                                                                 System.out.println("字节："+length);

                                                                                 long l = file1.lastModified();
                                                                                 Date date = new Date(l);
                                                                                 System.out.println(date);

                                                                                 //1.8 转换成时间 ？？？

                                                                             }

                                                                             /*
                                                                             * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                             * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                             * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                             关于路径：
                                                                             * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                             * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                               * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                               * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                              */
                                                                             @Test
                                                                             public void test01(){
                                                                                 //绝对路径
                                                                                 File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                 //获取名称
                                                                                 System.out.println(file.getName());
                                                                                 //输出
                                                                                 System.out.println(file);

                                                                                 //相对路径
                                                                                 File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                                 //获取名称
                                                                                 System.out.println(file1.getName());
                                                                                 //输出
                                                                                 System.out.println(file1);


                                                                                 //构造  public File(File parent, String child)`
                                                                                 File upload = new File("upload");
                                                                                 File file2 = new File(upload, "b.txt");

                                                                                 //获取名称
                                                                                 System.out.println(file2.getName());
                                                                                 //输出
                                                                                 System.out.println(file2);
                                                                             }
                                                                         }package com.lc.day17.file1;

                                                                          import org.junit.Test;

                                                                          import java.io.File;
                                                                          import java.io.IOException;
                                                                          import java.time.LocalDate;
                                                                          import java.time.format.DateTimeFormatter;
                                                                          import java.util.Date;

                                                                          /**
                                                                           * ClassName: TestFile
                                                                           * Package: com.lc.day17.file1
                                                                           * Description:
                                                                           *
                                                                           * @Author 爱扣钉-陈晨
                                                                           * @Create 2023/8/5 9:23
                                                                           * @Version 1.0
                                                                           */
                                                                          public class TestFile {


                                                                              /*
                                                                              - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                              - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                              - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                              - `public boolean delete()` ：删除文件或者文件夹
                                                                                删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                               */
                                                                              @Test
                                                                              public void test05() throws IOException {
                                                                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                                  boolean newFile = file1.createNewFile();
                                                                                  System.out.println(newFile);

                                                                                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                                  boolean mkdir = file2.mkdir();
                                                                                  System.out.println(mkdir);

                                                                                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                                  //时间转换
                                                                                  LocalDate date = LocalDate.now();

                                                                                  DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                                  String dateFile = date.format(dateTimeFormatter);

                                                                                  File file = new File(file3, dateFile);
                                                                                  System.out.println(file.mkdir());


                                                                                  //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                                  File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                                  System.out.println(file4.mkdirs());

                                                                                  System.out.println(file4.delete());

                                                                                  file1.delete();
                                                                              }


                                                                              /*
                                                                              - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                              - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                              - `public boolean isFile()` ：此File表示的是否为文件。
                                                                              - public boolean canRead() ：判断是否可读
                                                                              - public boolean canWrite() ：判断是否可写
                                                                              - public boolean isHidden() ：判断是否隐藏
                                                                               */
                                                                              @Test
                                                                              public void test04(){
                                                                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                                  boolean exists = file1.exists();
                                                                                  System.out.println("存在："+exists);

                                                                                  File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                  boolean directory = file2.isDirectory();
                                                                                  System.out.println("文件夹："+directory);
                                                                                  boolean file = file2.isFile();
                                                                                  System.out.println("文件"+file);

                                                                                  boolean b = file2.canRead();
                                                                                  System.out.println("可读"+b);
                                                                                  boolean w = file2.canWrite();
                                                                                  System.out.println("可写"+w);

                                                                                  File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                                  boolean hidden = file3.isHidden();
                                                                                  System.out.println("隐藏："+hidden);
                                                                              }

                                                                              /*
                                                                               * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                               * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                               */
                                                                              @Test
                                                                              public void test03(){
                                                                                  //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                                  File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                                  String[] list = file.list();
                                                                                  //遍历
                                                                                  for (String s : list) {
                                                                                      System.out.println("名称："+s);
                                                                                  }

                                                                                  //File数组
                                                                                  File[] files = file.listFiles();

                                                                                  for (File file1 : files) {
                                                                                      System.out.println(file1.getName());
                                                                                      System.out.println(file1.getAbsoluteFile());
                                                                                  }


                                                                              }



                                                                              /*
                                                                               * public String getName() ：获取名称
                                                                               * public String getPath() ：获取路径
                                                                               * `public String getAbsolutePath()`：获取绝对路径
                                                                               * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                               * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                               * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                               * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                               */
                                                                              @Test
                                                                              public void test02(){
                                                                                  File file = new File("upload\\a.txt");
                                                                                  System.out.println(file.getName());
                                                                                  String path = file.getPath();
                                                                                  System.out.println(path);
                                                                                  File absoluteFile = file.getAbsoluteFile();
                                                                                  System.out.println(absoluteFile);

                                                                                  File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                  File absoluteFile1 = file1.getAbsoluteFile();
                                                                                  System.out.println(absoluteFile1);
                                                                                  String path1 = file1.getPath();
                                                                                  System.out.println(path1);

                                                                                  //path 使用的是构建路径。
                                                                                  String parent = file1.getParent();
                                                                                  System.out.println("parent:"+parent);

                                                                                  long length = file1.length();
                                                                                  System.out.println("字节："+length);

                                                                                  long l = file1.lastModified();
                                                                                  Date date = new Date(l);
                                                                                  System.out.println(date);

                                                                                  //1.8 转换成时间 ？？？

                                                                              }

                                                                              /*
                                                                              * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                              * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                              * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                              关于路径：
                                                                              * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                              * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                                * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                                * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                               */
                                                                              @Test
                                                                              public void test01(){
                                                                                  //绝对路径
                                                                                  File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                  //获取名称
                                                                                  System.out.println(file.getName());
                                                                                  //输出
                                                                                  System.out.println(file);

                                                                                  //相对路径
                                                                                  File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                                  //获取名称
                                                                                  System.out.println(file1.getName());
                                                                                  //输出
                                                                                  System.out.println(file1);


                                                                                  //构造  public File(File parent, String child)`
                                                                                  File upload = new File("upload");
                                                                                  File file2 = new File(upload, "b.txt");

                                                                                  //获取名称
                                                                                  System.out.println(file2.getName());
                                                                                  //输出
                                                                                  System.out.println(file2);
                                                                              }
                                                                          }package com.lc.day17.file1;

                                                                           import org.junit.Test;

                                                                           import java.io.File;
                                                                           import java.io.IOException;
                                                                           import java.time.LocalDate;
                                                                           import java.time.format.DateTimeFormatter;
                                                                           import java.util.Date;

                                                                           /**
                                                                            * ClassName: TestFile
                                                                            * Package: com.lc.day17.file1
                                                                            * Description:
                                                                            *
                                                                            * @Author 爱扣钉-陈晨
                                                                            * @Create 2023/8/5 9:23
                                                                            * @Version 1.0
                                                                            */
                                                                           public class TestFile {


                                                                               /*
                                                                               - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                               - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                               - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                               - `public boolean delete()` ：删除文件或者文件夹
                                                                                 删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                                */
                                                                               @Test
                                                                               public void test05() throws IOException {
                                                                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                                   boolean newFile = file1.createNewFile();
                                                                                   System.out.println(newFile);

                                                                                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                                   boolean mkdir = file2.mkdir();
                                                                                   System.out.println(mkdir);

                                                                                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                                   //时间转换
                                                                                   LocalDate date = LocalDate.now();

                                                                                   DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                                   String dateFile = date.format(dateTimeFormatter);

                                                                                   File file = new File(file3, dateFile);
                                                                                   System.out.println(file.mkdir());


                                                                                   //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                                   File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                                   System.out.println(file4.mkdirs());

                                                                                   System.out.println(file4.delete());

                                                                                   file1.delete();
                                                                               }


                                                                               /*
                                                                               - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                               - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                               - `public boolean isFile()` ：此File表示的是否为文件。
                                                                               - public boolean canRead() ：判断是否可读
                                                                               - public boolean canWrite() ：判断是否可写
                                                                               - public boolean isHidden() ：判断是否隐藏
                                                                                */
                                                                               @Test
                                                                               public void test04(){
                                                                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                                   boolean exists = file1.exists();
                                                                                   System.out.println("存在："+exists);

                                                                                   File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                   boolean directory = file2.isDirectory();
                                                                                   System.out.println("文件夹："+directory);
                                                                                   boolean file = file2.isFile();
                                                                                   System.out.println("文件"+file);

                                                                                   boolean b = file2.canRead();
                                                                                   System.out.println("可读"+b);
                                                                                   boolean w = file2.canWrite();
                                                                                   System.out.println("可写"+w);

                                                                                   File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                                   boolean hidden = file3.isHidden();
                                                                                   System.out.println("隐藏："+hidden);
                                                                               }

                                                                               /*
                                                                                * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                                * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                                */
                                                                               @Test
                                                                               public void test03(){
                                                                                   //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                                   File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                                   String[] list = file.list();
                                                                                   //遍历
                                                                                   for (String s : list) {
                                                                                       System.out.println("名称："+s);
                                                                                   }

                                                                                   //File数组
                                                                                   File[] files = file.listFiles();

                                                                                   for (File file1 : files) {
                                                                                       System.out.println(file1.getName());
                                                                                       System.out.println(file1.getAbsoluteFile());
                                                                                   }


                                                                               }



                                                                               /*
                                                                                * public String getName() ：获取名称
                                                                                * public String getPath() ：获取路径
                                                                                * `public String getAbsolutePath()`：获取绝对路径
                                                                                * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                                * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                                * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                                * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                                */
                                                                               @Test
                                                                               public void test02(){
                                                                                   File file = new File("upload\\a.txt");
                                                                                   System.out.println(file.getName());
                                                                                   String path = file.getPath();
                                                                                   System.out.println(path);
                                                                                   File absoluteFile = file.getAbsoluteFile();
                                                                                   System.out.println(absoluteFile);

                                                                                   File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                   File absoluteFile1 = file1.getAbsoluteFile();
                                                                                   System.out.println(absoluteFile1);
                                                                                   String path1 = file1.getPath();
                                                                                   System.out.println(path1);

                                                                                   //path 使用的是构建路径。
                                                                                   String parent = file1.getParent();
                                                                                   System.out.println("parent:"+parent);

                                                                                   long length = file1.length();
                                                                                   System.out.println("字节："+length);

                                                                                   long l = file1.lastModified();
                                                                                   Date date = new Date(l);
                                                                                   System.out.println(date);

                                                                                   //1.8 转换成时间 ？？？

                                                                               }

                                                                               /*
                                                                               * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                               * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                               * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                               关于路径：
                                                                               * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                               * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                                 * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                                 * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                                */
                                                                               @Test
                                                                               public void test01(){
                                                                                   //绝对路径
                                                                                   File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                   //获取名称
                                                                                   System.out.println(file.getName());
                                                                                   //输出
                                                                                   System.out.println(file);

                                                                                   //相对路径
                                                                                   File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                                   //获取名称
                                                                                   System.out.println(file1.getName());
                                                                                   //输出
                                                                                   System.out.println(file1);


                                                                                   //构造  public File(File parent, String child)`
                                                                                   File upload = new File("upload");
                                                                                   File file2 = new File(upload, "b.txt");

                                                                                   //获取名称
                                                                                   System.out.println(file2.getName());
                                                                                   //输出
                                                                                   System.out.println(file2);
                                                                               }
                                                                           }package com.lc.day17.file1;

                                                                            import org.junit.Test;

                                                                            import java.io.File;
                                                                            import java.io.IOException;
                                                                            import java.time.LocalDate;
                                                                            import java.time.format.DateTimeFormatter;
                                                                            import java.util.Date;

                                                                            /**
                                                                             * ClassName: TestFile
                                                                             * Package: com.lc.day17.file1
                                                                             * Description:
                                                                             *
                                                                             * @Author 爱扣钉-陈晨
                                                                             * @Create 2023/8/5 9:23
                                                                             * @Version 1.0
                                                                             */
                                                                            public class TestFile {


                                                                                /*
                                                                                - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                                - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                                - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                                - `public boolean delete()` ：删除文件或者文件夹
                                                                                  删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                                 */
                                                                                @Test
                                                                                public void test05() throws IOException {
                                                                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                                    boolean newFile = file1.createNewFile();
                                                                                    System.out.println(newFile);

                                                                                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                                    boolean mkdir = file2.mkdir();
                                                                                    System.out.println(mkdir);

                                                                                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                                    //时间转换
                                                                                    LocalDate date = LocalDate.now();

                                                                                    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                                    String dateFile = date.format(dateTimeFormatter);

                                                                                    File file = new File(file3, dateFile);
                                                                                    System.out.println(file.mkdir());


                                                                                    //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                                    File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                                    System.out.println(file4.mkdirs());

                                                                                    System.out.println(file4.delete());

                                                                                    file1.delete();
                                                                                }


                                                                                /*
                                                                                - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                                - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                                - `public boolean isFile()` ：此File表示的是否为文件。
                                                                                - public boolean canRead() ：判断是否可读
                                                                                - public boolean canWrite() ：判断是否可写
                                                                                - public boolean isHidden() ：判断是否隐藏
                                                                                 */
                                                                                @Test
                                                                                public void test04(){
                                                                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                                    boolean exists = file1.exists();
                                                                                    System.out.println("存在："+exists);

                                                                                    File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                    boolean directory = file2.isDirectory();
                                                                                    System.out.println("文件夹："+directory);
                                                                                    boolean file = file2.isFile();
                                                                                    System.out.println("文件"+file);

                                                                                    boolean b = file2.canRead();
                                                                                    System.out.println("可读"+b);
                                                                                    boolean w = file2.canWrite();
                                                                                    System.out.println("可写"+w);

                                                                                    File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                                    boolean hidden = file3.isHidden();
                                                                                    System.out.println("隐藏："+hidden);
                                                                                }

                                                                                /*
                                                                                 * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                                 * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                                 */
                                                                                @Test
                                                                                public void test03(){
                                                                                    //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                                    File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                                    String[] list = file.list();
                                                                                    //遍历
                                                                                    for (String s : list) {
                                                                                        System.out.println("名称："+s);
                                                                                    }

                                                                                    //File数组
                                                                                    File[] files = file.listFiles();

                                                                                    for (File file1 : files) {
                                                                                        System.out.println(file1.getName());
                                                                                        System.out.println(file1.getAbsoluteFile());
                                                                                    }


                                                                                }



                                                                                /*
                                                                                 * public String getName() ：获取名称
                                                                                 * public String getPath() ：获取路径
                                                                                 * `public String getAbsolutePath()`：获取绝对路径
                                                                                 * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                                 * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                                 * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                                 * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                                 */
                                                                                @Test
                                                                                public void test02(){
                                                                                    File file = new File("upload\\a.txt");
                                                                                    System.out.println(file.getName());
                                                                                    String path = file.getPath();
                                                                                    System.out.println(path);
                                                                                    File absoluteFile = file.getAbsoluteFile();
                                                                                    System.out.println(absoluteFile);

                                                                                    File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                    File absoluteFile1 = file1.getAbsoluteFile();
                                                                                    System.out.println(absoluteFile1);
                                                                                    String path1 = file1.getPath();
                                                                                    System.out.println(path1);

                                                                                    //path 使用的是构建路径。
                                                                                    String parent = file1.getParent();
                                                                                    System.out.println("parent:"+parent);

                                                                                    long length = file1.length();
                                                                                    System.out.println("字节："+length);

                                                                                    long l = file1.lastModified();
                                                                                    Date date = new Date(l);
                                                                                    System.out.println(date);

                                                                                    //1.8 转换成时间 ？？？

                                                                                }

                                                                                /*
                                                                                * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                                * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                                * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                                关于路径：
                                                                                * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                                * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                                  * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                                  * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                                 */
                                                                                @Test
                                                                                public void test01(){
                                                                                    //绝对路径
                                                                                    File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                    //获取名称
                                                                                    System.out.println(file.getName());
                                                                                    //输出
                                                                                    System.out.println(file);

                                                                                    //相对路径
                                                                                    File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                                    //获取名称
                                                                                    System.out.println(file1.getName());
                                                                                    //输出
                                                                                    System.out.println(file1);


                                                                                    //构造  public File(File parent, String child)`
                                                                                    File upload = new File("upload");
                                                                                    File file2 = new File(upload, "b.txt");

                                                                                    //获取名称
                                                                                    System.out.println(file2.getName());
                                                                                    //输出
                                                                                    System.out.println(file2);
                                                                                }
                                                                            }package com.lc.day17.file1;

                                                                             import org.junit.Test;

                                                                             import java.io.File;
                                                                             import java.io.IOException;
                                                                             import java.time.LocalDate;
                                                                             import java.time.format.DateTimeFormatter;
                                                                             import java.util.Date;

                                                                             /**
                                                                              * ClassName: TestFile
                                                                              * Package: com.lc.day17.file1
                                                                              * Description:
                                                                              *
                                                                              * @Author 爱扣钉-陈晨
                                                                              * @Create 2023/8/5 9:23
                                                                              * @Version 1.0
                                                                              */
                                                                             public class TestFile {


                                                                                 /*
                                                                                 - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                                 - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                                 - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                                 - `public boolean delete()` ：删除文件或者文件夹
                                                                                   删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                                  */
                                                                                 @Test
                                                                                 public void test05() throws IOException {
                                                                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                                     boolean newFile = file1.createNewFile();
                                                                                     System.out.println(newFile);

                                                                                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                                     boolean mkdir = file2.mkdir();
                                                                                     System.out.println(mkdir);

                                                                                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                                     //时间转换
                                                                                     LocalDate date = LocalDate.now();

                                                                                     DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                                     String dateFile = date.format(dateTimeFormatter);

                                                                                     File file = new File(file3, dateFile);
                                                                                     System.out.println(file.mkdir());


                                                                                     //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                                     File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                                     System.out.println(file4.mkdirs());

                                                                                     System.out.println(file4.delete());

                                                                                     file1.delete();
                                                                                 }


                                                                                 /*
                                                                                 - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                                 - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                                 - `public boolean isFile()` ：此File表示的是否为文件。
                                                                                 - public boolean canRead() ：判断是否可读
                                                                                 - public boolean canWrite() ：判断是否可写
                                                                                 - public boolean isHidden() ：判断是否隐藏
                                                                                  */
                                                                                 @Test
                                                                                 public void test04(){
                                                                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                                     boolean exists = file1.exists();
                                                                                     System.out.println("存在："+exists);

                                                                                     File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                     boolean directory = file2.isDirectory();
                                                                                     System.out.println("文件夹："+directory);
                                                                                     boolean file = file2.isFile();
                                                                                     System.out.println("文件"+file);

                                                                                     boolean b = file2.canRead();
                                                                                     System.out.println("可读"+b);
                                                                                     boolean w = file2.canWrite();
                                                                                     System.out.println("可写"+w);

                                                                                     File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                                     boolean hidden = file3.isHidden();
                                                                                     System.out.println("隐藏："+hidden);
                                                                                 }

                                                                                 /*
                                                                                  * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                                  * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                                  */
                                                                                 @Test
                                                                                 public void test03(){
                                                                                     //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                                     File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                                     String[] list = file.list();
                                                                                     //遍历
                                                                                     for (String s : list) {
                                                                                         System.out.println("名称："+s);
                                                                                     }

                                                                                     //File数组
                                                                                     File[] files = file.listFiles();

                                                                                     for (File file1 : files) {
                                                                                         System.out.println(file1.getName());
                                                                                         System.out.println(file1.getAbsoluteFile());
                                                                                     }


                                                                                 }



                                                                                 /*
                                                                                  * public String getName() ：获取名称
                                                                                  * public String getPath() ：获取路径
                                                                                  * `public String getAbsolutePath()`：获取绝对路径
                                                                                  * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                                  * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                                  * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                                  * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                                  */
                                                                                 @Test
                                                                                 public void test02(){
                                                                                     File file = new File("upload\\a.txt");
                                                                                     System.out.println(file.getName());
                                                                                     String path = file.getPath();
                                                                                     System.out.println(path);
                                                                                     File absoluteFile = file.getAbsoluteFile();
                                                                                     System.out.println(absoluteFile);

                                                                                     File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                     File absoluteFile1 = file1.getAbsoluteFile();
                                                                                     System.out.println(absoluteFile1);
                                                                                     String path1 = file1.getPath();
                                                                                     System.out.println(path1);

                                                                                     //path 使用的是构建路径。
                                                                                     String parent = file1.getParent();
                                                                                     System.out.println("parent:"+parent);

                                                                                     long length = file1.length();
                                                                                     System.out.println("字节："+length);

                                                                                     long l = file1.lastModified();
                                                                                     Date date = new Date(l);
                                                                                     System.out.println(date);

                                                                                     //1.8 转换成时间 ？？？

                                                                                 }

                                                                                 /*
                                                                                 * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                                 * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                                 * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                                 关于路径：
                                                                                 * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                                 * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                                   * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                                   * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                                  */
                                                                                 @Test
                                                                                 public void test01(){
                                                                                     //绝对路径
                                                                                     File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                     //获取名称
                                                                                     System.out.println(file.getName());
                                                                                     //输出
                                                                                     System.out.println(file);

                                                                                     //相对路径
                                                                                     File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                                     //获取名称
                                                                                     System.out.println(file1.getName());
                                                                                     //输出
                                                                                     System.out.println(file1);


                                                                                     //构造  public File(File parent, String child)`
                                                                                     File upload = new File("upload");
                                                                                     File file2 = new File(upload, "b.txt");

                                                                                     //获取名称
                                                                                     System.out.println(file2.getName());
                                                                                     //输出
                                                                                     System.out.println(file2);
                                                                                 }
                                                                             }package com.lc.day17.file1;

                                                                              import org.junit.Test;

                                                                              import java.io.File;
                                                                              import java.io.IOException;
                                                                              import java.time.LocalDate;
                                                                              import java.time.format.DateTimeFormatter;
                                                                              import java.util.Date;

                                                                              /**
                                                                               * ClassName: TestFile
                                                                               * Package: com.lc.day17.file1
                                                                               * Description:
                                                                               *
                                                                               * @Author 爱扣钉-陈晨
                                                                               * @Create 2023/8/5 9:23
                                                                               * @Version 1.0
                                                                               */
                                                                              public class TestFile {


                                                                                  /*
                                                                                  - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                                  - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                                  - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                                  - `public boolean delete()` ：删除文件或者文件夹
                                                                                    删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                                   */
                                                                                  @Test
                                                                                  public void test05() throws IOException {
                                                                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                                      boolean newFile = file1.createNewFile();
                                                                                      System.out.println(newFile);

                                                                                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                                      boolean mkdir = file2.mkdir();
                                                                                      System.out.println(mkdir);

                                                                                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                                      //时间转换
                                                                                      LocalDate date = LocalDate.now();

                                                                                      DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                                      String dateFile = date.format(dateTimeFormatter);

                                                                                      File file = new File(file3, dateFile);
                                                                                      System.out.println(file.mkdir());


                                                                                      //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                                      File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                                      System.out.println(file4.mkdirs());

                                                                                      System.out.println(file4.delete());

                                                                                      file1.delete();
                                                                                  }


                                                                                  /*
                                                                                  - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                                  - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                                  - `public boolean isFile()` ：此File表示的是否为文件。
                                                                                  - public boolean canRead() ：判断是否可读
                                                                                  - public boolean canWrite() ：判断是否可写
                                                                                  - public boolean isHidden() ：判断是否隐藏
                                                                                   */
                                                                                  @Test
                                                                                  public void test04(){
                                                                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                                      boolean exists = file1.exists();
                                                                                      System.out.println("存在："+exists);

                                                                                      File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                      boolean directory = file2.isDirectory();
                                                                                      System.out.println("文件夹："+directory);
                                                                                      boolean file = file2.isFile();
                                                                                      System.out.println("文件"+file);

                                                                                      boolean b = file2.canRead();
                                                                                      System.out.println("可读"+b);
                                                                                      boolean w = file2.canWrite();
                                                                                      System.out.println("可写"+w);

                                                                                      File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                                      boolean hidden = file3.isHidden();
                                                                                      System.out.println("隐藏："+hidden);
                                                                                  }

                                                                                  /*
                                                                                   * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                                   * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                                   */
                                                                                  @Test
                                                                                  public void test03(){
                                                                                      //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                                      File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                                      String[] list = file.list();
                                                                                      //遍历
                                                                                      for (String s : list) {
                                                                                          System.out.println("名称："+s);
                                                                                      }

                                                                                      //File数组
                                                                                      File[] files = file.listFiles();

                                                                                      for (File file1 : files) {
                                                                                          System.out.println(file1.getName());
                                                                                          System.out.println(file1.getAbsoluteFile());
                                                                                      }


                                                                                  }



                                                                                  /*
                                                                                   * public String getName() ：获取名称
                                                                                   * public String getPath() ：获取路径
                                                                                   * `public String getAbsolutePath()`：获取绝对路径
                                                                                   * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                                   * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                                   * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                                   * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                                   */
                                                                                  @Test
                                                                                  public void test02(){
                                                                                      File file = new File("upload\\a.txt");
                                                                                      System.out.println(file.getName());
                                                                                      String path = file.getPath();
                                                                                      System.out.println(path);
                                                                                      File absoluteFile = file.getAbsoluteFile();
                                                                                      System.out.println(absoluteFile);

                                                                                      File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                      File absoluteFile1 = file1.getAbsoluteFile();
                                                                                      System.out.println(absoluteFile1);
                                                                                      String path1 = file1.getPath();
                                                                                      System.out.println(path1);

                                                                                      //path 使用的是构建路径。
                                                                                      String parent = file1.getParent();
                                                                                      System.out.println("parent:"+parent);

                                                                                      long length = file1.length();
                                                                                      System.out.println("字节："+length);

                                                                                      long l = file1.lastModified();
                                                                                      Date date = new Date(l);
                                                                                      System.out.println(date);

                                                                                      //1.8 转换成时间 ？？？

                                                                                  }

                                                                                  /*
                                                                                  * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                                  * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                                  * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                                  关于路径：
                                                                                  * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                                  * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                                    * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                                    * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                                   */
                                                                                  @Test
                                                                                  public void test01(){
                                                                                      //绝对路径
                                                                                      File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                      //获取名称
                                                                                      System.out.println(file.getName());
                                                                                      //输出
                                                                                      System.out.println(file);

                                                                                      //相对路径
                                                                                      File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                                      //获取名称
                                                                                      System.out.println(file1.getName());
                                                                                      //输出
                                                                                      System.out.println(file1);


                                                                                      //构造  public File(File parent, String child)`
                                                                                      File upload = new File("upload");
                                                                                      File file2 = new File(upload, "b.txt");

                                                                                      //获取名称
                                                                                      System.out.println(file2.getName());
                                                                                      //输出
                                                                                      System.out.println(file2);
                                                                                  }
                                                                              }package com.lc.day17.file1;

                                                                               import org.junit.Test;

                                                                               import java.io.File;
                                                                               import java.io.IOException;
                                                                               import java.time.LocalDate;
                                                                               import java.time.format.DateTimeFormatter;
                                                                               import java.util.Date;

                                                                               /**
                                                                                * ClassName: TestFile
                                                                                * Package: com.lc.day17.file1
                                                                                * Description:
                                                                                *
                                                                                * @Author 爱扣钉-陈晨
                                                                                * @Create 2023/8/5 9:23
                                                                                * @Version 1.0
                                                                                */
                                                                               public class TestFile {


                                                                                   /*
                                                                                   - `public boolean createNewFile()` ：创建文件。若文件存在，则不创建，返回false。
                                                                                   - `public boolean mkdir()` ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
                                                                                   - `public boolean mkdirs()` ：创建文件目录。如果上层文件目录不存在，一并创建。
                                                                                   - `public boolean delete()` ：删除文件或者文件夹
                                                                                     删除注意事项：① Java中的删除不走回收站。② 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。
                                                                                    */
                                                                                   @Test
                                                                                   public void test05() throws IOException {
                                                                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");

                                                                                       boolean newFile = file1.createNewFile();
                                                                                       System.out.println(newFile);

                                                                                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\ee");
                                                                                       boolean mkdir = file2.mkdir();
                                                                                       System.out.println(mkdir);

                                                                                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc");

                                                                                       //时间转换
                                                                                       LocalDate date = LocalDate.now();

                                                                                       DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

                                                                                       String dateFile = date.format(dateTimeFormatter);

                                                                                       File file = new File(file3, dateFile);
                                                                                       System.out.println(file.mkdir());


                                                                                       //File file3 = new File("C:\\Users\\erga\\Desktop\\cc");
                                                                                       File file4 = new File("C:\\Users\\erga\\Desktop\\cc\\dd\\ee\\ff");
                                                                                       System.out.println(file4.mkdirs());

                                                                                       System.out.println(file4.delete());

                                                                                       file1.delete();
                                                                                   }


                                                                                   /*
                                                                                   - `public boolean exists()` ：此File表示的文件或目录是否实际存在。
                                                                                   - `public boolean isDirectory()` ：此File表示的是否为目录。
                                                                                   - `public boolean isFile()` ：此File表示的是否为文件。
                                                                                   - public boolean canRead() ：判断是否可读
                                                                                   - public boolean canWrite() ：判断是否可写
                                                                                   - public boolean isHidden() ：判断是否隐藏
                                                                                    */
                                                                                   @Test
                                                                                   public void test04(){
                                                                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\c.txt");
                                                                                       boolean exists = file1.exists();
                                                                                       System.out.println("存在："+exists);

                                                                                       File file2 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                       boolean directory = file2.isDirectory();
                                                                                       System.out.println("文件夹："+directory);
                                                                                       boolean file = file2.isFile();
                                                                                       System.out.println("文件"+file);

                                                                                       boolean b = file2.canRead();
                                                                                       System.out.println("可读"+b);
                                                                                       boolean w = file2.canWrite();
                                                                                       System.out.println("可写"+w);

                                                                                       File file3 = new File("C:\\Users\\erga\\Desktop\\cc\\b.txt");
                                                                                       boolean hidden = file3.isHidden();
                                                                                       System.out.println("隐藏："+hidden);
                                                                                   }

                                                                                   /*
                                                                                    * public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
                                                                                    * public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
                                                                                    */
                                                                                   @Test
                                                                                   public void test03(){
                                                                                       //C:\LoveCoding\VIP-27\学生资料\01_JavaSe

                                                                                       File file = new File("C:\\LoveCoding\\VIP-27\\学生资料\\01_JavaSe");
                                                                                       String[] list = file.list();
                                                                                       //遍历
                                                                                       for (String s : list) {
                                                                                           System.out.println("名称："+s);
                                                                                       }

                                                                                       //File数组
                                                                                       File[] files = file.listFiles();

                                                                                       for (File file1 : files) {
                                                                                           System.out.println(file1.getName());
                                                                                           System.out.println(file1.getAbsoluteFile());
                                                                                       }


                                                                                   }



                                                                                   /*
                                                                                    * public String getName() ：获取名称
                                                                                    * public String getPath() ：获取路径
                                                                                    * `public String getAbsolutePath()`：获取绝对路径
                                                                                    * public File getAbsoluteFile()：获取绝对路径表示的文件
                                                                                    * `public String getParent()`：获取上层文件目录路径。若无，返回null
                                                                                    * public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
                                                                                    * public long lastModified() ：获取最后一次的修改时间，毫秒值
                                                                                    */
                                                                                   @Test
                                                                                   public void test02(){
                                                                                       File file = new File("upload\\a.txt");
                                                                                       System.out.println(file.getName());
                                                                                       String path = file.getPath();
                                                                                       System.out.println(path);
                                                                                       File absoluteFile = file.getAbsoluteFile();
                                                                                       System.out.println(absoluteFile);

                                                                                       File file1 = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                       File absoluteFile1 = file1.getAbsoluteFile();
                                                                                       System.out.println(absoluteFile1);
                                                                                       String path1 = file1.getPath();
                                                                                       System.out.println(path1);

                                                                                       //path 使用的是构建路径。
                                                                                       String parent = file1.getParent();
                                                                                       System.out.println("parent:"+parent);

                                                                                       long length = file1.length();
                                                                                       System.out.println("字节："+length);

                                                                                       long l = file1.lastModified();
                                                                                       Date date = new Date(l);
                                                                                       System.out.println(date);

                                                                                       //1.8 转换成时间 ？？？

                                                                                   }

                                                                                   /*
                                                                                   * `public File(String pathname) ` ：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
                                                                                   * `public File(String parent, String child) ` ：以parent为父路径，child为子路径创建File对象。
                                                                                   * `public File(File parent, String child)` ：根据一个父File对象和子文件路径创建File对象

                                                                                   关于路径：
                                                                                   * **绝对路径：**从盘符开始的路径，这是一个完整的路径。C:
                                                                                   * **相对路径：**相对于`项目目录`的路径，这是一个便捷的路径，开发中经常使用。
                                                                                     * IDEA中，main中的文件的相对路径，是相对于"`当前工程`"  JavaSe
                                                                                     * IDEA中，单元测试方法中的文件的相对路径，是相对于"`当前module`"  day17
                                                                                    */
                                                                                   @Test
                                                                                   public void test01(){
                                                                                       //绝对路径
                                                                                       File file = new File("C:\\Users\\erga\\Desktop\\cc\\a.txt");
                                                                                       //获取名称
                                                                                       System.out.println(file.getName());
                                                                                       //输出
                                                                                       System.out.println(file);

                                                                                       //相对路径
                                                                                       File file1 = new File("upload", "a.txt");// upload\\a.txt
                                                                                       //获取名称
                                                                                       System.out.println(file1.getName());
                                                                                       //输出
                                                                                       System.out.println(file1);


                                                                                       //构造  public File(File parent, String child)`
                                                                                       File upload = new File("upload");
                                                                                       File file2 = new File(upload, "b.txt");

                                                                                       //获取名称
                                                                                       System.out.println(file2.getName());
                                                                                       //输出
                                                                                       System.out.println(file2);
                                                                                   }
                                                                               }