Directory Scanning with Pattern Matching

Efficiently scan nested directoyr structures while filtering directories at each level using custom pattern matching rules. This approach avoids unnecsesary scans of irrelevant directories in deep folder structures.

1. Directory Filter Implementation

The DirectoryFilter class processes matching rules and validaets directories against hierarchical requirements:

public class DirectoryPatternFilter implements FileFilter {
    private static final String LEVEL_SEPARATOR = "#";
    private final String[] patterns;
    private final int maxDepth;
    private int currentLevel;

    public DirectoryPatternFilter(String patternRules) {
        this.patterns = patternRules.split(LEVEL_SEPARATOR);
        this.maxDepth = patterns.length;
    }

    public void setCurrentLevel(int level) {
        this.currentLevel = level;
    }

    public boolean isFinalLevel() {
        return this.currentLevel == this.maxDepth - 1;
    }

    @Override
    public boolean accept(File directory) {
        if (currentLevel >= maxDepth) {
            return false;
        }
        return directory.isDirectory() && 
               Pattern.compile(patterns[currentLevel]).matcher(directory.getName()).find();
    }
}

2. Core Scanning Logic

The scanner processes directories level by level according to the pattern rules:

public class PatternDirectoryScanner {

    public List<File> scanFiles(String rootPath, String patternRules) {
        File rootDir = new File(rootPath);
        if (rootDir.isDirectory()) {
            List<File> resultFiles = new ArrayList<>();
            DirectoryPatternFilter filter = new DirectoryPatternFilter(patternRules);
            List<File> targetDirs = findMatchingDirectories(rootDir, filter, 0);
            
            for (File dir : targetDirs) {
                File[] files = dir.listFiles(File::isFile);
                if (files != null && files.length > 0) {
                    resultFiles.addAll(Arrays.asList(files));
                }
            }
            return resultFiles;
        }
        return Collections.emptyList();
    }

    private List<File> findMatchingDirectories(File currentDir, 
                                             DirectoryPatternFilter filter,
                                             int currentLevel) {
        List<File> matches = new ArrayList<>();
        if (currentDir.isDirectory()) {
            filter.setCurrentLevel(currentLevel);
            File[] subDirs = currentDir.listFiles(filter);
            
            if (filter.isFinalLevel()) {
                matches.addAll(Arrays.asList(subDirs));
            }
            
            for (File subDir : subDirs) {
                matches.addAll(findMatchingDirectories(subDir, filter, currentLevel + 1));
            }
        }
        return matches;
    }
}

3. Usage Example

public static void main(String[] args) {
    String basePath = "D:/projects";
    String matchingPattern = "src#.*#com.*";
    List<File> matchedFiles = new PatternDirectoryScanner().scanFiles(basePath, matchingPattern);
}