java文件夹递归操作工具类

零：功能总结

        本工具类实现的主要功能有：

        递归查找某一路径下的所有文件名     
        递归查找某一路径下的所有文件名并进行去重    
        递归查找某一路径下指定类型的所有文件名     
        递归查找某一路径下匹配文件类型的所有文件名（去重）        
        递归查找某一路径下的所有文件数量    
        递归统计某一路径下所有指定文件类型的数量        
        递归删除某一路径下所有文件（包括该文件夹以及所有文件夹）        

一、工具类源码

源码如下：

package test;

/**
 * @Description
 * @Author LiTong(Prode)
 * @Data 2023/10/10 14:34
 */

import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class FileListerUtils {

    /**
     * @Description 递归查找某一路径下的所有文件名
     * @Author LiTong(Prode)
     * @Date 2023/10/10 15:00
     **/
    
    public static List<String> listAllFiles(String folderPath) {
        List<String> fileList = new ArrayList<>();

        // 创建一个File对象，表示要查找的文件夹
        File folder = new File(folderPath);

        // 检查文件夹是否存在
        if (folder.exists() && folder.isDirectory()) {
            // 获取文件夹中的所有文件和子文件夹
            File[] files = folder.listFiles();

            if (files != null) {
                for (File file : files) {
                    // 判断当前项是否为文件
                    if (file.isFile()) {
                        // 添加文件名到列表中
                        fileList.add(file.getName());
                    } else if (file.isDirectory()) {
                        // 如果是文件夹，递归调用listAllFiles方法来获取子文件夹中的文件名
                        List<String> subFolderFiles = listAllFiles(file.getAbsolutePath());
                        fileList.addAll(subFolderFiles);
                    }
                }
            }
        } else {
            fileList.add("文件夹不存在或不是一个文件夹");
        }
        return fileList;
    }
    /**
     * @Description  递归查找某一路径下的所有文件名并进行去重
     * @Author LiTong(Prode)
     * @Date 2023/10/10 15:36
     **/
    public static Set<String> listUniqueFiles(String folderPath) {
        Set<String> uniqueFileNames = new HashSet<>();

        // 创建一个File对象，表示要查找的文件夹
        File folder = new File(folderPath);

        // 检查文件夹是否存在
        if (folder.exists() && folder.isDirectory()) {
            // 获取文件夹中的所有文件和子文件夹
            File[] files = folder.listFiles();

            if (files != null) {
                for (File file : files) {
                    // 判断当前项是否为文件
                    if (file.isFile()) {
                        // 添加文件名到Set集合中
                        uniqueFileNames.add(file.getName());
                    } else if (file.isDirectory()) {
                        // 如果是文件夹，递归调用listUniqueFiles方法来获取子文件夹中的不重复文件名
                        Set<String> subFolderFiles = listUniqueFiles(file.getAbsolutePath());
                        uniqueFileNames.addAll(subFolderFiles);
                    }
                }
            }
        } else {
            uniqueFileNames.add("文件夹不存在或不是一个文件夹");
        }
        return uniqueFileNames;
    }
    /**
     * @Description  递归查找某一路径下指定类型的所有文件名
     * @Author LiTong(Prode)
     * @Date 2023/10/10 15:03
     **/
    public static List<String> listAllFiles(String folderPath, final String fileType) {
        List<String> fileList = new ArrayList<>();

        // 创建一个File对象，表示要查找的文件夹
        File folder = new File(folderPath);

        // 检查文件夹是否存在
        if (folder.exists() && folder.isDirectory()) {
            // 获取文件夹中的所有文件和子文件夹
            File[] files = folder.listFiles();

            if (files != null) {
                for (File file : files) {
                    // 判断当前项是否为文件
                    if (file.isFile()) {
                        // 判断文件名是否以指定的文件类型结尾
                        if (file.getName().endsWith(fileType)) {
                            // 添加符合条件的文件名到列表中
                            fileList.add(file.getName());
                        }
                    } else if (file.isDirectory()) {
                        // 如果是文件夹，递归调用listFilesByType方法来获取子文件夹中的文件名
                        List<String> subFolderFiles = listAllFiles(file.getAbsolutePath(), fileType);
                        fileList.addAll(subFolderFiles);
                    }
                }
            }
        } else {
            fileList.add("文件夹不存在或不是一个文件夹");
        }
        return fileList;
    }
    /**
     * @Description  递归查找某一路径下匹配文件类型的所有文件名（去重）
     * @Author LiTong(Prode)
     * @Date 2023/10/10 15:38 
     **/
    public static Set<String> listFilesByTypeWithSet(String folderPath, String fileType) {
        Set<String> uniqueFileNames = new HashSet<>();

        // 创建一个File对象，表示要查找的文件夹
        File folder = new File(folderPath);

        // 检查文件夹是否存在
        if (folder.exists() && folder.isDirectory()) {
            // 获取文件夹中的所有文件和子文件夹
            File[] files = folder.listFiles();

            if (files != null) {
                for (File file : files) {
                    // 判断当前项是否为文件
                    if (file.isFile()) {
                        // 判断文件名是否以指定的文件类型结尾
                        if (file.getName().endsWith(fileType)) {
                            // 添加符合条件的文件名到Set集合中
                            uniqueFileNames.add(file.getName());
                        }
                    } else if (file.isDirectory()) {
                        // 如果是文件夹，递归调用listFilesByTypeWithSet方法来获取子文件夹中的不重复文件名
                        Set<String> subFolderFiles = listFilesByTypeWithSet(file.getAbsolutePath(), fileType);
                        uniqueFileNames.addAll(subFolderFiles);
                    }
                }
            }
        } else {
            uniqueFileNames.add("文件夹不存在或不是一个文件夹");
        }

        return uniqueFileNames;
    }
    /**
     * @Description  递归查找某一路径下的所有文件数量
     * @Author LiTong(Prode)
     * @Date 2023/10/10 15:04
     **/
    public static int countFiles(String folderPath) {
        int fileCount = 0;

        // 创建一个File对象，表示要统计的文件夹
        File folder = new File(folderPath);

        // 检查文件夹是否存在
        if (folder.exists() && folder.isDirectory()) {
            // 获取文件夹中的所有文件和子文件夹
            File[] files = folder.listFiles();

            if (files != null) {
                for (File file : files) {
                    // 判断当前项是否为文件
                    if (file.isFile()) {
                        // 如果是文件，增加文件计数
                        fileCount++;
                    } else if (file.isDirectory()) {
                        // 如果是文件夹，递归调用countFiles方法来获取子文件夹中的文件数量
                        fileCount += countFiles(file.getAbsolutePath());
                    }
                }
            }
        }
        return fileCount;
    }
    /**
     * @Description  递归统计某一路径下所有指定文件类型的数量
     * @Author LiTong(Prode)
     * @Date 2023/10/10 15:46 
     **/
    public static int countFilesByType(String folderPath, String fileType) {
        int fileCount = 0;

        // 创建一个File对象，表示要统计的文件夹
        File folder = new File(folderPath);

        // 检查文件夹是否存在
        if (folder.exists() && folder.isDirectory()) {
            // 获取文件夹中的所有文件和子文件夹
            File[] files = folder.listFiles();

            if (files != null) {
                for (File file : files) {
                    // 判断当前项是否为文件
                    if (file.isFile()) {
                        // 判断文件名是否以指定的文件类型结尾
                        if (file.getName().endsWith(fileType)) {
                            // 增加文件计数
                            fileCount++;
                        }
                    } else if (file.isDirectory()) {
                        // 如果是文件夹，递归调用countFilesByType方法来获取子文件夹中的文件数量
                        fileCount += countFilesByType(file.getAbsolutePath(), fileType);
                    }
                }
            }
        }
        return fileCount;
    }

    /**
     * @Description  递归删除某一路径下所有文件（包括该文件夹以及所有文件夹）
     * @Author LiTong(Prode)
     * @Date 2023/10/10 15:45 
     **/
    public static boolean deleteFolder(String folderPath) {
        // 创建一个File对象，表示要删除的文件夹
        File folder = new File(folderPath);

        // 检查文件夹是否存在
        if (folder.exists() && folder.isDirectory()) {
            // 获取文件夹中的所有文件和子文件夹
            File[] files = folder.listFiles();

            if (files != null) {
                for (File file : files) {
                    // 判断当前项是否为文件
                    if (file.isFile()) {
                        // 删除文件
                        file.delete();
                    } else if (file.isDirectory()) {
                        // 如果是文件夹，递归调用deleteFolder方法来删除子文件夹及其内容
                        deleteFolder(file.getAbsolutePath());
                    }
                }
            }

            // 删除空文件夹
            folder.delete();
            return true;
        } else {
            return false;
        }
    }
}

二、调用方式

调用方式如下： 

package test;

import com.test.Documentsutils;

/**
 * @Description
 * @Author LiTong(Prode)
 * @Data 2023/7/25 10:47
 */
public class Test05 {
    public static void main(String[] args) {

        Documentsutils documentsutils = new Documentsutils();

        String folderPath = "C:\\Users\\lenovo\\Desktop\\A002"; // 替换为你的文件夹路径
        // 指定要统计的文件类型（扩展名）
        String fileType = ".pig"; // 替换为你要统计的文件类型

        //递归查找某一路径下的所有文件名
        documentsutils.listAllFiles(folderPath);
        //递归查找某一路径下的所有文件名并进行去重
        documentsutils.listUniqueFiles(folderPath);
        //递归查找某一路径下指定类型的所有文件名
        documentsutils.listAllFiles(folderPath,fileType);
        //递归查找某一路径下匹配文件类型的所有文件名（去重）
        documentsutils.listFilesByTypeWithSet(folderPath,fileType);
        //递归查找某一路径下的所有文件数量
        documentsutils.countFiles(folderPath);
        //递归统计某一路径下所有指定文件类型的数量
        documentsutils.countFilesByType(folderPath,fileType);
        //递归删除某一路径下所有文件（包括该文件夹以及所有文件夹）
        documentsutils.deleteFolder(folderPath);


    }
}

三、实现效果

1. 递归查找某一路径下的所有文件名（去重）。

可以看到，这两个方法都只需要将文件路径作为参数传入，第一次输出为所有的文件名，第二次输出为去重后的文件名。

2. 递归查找某一路径下指定类型的所有文件名（去重）。

可以看到，这两个方法需要将文件夹路径和文件类型（扩展名）作为参数传入，第一个方法统计出所有符合文件类型的文件名，第二个方法统出所有符合文件类型的文件名后进行了去重。

3. 递归统计某一路径下的所有文件(指定类型)数量。

可以看到，第一个方法统计出了所有的文件数量，第二个方法则统计出了所有指定类型“.pig”文件的数量，为了便于展示放在了单一文件夹下，此方法也支持递归查找某文件路径下所有的文件数量。