Java 查找模式递归地匹配文件

考虑到下面的

FileRepository

类，在处理500个或更多客户机目录时，如何优化文件搜索。也许我可以使用

流

重新编写以下内容

我需要在第一级查看所有客户目录，然后在下面查看每个客户目录，只考虑昨天的文件夹，类似于

COB02Oct2010

。我已经编写了一个<代码> DateHelper <代码>，以返回这个以前的工作日日期，然后只考虑相关的子目录……然后我查看保存在该目录中的匹配文件模式以获得文件发送。

我可以简单地使用

路径

和

目录流

public class FileRepository {

    public List<File> getFilesToSend(String sourcePath, String pattern, String format) {

        List<File> files = new ArrayList<>();

        File[] customerDir = getCustomerDirs(sourcePath);

        for (int i = 0; i < clientDirs.length; i++) {
            files.addAll(processClientDirectory(clientDirs[i], pattern, format));
        }
        return files;
    }

    private List<File> processClientDirectory(File clientDir, String pattern, String format) {

        List<File> result = new ArrayList<>();

        pattern = pattern.toLowerCase(Locale.ENGLISH);
        format = Constants.EXTENSION_SEPARATOR + format.toLowerCase(Locale.ENGLISH); //add a "."

        File cobDir = new File(clientDir, "COB" + DateHelper.getPreviousWorkingDay());
        getFilesToProcess(result, cobDir, pattern, format);

        return result;
    }

    private void getFilesToProcess(List<File> result, File cobDir, String pattern, String format) {


        if (!cobDir.exists()) {
            return;
        }

        File[] files = cobDir.listFiles(pathName -> {
            if (pathName.isDirectory()) {
                return true;
            }

            if (!pathName.isFile()) {
                return false;
            }

            String name = pathName.getName().toLowerCase(Locale.ENGLISH);
            if (!name.startsWith(pattern)) {
                return false;
            }
            if (!name.endsWith(format)) {
                return false;
            }

            return true;
        });

        for (int i = 0; i < files.length; i++) {
            File current = files[i];
            if (current.isDirectory()) {
                getFilesToProcess(result, current, pattern, format);
                continue;
            }
            result.add(current);
        }
    }

    public File[] getCustomerDirs(String sourcePath) {
        File[] directories = new File(sourcePath).listFiles(File::isDirectory);
        return directories;
    }
}

公共类文件存储库{
公共列表GetFileToSend（字符串源路径、字符串模式、字符串格式）{
列表文件=新的ArrayList（）；
文件[]customerDir=getCustomerDirs（sourcePath）；
for（int i=0；i{
if（路径名.isDirectory（））{
返回true；
}
如果（！pathName.isFile（））{
返回false；
}
String name=pathName.getName（）.toLowerCase（Locale.ENGLISH）；
如果（！name.startsWith（模式））{
返回false；
}
如果（！name.endsWith（格式））{
返回false；
}
返回true；
});
对于（int i=0；i

我不确定如何编写过滤器，例如：

try (DirectoryStream<Path> stream = Files.newDirectoryStream(directoryPath, filter)) {
            for (Path path : stream) {
                if (Files.isRegularFile(path)) {
                    consumer.accept(path);
                }
            }
}

try（DirectoryStream=Files.newDirectoryStream（directoryPath，filter））{
用于（路径：流）{
if（Files.isRegularFile（path））{
consumer.accept（路径）；
}
}
}

以下是我的库提供的示例解决方案：

public List getFilesToSend（字符串源路径、字符串模式、字符串格式）{
最终谓词isTargetFile=f->f.isFile（）
&&N.startWithIgnoreCase（f.getName（），模式）
&&N.endsWithIgnoreCase（f.getName（），“+”格式）；
return Stream.list（新文件（sourcePath））
.filter（文件：：isDirectory）
.map（f->新文件（f，“COB”+getPreviousWorkingDay（））
.flatMap（cobDir->Stream.list（cobDir，true）.filter（isTargetFile））
.toList（）；
}

public List<File> getFilesToSend(String sourcePath, String pattern, String format) {
    final Predicate<File> isTargetFile = f -> f.isFile() 
                                && N.startsWithIgnoreCase(f.getName(), pattern) 
                                && N.endsWithIgnoreCase(f.getName(), "." + format);

    return Stream.list(new File(sourcePath))
            .filter(File::isDirectory)
            .map(f -> new File(f, "COB" + getPreviousWorkingDay()))
            .flatMap(cobDir -> Stream.list(cobDir, true).filter(isTargetFile))
            .toList();
}