1. 概述

java.io.File 是 Java 中用于表示文件或目录的类。它提供了操作文件和目录的方法，例如创建、删除、重命名等。

File 类中的对象可以用来访问文件的属性，如文件路径、名称、大小等。

File 类的构造方法可以根据不同的参数创建文件对象。常见的构造方法有：

• File(String pathname)：根据文件路径创建文件对象。路径可以是绝对路径或相对路径。

• File(String parent, String child)：根据父路径名字符串和子路径名字符串创建文件对象。父路径和子路径通过拼接而成。

• File(File parent, String child)：根据父路径对应文件对象和子路径名字符串创建文件对象。父路径和子路径通过拼接而成。

File 类提供了多个方法来操作文件和目录，包括：

• 创建和删除文件或目录的方法：createNewFile()、mkdir()、mkdirs()、delete()

• 文件属性的方法：exists()、isFile()、isDirectory()、isHidden()、length()

• 文件信息的方法：getName()、getPath()、getAbsolutePath()、getParent()

2. 构造方法

2.1 方法

File 类的构造方法可以根据不同的参数创建文件对象。

方法名称	说明
public File(String pathname)	根据文件路径创建文件对象
public File(String parent, String child)	根据父路径名字符串和子路径名字符串创建文件对象(拼接)
public File(File parent, String child)	根据父路径对应文件对象和子路径名字符串创建文件对象(拼接)

2.2 代码示例

• 代码示例
  练习：将该路径用文件对象表示：“C:\Users\用户\Desktop\JAVA”

  package text.text03;
  
  import java.io.File;
  
  /*File
  File：File对象表示路径，可以是文件，也可以是文件夹，这个路径可以存在，也可以不存在
  
  绝对路径：带盘符的路径
  相对路径：不带盘符的路径，默认到当前项目下去找
  
  构造方法：
  | 方法名称                                    | 说明                                               |
  | ------------------------------------------- | -------------------------------------------------- |
  | `public File(String pathname) `             | 根据文件路径创建文件对象                           |
  | `public File(String parent, String child) ` | 根据父路径名字符串和子路径名字符串创建文件对象(拼接)     |
  | `public File(File parent, String child)`    | 根据父路径对应文件对象和子路径名字符串创建文件对象(拼接) |
  
  
  练习：将该路径用文件对象表示："C:\Users\用户\Desktop\JAVA"
   */
  public class text01 {
      public static void main(String[] args) {
          //1.`public File(String pathname) `: 根据文件路径创建文件对象
          System.out.println("================1.`public File(String pathname) `: 根据文件路径创建文件对象================");
          String str1 = "C:\\Users\\用户\\Desktop\\JAVA";
          //创建文件对象
          File file1 = new File(str1);
          System.out.println(file1);          //C:\Users\用户\Desktop\JAVA
  
  
          //2.`public File(String parent, String child) `: 根据父路径名字符串和子路径名字符串创建文件对象
          System.out.println("================2.`public File(String parent, String child) `: 根据父路径名字符串和子路径名字符串创建文件对象================");
          String str2 = "C:\\Users\\用户\\Desktop";
          String str3 = "JAVA";
          //创建文件对象
          File file2 = new File(str2, str3);
          System.out.println(file2);        //C:\Users\用户\Desktop\JAVA
  
          //3.`public File(File parent, String child)` : 根据父路径对应文件对象和子路径名字符串创建文件对象
          System.out.println("================3.`public File(File parent, String child)` : 根据父路径对应文件对象和子路径名字符串创建文件对象 ================");
          String str4 = "C:\\Users\\用户\\Desktop";
          //创建文件对象
          File file4 = new File(str4);
          String str5 = "JAVA";
          //创建文件对象
          File file5 = new File(file4, str5);
          System.out.println(file5);        //C:\Users\用户\Desktop\JAVA
  
      }
  }
  
  

• 输出结果
  

3. 成员方法

在 Java 的 java.io.File 类中，有许多有用的成员方法来操作文件和目录。这些方法提供了各种文件系统操作和文件属性的访问。

3.1 判断、获取的方法

3.1.1 方法

方法名称	说明
public boolean isDirectory()	判断此路径名表示的 File 是否为文件夹
public boolean isFile()	判断此路径名表示的 File 是否为文件
public boolean exists()	判断此路径名表示的 File 是否存在
public long length()	返回文件的大小(字节数量)
public String getAbsolutePath()	返回文件的绝对路径
public String getPath()	返回定义文件时使用的路径
public String getName()	返回文件的名称，带后缀
public long lastModified()	返回文件的最后修改时间(时间毫秒值)

注意：

1. public long length() : 返回文件的大小(字节数量)

   • 细节1：这个方法只能获取文件的大小，单位是字节，如果想要M，G，可以不断地除以1024

   • 细节2：这个方法无法获取文件夹的大小，如果想要获取文件夹的大小，需要把整个文件夹里面所有的文件大小累加起来

2. public string getName() : 返回文件的名称，带后缀

   • 细节1：调用者是文件，返回的是文件名+后缀名、扩展名

   • 细节2：调用者是文件夹，返回值是文件夹的名字

3.1.2 代码示例

• 代码示例
  文件夹：D:\QQ
  文件：D:\QQ\QQ.txt
  不存在的文件：D:\QQ\QQQQQQ.txt

  package text.text03;
  
  import java.io.File;
  
  /*File的常见成员方法（判断、获取）
  
  | 方法名称                        | 说明                               |
  | ------------------------------- | ---------------------------------- |
  | public boolean isDirectory()    | 判断此路径名表示的File是否为文件夹 |
  | public boolean isFile()         | 判断此路径名表示的File是否为文件   |
  | public boolean exists()         | 判断此路径名表示的File是否存在     |
  | public long length()            | 返回文件的大小(字节数量)           |
  | public string getAbsolutePath() | 返回文件的绝对路径                 |
  | public string getPath()         | 返回定义文件时使用的路径           |
  | public string getName()         | 返回文件的名称，带后缀             |
  | public long lastModified()      | 返回文件的最后修改时间(时间毫秒值) |
  
  注意：
  1.public long length() : 返回文件的大小(字节数量)
      细节1：这个方法只能获取文件的大小，单位是字节，如果想要M，G，可以不断地除以1024
      细节2：这个方法无法获取文件夹的大小，如果想要获取文件夹的大小，需要把整个文件夹里面所有的文件大小累加起来
  2.public string getName() : 返回文件的名称，带后缀
      细节1：调用者是文件，返回的是文件名+后缀名、扩展名
      细节2：调用者是文件夹，返回值是文件夹的名字
  
      
  文件夹：D:\QQ
  文件：D:\QQ\QQ.txt
  不存在的文件：D:\QQ\QQQQQQ.txt
   */
  public class text02 {
      public static void main(String[] args) {
          //1.public boolean isDirectory() : 判断此路径名表示的File是否为文件夹
          System.out.println("===============1.public boolean isDirectory() : 判断此路径名表示的File是否为文件夹===============");
          //存在的文件夹
          File file1 = new File("D:\\QQ");
          //存在的文件
          File file2 = new File("D:\\QQ\\QQ.txt");
          //不存在的文件
          File file3 = new File("D:\\QQ\\QQQQQQ.txt");
          boolean directory1 = file1.isDirectory();
          boolean directory2 = file2.isDirectory();
          boolean directory3 = file3.isDirectory();
          System.out.println(file1 + "是否为文件夹：" + directory1);  //true
          System.out.println(file2 + "是否为文件夹：" + directory2);  //false
          System.out.println(file3 + "是否为文件夹：" + directory3);  //false
  
  
          System.out.println();
          //2.public boolean isFile() : 判断此路径名表示的File是否为文件
          System.out.println("===============2.public boolean isFile() : 判断此路径名表示的File是否为文件===============");
          //存在的文件夹
          File file4 = new File("D:D:\\QQ");
          //存在的文件
          File file5 = new File("D:\\QQ\\QQ.txt");
          //不存在的文件
          File file6 = new File("D:D:\\QQ\\QQQQQQ.txt");
          boolean isFile1 = file4.isFile();
          boolean isFile2 = file5.isFile();
          boolean isFile3 = file6.isFile();
          System.out.println(file4 + "是否为文件：" + isFile1);     //false
          System.out.println(file5 + "是否为文件：" + isFile2);     //true
          System.out.println(file6 + "是否为文件：" + isFile3);     //false
  
  
          System.out.println();
          //3.public boolean exists()  : 判断此路径名表示的File是否存在
          System.out.println("===============3.public boolean exists()  : 判断此路径名表示的File是否存在===============");
          //存在的文件夹
          File file7 = new File("D:D:\\QQ");
          //存在的文件
          File file8 = new File("D:\\QQ\\QQ.txt");
          //不存在的文件
          File file9 = new File("D:D:\\QQ\\QQQQQQ.txt");
          boolean exists1 = file7.exists();
          boolean exists2 = file8.exists();
          boolean exists3 = file9.exists();
          System.out.println(file7 + "是否为存在：" + exists1);       //false
          System.out.println(file8 + "是否为存在：" + exists2);       //true
          System.out.println(file9 + "是否为存在：" + exists3);       //false
  
  
          System.out.println();
          //4.public long length() : 返回文件的大小(字节数量)
          //细节1：这个方法只能获取文件的大小，单位是字节，如果想要M，G，可以不断地除以1024
          //细节2：这个方法无法获取文件夹的大小，如果想要获取文件夹的大小，需要把整个文件夹里面所有的文件大小累加起来
          System.out.println("===============4.public long length() : 返回文件的大小(字节数量)===============");
          //存在的文件夹
          File file10 = new File("D:D:\\QQ");
          //存在的文件
          File file11 = new File("D:\\QQ\\QQ.txt");
          //不存在的文件
          File file12 = new File("D:D:\\QQ\\QQQQQQ.txt");
          long length1 = file10.length();
          long length2 = file11.length();
          long length3 = file12.length();
          System.out.println(file10 + "的文件大小是：" + length1);  //0
          System.out.println(file11 + "的文件大小是：" + length2);  //27
          System.out.println(file12 + "的文件大小是：" + length3);  //0
  
  
          System.out.println();
          //5.public string getAbsolutePath() : 返回文件的绝对路径
          System.out.println("===============5.public string getAbsolutePath() : 返回文件的绝对路径===============");
          //存在的文件夹
          File file13 = new File("D:D:\\QQ");
          //存在的文件
          File file14 = new File("D:\\QQ\\QQ.txt");
          //不存在的文件
          File file15 = new File("D:D:\\QQ\\QQQQQQ.txt");
          String absolutePath1 = file13.getAbsolutePath();
          String absolutePath2 = file14.getAbsolutePath();
          String absolutePath3 = file15.getAbsolutePath();
          System.out.println(file13 + "文件的绝对路径是：" + absolutePath1);    //D:\JavaCode\code\D:\QQ
          System.out.println(file14 + "文件的绝对路径是：" + absolutePath2);    //D:\QQ\QQ.txt
          System.out.println(file15 + "文件的绝对路径是：" + absolutePath3);    //D:\JavaCode\code\D:\QQ\QQQQQQ.txt
  
  
          System.out.println();
          //6.public string getPath() : 返回定义文件时使用的路径
          System.out.println("===============6.public string getPath() : 返回定义文件时使用的路径===============");
          //存在的文件夹
          File file16 = new File("D:D:\\QQ");
          //存在的文件
          File file17 = new File("D:\\QQ\\QQ.txt");
          //不存在的文件
          File file18 = new File("D:D:\\QQ\\QQQQQQ.txt");
          String path1 = file16.getPath();
          String path2 = file17.getPath();
          String path3 = file18.getPath();
          System.out.println(file16 + "定义文件时使用的路径是：" + path1);  //D:D:\QQ
          System.out.println(file17 + "定义文件时使用的路径是：" + path2);  //D:\QQ\QQ.txt
          System.out.println(file18 + "定义文件时使用的路径是：" + path3);  //D:D:\QQ\QQQQQQ.txt
  
  
          System.out.println();
          //7.public string getName() : 返回文件的名称，带后缀
          //细节1：调用者是文件，返回的是文件名+后缀名、扩展名
          //细节2：调用者是文件夹，返回值是文件夹的名字
          System.out.println("===============7.public string getName() : 返回文件的名称，带后缀===============");
          //存在的文件夹
          File file19 = new File("D:D:\\QQ");
          //存在的文件
          File file20 = new File("D:\\QQ\\QQ.txt");
          //不存在的文件
          File file21 = new File("D:D:\\QQ\\QQQQQQ.txt");
          String name1 = file19.getName();
          String name2 = file20.getName();
          String name3 = file21.getName();
          System.out.println(file19 + "文件的名称，带后缀为：" + name1);    //QQ
          System.out.println(file20 + "文件的名称，带后缀为：" + name2);    //QQ.txt
          System.out.println(file21 + "文件的名称，带后缀为：" + name3);    //QQQQQQ.txt
  
  
          System.out.println();
          //8.public long lastModified() : 返回文件的最后修改时间(时间毫秒值)
          System.out.println("===============8.public long lastModified() : 返回文件的最后修改时间(时间毫秒值)===============");
          //存在的文件夹
          File file22 = new File("D:D:\\QQ");
          //存在的文件
          File file23 = new File("D:\\QQ\\QQ.txt");
          //不存在的文件
          File file24 = new File("D:D:\\QQ\\QQQQQQ.txt");
          long time1 = file22.lastModified();
          long time2 = file23.lastModified();
          long time3 = file24.lastModified();
          System.out.println(file22 + "文件的最后修改时间(时间毫秒值)为：" + time1);   //0
          System.out.println(file23 + "文件的最后修改时间(时间毫秒值)为：" + time2);   //1707927977267
          System.out.println(file24 + "文件的最后修改时间(时间毫秒值)为：" + time3);   //0
          /*
          //删除文件
          file1.delete();
          file2.delete();
          file3.delete();
          file4.delete();
          file5.delete();
          file6.delete();
          file7.delete();
          file8.delete();
          file9.delete();
          file10.delete();
          file11.delete();
          file12.delete();
          file13.delete();
          file14.delete();
          file15.delete();
          file16.delete();
          file17.delete();
          file18.delete();
          file19.delete();
          file20.delete();
          file21.delete();
          file22.delete();
          file23.delete();
          file24.delete();
          */
  
      }
  }
  
  

• 输出结果

  • 1.public boolean isDirectory() : 判断此路径名表示的File是否为文件夹
    

  • 2.public boolean isFile() : 判断此路径名表示的File是否为文件
    

  • 3.public boolean exists() : 判断此路径名表示的File是否存在
    

  • 4.public long length() : 返回文件的大小(字节数量)
    

  • 5.public string getAbsolutePath() : 返回文件的绝对路径
    

  • 6.public string getPath() : 返回定义文件时使用的路径
    

  • 7.public string getName() : 返回文件的名称，带后缀
    

  • 8.public long lastModified() : 返回文件的最后修改时间(时间毫秒值)
    

3.2 创建、删除的方法

3.2.1 方法

方法名称	说明
public boolean createNewFile()	创建一个新的空文件
public boolean mkdir()	创建单级文件夹
public boolean mkdirs()	创建多级文件夹
public boolean delete()	删除文件或空文件夹

注意：

1. public boolean createNewFile() : 创建一个新的空的文件

   • 细节1:如果当前路径表示的文件是不存在的，则创建成功，方法返回true
     如果当前路径表示的文件是存在的，则创建失败，方法返回false

   • 细节2:如果父级路径是不存在的，那么方法会有常IOException

   • 细节3:createNewFile方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件

2. public boolean mkdir() : 创建单级文件夹

   • 细节1:windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false

   • 细节2:mkdir方法只能创建单级文件夹，无法创建多级文件夹。

3. public boolean mkdirs() : 创建多级文件夹

   • 细节:既可以创建单级的，又可以创建多级的文件夹

4. public boolean delete() : 删除文件、空文件夹

   • 细节

     • 如果删除的是文件，则直接删除，不走回收站。

     • 如果删除的是空文件夹，则直接删除，不走回收站

     • 如果删除的是有内容的文件夹，则删除失败

3.2.2 代码示例

• 代码示例

  package text.text03;
  
  import java.io.File;
  import java.io.IOException;
  
  /* File的常见成员方法（创建、删除）
  
  | 方法名称                       | 说明                 |
  | ------------------------------ | -------------------- |
  | public boolean createNewFile() | 创建一个新的空的文件 |
  | public boolean mkdir()         | 创建单级文件夹       |
  | public boolean mkdirs()        | 创建多级文件夹       |
  | public boolean delete()        | 删除文件、空文件夹   |
  
  注意：
  1.public boolean createNewFile() : 创建一个新的空的文件
      细节1:如果当前路径表示的文件是不存在的，则创建成功，方法返回true
           如果当前路径表示的文件是存在的，则创建失败，方法返回false
      细节2:如果父级路径是不存在的，那么方法会有常IOException
      细节3:createNewFile方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件
  2.public boolean mkdir() : 创建单级文件夹
      细节1:windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false
      细节2:mkdir方法只能创建单级文件夹，无法创建多级文件夹。
  3.public boolean mkdirs() : 创建多级文件夹
      细节:既可以创建单级的，又可以创建多级的文件夹
  4.public boolean delete() : 删除文件、空文件夹
  细节:如果删除的是文件，则直接删除，不走回收站。
      如果删除的是空文件夹，则直接删除，不走回收站
      如果删除的是有内容的文件夹，则删除失败
  
   */
  public class text03 {
      public static void main(String[] args) throws IOException {
          //1.public boolean createNewFile() : 创建一个新的空的文件
          //细节1:如果当前路径表示的文件是不存在的，则创建成功，方法返回true
          //     如果当前路径表示的文件是存在的，则创建失败，方法返回false
          //细节2:如果父级路径是不存在的，那么方法会有常IOException
          //细节3:createNewFile方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件
          System.out.println("===============1.public boolean createNewFile() : 创建一个新的空的文件===============");
          //不存在的文件
          File file1 = new File("D:\\WW");
          //存在的文件
          File file2 = new File("D:\\QQ\\QQ.txt");
          boolean newFile1 = file1.createNewFile();
          boolean newFile2 = file2.createNewFile();
          System.out.println(file1 + " 一个新的空的文件是否成功被创建：" + newFile1);      //true
          System.out.println(file2 + " 一个新的空的文件是否成功被创建：" + newFile2);      //false
  
  
          System.out.println();
          //2.public boolean mkdir() : 创建单级文件夹
          //细节1:windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false
          //细节2:mkdir方法只能创建单级文件夹，无法创建多级文件夹。
          System.out.println("===============2.public boolean mkdir() : 创建单级文件夹===============");
          //单级文件夹
          File file3 = new File("D:\\MM");
          //多级文件夹
          File file4 = new File("D:\\WW\\QQ\\LL");
          boolean mkdir1 = file3.mkdir();
          boolean mkdir2 = file4.mkdir();
          System.out.println(file3 + "单级文件夹是否成功被创建：" + mkdir1);      //true
          System.out.println(file4 + "单级文件夹是否成功被创建：" + mkdir2);      //false
  
  
          System.out.println();
          //3.public boolean mkdirs() : 创建多级文件夹
          //细节:既可以创建单级的，又可以创建多级的文件夹
          System.out.println("===============3.public boolean mkdirs() : 创建多级文件夹===============");
          //单级文件夹
          File file5 = new File("D:\\NN");    //true
          //多级文件夹
          File file6 = new File("D:\\QQ\\QQ");   //true
          boolean mkdirs1 = file5.mkdirs();
          boolean mkdirs2 = file6.mkdirs();
          System.out.println(file5 + "多级文件夹是否成功被创建：" + mkdirs1);
          System.out.println(file6 + "多级文件夹是否成功被创建：" + mkdirs2);
  
  
          System.out.println();
          //4.public boolean delete() : 删除文件、空文件夹
          //细节:如果删除的是文件，则直接删除，不走回收站。
          //    如果删除的是空文件夹，则直接删除，不走回收站
          //    如果删除的是有内容的文件夹，则删除失败
          System.out.println("===============4.public boolean delete() : 删除文件、空文件夹===============");
          boolean delete1 = file1.delete();
          boolean delete2 = file2.delete();
          boolean delete3 = file3.delete();
          boolean delete4 = file4.delete();
          boolean delete5 = file5.delete();
          boolean delete6 = file6.delete();
          System.out.println(file1 + "是否成功被删除：" + delete1);  //true
          System.out.println(file2 + "是否成功被删除：" + delete2);  //true
          System.out.println(file3 + "是否成功被删除：" + delete3);  //true
          System.out.println(file4 + "是否成功被删除：" + delete4);  //false
          System.out.println(file5 + "是否成功被删除：" + delete5);  //true
          System.out.println(file6 + "是否成功被删除：" + delete6);  //true
      }
  }
  
  

• 输出结果
  

3.3 获取、遍历的方法

3.3.1 重点方法

3.3.1.1 方法

方法名称	说明
public File[] listFiles()	返回一个 File 数组，表示该 File 目录中的所有的子文件或目录的对象

• 作用：获取文件夹里面的所有内容，包括隐藏的文件或文件夹，把所有的内容放到数组中返回

注意：

• 细节1：当调用者File表示的路径不存在时，返回null

• 细节2：当调用者File表示的路径是文件时，返回nul

• 细节3：当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组

• 细节4：当调用者File表示的路径是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回

• 细节5：当调用者File表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件

• 细节6：当调用者File表示的路径是需要权限才能访问的文件夹时，返回null

3.3.1.2 代码示例

• 代码示例
  文件夹：D:\QQ

  package text.text03;
  
  import java.io.File;
  
  /*File的常见成员方法（获取并遍历）（重点）
  
  | 方法名称                    | 说明                                                   |
  | --------------------------- | ------------------------------------------------------ |
  | `public File[] listFiles()` | 返回一个File数组，表示该File目录中的所有的子文件或目录 |
  
  作用：获取文件夹里面的所有内容，包括隐藏的文件或文件夹，把所有的内容放到数组中返回
  
  注意：
      细节1：当调用者File表示的路径不存在时，返回null
      细节2：当调用者File表示的路径是文件时，返回nul
      细节3：当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组
      细节4：当调用者File表示的路径是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
      细节5：当调用者File表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
      细节6：当调用者File表示的路径是需要权限才能访问的文件夹时，返回null
  
  文件夹：D:\QQ
   */
  public class text04 {
      public static void main(String[] args) {
          //创建文件对象
          File file = new File("D:\\QQ");
          //调用listFiles()方法
          //细节1：当调用者File表示的路径不存在时，返回null
          //细节2：当调用者File表示的路径是文件时，返回nul
          //细节3：当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组
          //细节4：当调用者File表示的路径是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
          //细节5：当调用者File表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
          //细节6：当调用者File表示的路径是需要权限才能访问的文件夹时，返回null
          File[] files = file.listFiles();
          //遍历File[]数组
          for (File f : files) {
              System.out.println(f);
          }
      }
  }
  
  

• 输出结果
  

3.3.2 所有方法

3.3.2.1 方法

方法名称	说明
public static File[] listRoots()	列出可用的文件系统根（获取系统中所有的盘符）
public String[] list()	获取当前路径下的所有内容的名称，仅返回名称而不是完整路径
public String[] list(FilenameFilter filter)	获取当前路径下满足文件名过滤器条件的所有内容的名称
public File[] listFiles()	获取当前路径下的所有内容的 File 对象，包括文件和文件夹
public File[] listFiles(FileFilter filter)	获取当前路径下满足文件过滤器条件的所有内容的 File 对象
public File[] listFiles(FilenameFilter filter)	获取当前路径下满足文件名过滤器条件的所有内容的 File 对象

FilenameFilter 是一个接口，用于过滤文件名，FileFilter 是一个接口，用于过滤文件和文件夹。

注意：

1. public string[] list(FilenameFilter filter) ：利用文件名过滤器获取当前该路径下所有内容
   • 细节1：FilenameFilter是一个函数式接口，里面重写的accept方法的形参，依次表示该文件夹里面得到每一个文件或者文件夹的路径
     • 参数一：父级路径文件对象
     • 参数二：子级路径
     • 返回值：
       • 如果返回值是true，就表示当前路劲保留；
       • 如果返回值是false，就表示当前路径舍弃不要。

3.3.2.2 代码示例

• 代码示例
  文件夹：D:\QQ

  package text.text03;
  
  import java.io.File;
  import java.io.FileFilter;
  import java.io.FilenameFilter;
  import java.util.Arrays;
  
  /*File的常见成员方法(获取并遍历)（所有）
  
  | 方法名称                                       | 说明                                     |
  | ---------------------------------------------- | ---------------------------------------- |
  | public static File[] listRoots()               | 列出可用的文件系统根(获取系统中所有的盘符)                     |
  | public string[] list()                         | 获取当前该路径下所有内容(仅仅能获取名字)                 |
  | public string[] list(FilenameFilter filter)    | 利用文件名过滤器获取当前该路径下所有内容 |
  | public File[] listFiles()                      | 获取当前该路径下所有内容                 |
  | public File[] listFiles(FileFilter filter)     | 利用文件名过滤器获取当前该路径下所有内容 |
  | public File[] listFiles(FilenameFilter filter) | 利用文件名过滤器获取当前该路径下所有内容 |
  
  注意：
    1.public string[] list(FilenameFilter filter) ：利用文件名过滤器获取当前该路径下所有内容
      细节1：FilenameFilter是一个函数式接口，里面重写的accept方法的形参，依次表示该文件夹里面得到每一个文件或者文件夹的路径
            参数一：父级路径文件对象
            参数二：子级路径
            返回值：如果返回值是true，就表示当前路劲保留；
                   如果返回值是false，就表示当前路径舍弃不要。
  
  文件夹：D:\QQ
   */
  public class text05 {
      public static void main(String[] args) {
          //1.public static File[] listRoots() :列出可用的文件系统根(获取系统中所有的盘符)
          System.out.println("================1.public static File[] listRoots() :列出可用的文件系统根(获取系统中所有的盘符)================");
          File[] files1 = File.listRoots();
          System.out.println("系统中所有的盘符为：" + Arrays.toString(files1));   //[C:\, D:\]
  
  
          System.out.println();
          //2.public string[] list():获取当前该路径下所有内容(仅仅能获取名字)
          System.out.println("================2.public string[] list():获取当前该路径下所有内容(仅仅能获取名字)================");
          File file1 = new File("D:\\QQ");
          String[] list1 = file1.list();
          System.out.println(file1 + "路径下所有内容为：" + Arrays.toString(list1));
  
  
          System.out.println();
          //3.public string[] list(FilenameFilter filter) :利用文件名过滤器获取当前该路径下所有内容
          System.out.println("================3.public string[] list(FilenameFilter filter) :利用文件名过滤器获取当前该路径下所有内容================");
          File file2 = new File("D:\\QQ");
          //获取文件后缀为.txt的文件
          String[] list2 = file2.list(new FilenameFilter() {
              @Override
              //参数一：父级路径文件对象
              //参数二：子级路径
              //返回值：如果返回值是true，就表示当前路劲保留；
              //       如果返回值是false，就表示当前路径舍弃不要。
  
              public boolean accept(File dir, String name) {
                  File file = new File(dir, name);
                  return file.isFile() && file.getName().endsWith(".txt");
              }
          });
          System.out.println(file2 + "路径下所有文件后缀为.txt的文件为：" + Arrays.toString(list2));   //[QQ.txt, QQWhatsnew.txt]
  
  
          System.out.println();
          //4.public File[] listFiles() :获取当前该路径下所有内容
          System.out.println("================4.public File[] listFiles() :获取当前该路径下所有内容================");
          //重点内容，在D:\JavaCode\code\codeText01\src\text\text03\text04.java中
  
          System.out.println();
          //5.public File[] listFiles(FileFilter filter):利用文件名过滤器获取当前该路径下所有内容
          System.out.println("================5.public File[] listFiles(FileFilter filter):利用文件名过滤器获取当前该路径下所有内容================");
          File file3 = new File("D:\\QQ");
          //获取文件后缀为.txt的文件
          File[] files2 = file3.listFiles(new FileFilter() {
              @Override
              public boolean accept(File pathname) {
                  return pathname.isFile() && pathname.getName().endsWith(".txt");
              }
          });
          System.out.println(file3 + "路径下所有文件后缀为.txt的文件为：" + Arrays.toString(files2));  //[D:\QQ\QQ.txt, D:\QQ\QQWhatsnew.txt]
  
  
          System.out.println();
          //6.public File[] listFiles(FilenameFilter filter):利用文件名过滤器获取当前该路径下所有内容
          System.out.println("================6.public File[] listFiles(FilenameFilter filter):利用文件名过滤器获取当前该路径下所有内容================");
          File file4 = new File("D:\\QQ");
          //获取文件后缀为.txt的文件
          File[] files = file4.listFiles(new FilenameFilter() {
              @Override
              public boolean accept(File dir, String name) {
                  File file = new File(dir, name);
                  return file.isFile() && file.getName().endsWith(".txt");
              }
          });
          System.out.println(file4 + "路径下所有文件后缀为.txt的文件为：" + Arrays.toString(files));      //[D:\QQ\QQ.txt, D:\QQ\QQWhatsnew.txt]
  
      }
  }
  
  

• 输出结果
  

4. 代码示例

套路：

1. 进入文件夹

2. 遍历数组

3. 判断（判断是否为文件）

4. 判断（判断是否为文件夹）

4.1 示例1：创建文件夹

需求：在当前模块下的aaa文件夹中创建一个a.txt文件

• 代码示例

  package text.text03;
  
  import java.io.File;
  import java.io.IOException;
  
  /*练习1：创建文件夹
  
  需求：在当前模块下的aaa文件夹中创建一个a.txt文件
   */
  public class text06 {
      public static void main(String[] args) throws IOException {
          //创建a.txt的父级路径
          File file = new File("codeText01\\aaa");
          //创建父级路径
          boolean mkdir = file.mkdir();
          //将父级路径与子级路径进行拼接
          File file1 = new File(file, "a.txt");
          //创建文件
          boolean newFile = file1.createNewFile();
          if (newFile) {
              System.out.println("创建成功！路径为：" + file1);
          } else {
              System.out.println("创建失败！该文件已经存在，路径为：" + file1);
          }
      }
  }
  
  

• 输出结果
  

4.2 示例2：查找文件（不考虑子文件夹）

需求：定义一个方法找某一个文件夹中，是否有以avi结尾的电影（暂时不需要考虑子文件夹）

• 代码示例

  package text.text03;
  
  import java.io.File;
  
  /* 练习2：查找文件（不考虑子文件夹）
  
  需求：定义一个方法找某一个文件夹中，是否有以avi结尾的电影（暂时不需要考虑子文件夹）
   */
  public class text07 {
      public static void main(String[] args) {
          //创建文件
          File file = new File("D:\\QQ");
          //调用方法
          boolean b = haveAvi(file);
          if (b) {
              System.out.println("存在以avi结尾的电影");
          } else {
              System.out.println("不存在以avi结尾的电影");
          }
      }
  
      //方法
      public static boolean haveAvi(File file) {
          File[] files = file.listFiles();
          //遍历文件数组
          for (File f : files) {
              if (f.isFile() && f.getName().endsWith(".avi")) {
                  return true;
              }
          }
          return false;
      }
  }
  

• 输出结果
  

4.3 示例3：查找文件（考虑子文件夹）

需求：找到电脑中所有以avi结尾的电影。（需要考虑子文件夹）

• 代码示例

  package text.text03;
  
  import java.io.File;
  
  /* 练习3：查找文件（考虑子文件夹）
  
  需求：找到电脑中所有以avi结尾的电影。（需要考虑子文件夹）
  
  思想：把大问题拆分，拆到某一个文件夹中不包含其他文件夹为止
  
  套路：1.进入文件夹
       2.遍历数组
       3.判断
       4.判断
   */
  public class text08 {
      public static void main(String[] args) {
          findDrive();
      }
  
      //创建方法，获取所有的盘符
      public static void findDrive() {
          //获取所有的盘符
          File[] files = File.listRoots();
          //遍历数组
          for (File file : files) {
              haveAvi(file);
          }
      }
  
      //创建方法，判断该盘符中是否含有以avi结尾的电影
      public static void haveAvi(File file) {
          //进入文件夹（将该文件夹的所有的内容存入文件数组）
          File[] files = file.listFiles();
          //因为调用listFiles()方法，当盘符中有隐藏的文件或文件夹时，会null
          if (files != null) {
              //遍历数组
              for (File f : files) {
                  //判断该内容是文件
                  if (f.isFile()) {
                      //判断是否为avi结尾的电影
                      if (f.getName().endsWith(".avi")) {
                          System.out.println(f);
                      }
                  }
                  //判断该内容是文件夹
                  else {
                      //递归调用haveAvi方法
                      haveAvi(f);
                  }
              }
          }
      }
  
  }
                       
  

• 输出结果
  

4.4 示例4：删除多级文件夹

练习4：删除多级文件夹

• 代码示例

  package text.text03;
  
  import java.io.File;
  
  /*练习4：删除多级文件夹
  
  思路： 如果我们要删除一个有内容的文件夹
  	   1.先删除文件夹里面所有的内容
         2.再删除自己
  
  套路：1.进入文件夹
       2.遍历数组
       3.判断
       4.判断
   */
  public class text09 {
      public static void main(String[] args) {
          //创建文件对象
          File file = new File("D:\\File\\file");
          entry(file);
      }
  
      //创建进入文件夹的方法
      public static void entry(File file) {
          //创建文件数组
          File[] files = file.listFiles();
          //遍历数组
          for (File file1 : files) {
              //判断，如果是文件，直接删除
              if (file1.isFile()) {
                  boolean delete = file1.delete();
                  System.out.println(delete);
              }
              //判断，如果是文件夹，递归调用
              else {
                  entry(file1);
              }
          }
          //删除本文件夹
          boolean delete = file.delete();
          System.out.println(delete);
      }
  }
  
  

• 输出结果
  

4.5 示例5：统计一个文件夹的总大小

练习5：统计一个文件夹的总大小

• 代码示例

  package text.text03;
  
  import java.io.File;
  
  /*
  练习5：统计一个文件夹的总大小
   */
  public class text10 {
      public static void main(String[] args) {
          //创建文件对象
          File file = new File("D:\\QQ");
          //调用方法
          long len = getLen(file);
          System.out.println(file + "文件夹的总大小为：" + len);
      }
      /*
      * 作用：
      *       统计一个文件夹的总大小
      * 参数：
      *       表示要统计的那个文件夹
      * 返回值：
      *       统计之后的结果
      *
      * 文件夹的总大小：
      *       文件夹里面所有文件的大小
       */
  
      public static long getLen(File file) {
          //定义变量记录总大小
          long sum = 0;
          //创建数组（进入文件夹）
          File[] files = file.listFiles();
          //因为调用listFiles()方法，当盘符中有隐藏的文件或文件夹时，会null
          if (files != null) {
              //遍历数组
              for (File file1 : files) {
                  //判断是否为文件，是则计算大小
                  if (file1.isFile()) {
                      sum = sum + file1.length();
                  }
                  //判断是否为文件夹，是则递归
                  else {
                      //必须有变量来接受递归后方法返回的值
                      sum = sum + getLen(file1);
                  }
              }
          }
          return sum;
      }
  }
  

• 输出结果
  

4.6 示例6：统计大小

需求：统计一个文件夹的总个数并进行打印

• 格式如下：
  • txt:几个
  • doc:几个
  • pg:几个
• 代码示例

  package text.text03;
  
  import java.io.File;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Set;
  
  /* 练习6：统计大小
  
  需求：统计一个文件夹的总个数并进行打印
      格式如下：txt:几个
              doc:几个
              jpg:几个
  
  思路：File + 递归 + Map集合
   */
  public class text11 {
      public static void main(String[] args) {
          File file = new File("D:\\File\\file");
          HashMap<String, Integer> hashMap = getSum(file);
          System.out.println(hashMap);
          //遍历hashMap集合
          Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
          for (Map.Entry<String, Integer> entry : entries) {
              String key = entry.getKey();
              int value = entry.getValue();
              System.out.println(key + " : " + value + "个");
          }
      }
  
  
      /*
       * 作用：
       *       统计一个文件夹中每种文件的个数
       * 参数：
       *       要统计的那个文件夹
       * 返回值：
       *       用来统计map集合
       *       键：后缀名 值：次数
       *
       *       a.txt
       *       a.a.txt
       *       aaa（不需要统计的）
       *
       *
       * */
      public static HashMap<String, Integer> getSum(File file) {
          //创建Map集合，键为：文件后缀；值为：个数
          HashMap<String, Integer> hm = new HashMap<>();
  
          //创建File对象数组
          File[] files = file.listFiles();
  
          //遍历数组
          for (File file1 : files) {
  
              //判断file1是文件还是文件夹
              if (file1.isFile()) {    //如果是文件，则判断后缀名，并统计个数
                  //将文件名字通过 . 进行分割，获取后缀名
                  String[] split = file1.getName().split("\\.");
                  if (split.length >= 2) { //如果split.length==1，则表明没有后缀名，不需要统计
                      //获取后缀名
                      String getName = split[split.length - 1];
  
                      //判断hm集合中是否存在该后缀名
                      if (hm.containsKey(getName)) {    //如果存在，则获取集合值的值，获取该后缀名的数量并+1
                          //获取集合的值
                          int count = hm.get(getName);
                          //将值+1
                          count++;
                          //重新添加进集合
                          hm.put(getName, count);
                      } else {     //如果不存在，则添加进集合
                          hm.put(getName, 1);
                      }
                  }
              }
              //如果是文件夹，则递归调用
              else {
                  HashMap<String, Integer> fileHM = getSum(file1);  //必须有集合来接收文件夹中的后缀名的数量
  
                  //将文件夹中的后缀名数量添加进hm集合
                  //遍历fileHM集合
                  Set<Map.Entry<String, Integer>> entries = fileHM.entrySet();
                  for (Map.Entry<String, Integer> entry : entries) {
                      //获取fileHM集合的键
                      String key = entry.getKey();
                      //获取fileHM集合的值
                      int value = entry.getValue();
  
                      //将fileHM集合中键的值添加进hm中
                      //判断fileHM集合中的后缀名是否在hm集合中存在
                      if (hm.containsKey(key)) {     //存在，在hm中将该后缀名的数量添加上fileHM的数量
                          //获取hm中该后缀名的数量
                          int count = hm.get(key);
                          count = count + value;
                          hm.put(key, count);
                      } else {   //不存在，则将fileHM的该后缀名以及数量添加进hm集合
                          hm.put(key, value);
                      }
                  }
              }
          }
          return hm;
      }
  }
  
  

• 输出结果
  

5. 注意事项

1. 路径分隔符：在不同的操作系统中，路径分隔符可以是不同的。

   例如，在Windows系统中使用反斜杠（\）作为路径分隔符，在Linux和Mac系统中使用正斜杠（/）作为路径分隔符。为了确保跨平台兼容性，可以使用 File.separator 来代替硬编码的路径分隔符。

2. 文件权限：在进行文件操作时，要注意文件的权限设置。确保你的程序具有足够的权限来读取、写入或执行文件。否则，在运行时可能会出现 SecurityException 异常。

3. 文件并发访问：多个线程或多个程序同时对同一个文件进行并发读写可能导致数据损坏或不一致。在进行并发文件访问时，需要采取适当的同步机制（如使用锁或同步块）来确保数据一致性。

4. 文件路径有效性检查：在创建或访问文件之前，应始终进行路径有效性检查。可以使用 exists() 方法检查文件或目录是否存在，以及 isDirectory() 和 isFile() 方法检查路径表示的是目录还是文件。

5. 错误处理：在文件操作过程中，可能会发生许多异常情况，如文件不存在、无法读取或写入文件等。确保在代码中适当地捕获和处理这些异常，以提供适当的用户反馈或执行后续操作。