Jak znaleźć pliki, które pasują do ciągu znaków wieloznacznych w Javie?

To powinno być naprawdę proste. Jeśli mam taki ciąg:

../Test?/sample*.txt

w takim razie jaki jest ogólnie akceptowany sposób uzyskania listy plików pasujących do tego wzorca? (np powinna pasować ../Test1/sample22b.txti ../Test4/sample-spiffy.txtale nie ../Test3/sample2.blahlub ../Test44/sample2.txt)

Przyjrzałem się i wygląda na org.apache.commons.io.filefilter.WildcardFileFilterto, że jest to właściwa bestia, ale nie jestem pewien, jak go użyć do wyszukiwania plików w względnej ścieżce katalogu.

Przypuszczam, że mogę poszukać źródła mrówki, ponieważ używa ona składni symboli wieloznacznych, ale chyba brakuje mi tutaj czegoś dość oczywistego.

( edycja : powyższy przykład to tylko przykładowy przypadek. Szukam sposobu na przeanalizowanie ogólnych ścieżek zawierających symbole wieloznaczne w czasie wykonywania. Zorientowałem się, jak to zrobić na podstawie sugestii mmyersów, ale jest to trochę denerwujące. Nie wspominając o tym) JRE java wydaje się automatycznie analizować proste symbole wieloznaczne w głównym (argumenty String []) z pojedynczego argumentu, aby "zaoszczędzić" czas i kłopoty ... Cieszę się, że nie mam argumentów niebędących plikami w mieszać.)

Rozważ DirectoryScanner z Apache Ant:

DirectoryScanner scanner = new DirectoryScanner();
scanner.setIncludes(new String[]{"**/*.java"});
scanner.setBasedir("C:/Temp");
scanner.setCaseSensitive(false);
scanner.scan();
String[] files = scanner.getIncludedFiles();

Będziesz musiał odwołać się do ant.jar (~ 1,3 MB dla ant 1.7.1).

Wypróbuj FileUtilsz Apache commons-io ( listFilesi iterateFilesmetody):

File dir = new File(".");
FileFilter fileFilter = new WildcardFileFilter("sample*.java");
File[] files = dir.listFiles(fileFilter);
for (int i = 0; i < files.length; i++) {
   System.out.println(files[i]);
}

Aby rozwiązać problem z TestXfolderami, najpierw przejrzałbym listę folderów:

File[] dirs = new File(".").listFiles(new WildcardFileFilter("Test*.java");
for (int i=0; i<dirs.length; i++) {
   File dir = dirs[i];
   if (dir.isDirectory()) {
       File[] files = dir.listFiles(new WildcardFileFilter("sample*.java"));
   }
}

Całkiem rozwiązanie typu „brutalna siła”, ale powinno działać dobrze. Jeśli to nie odpowiada Twoim potrzebom, zawsze możesz użyć RegexFileFilter .

Oto przykłady listowania plików według wzorca obsługiwanego przez globbing Java 7 nio i lambdy Java 8:

    try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(
            Paths.get(".."), "Test?/sample*.txt")) {
        dirStream.forEach(path -> System.out.println(path));
    }

lub

    PathMatcher pathMatcher = FileSystems.getDefault()
        .getPathMatcher("regex:Test./sample\\w+\\.txt");
    try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(
            new File("..").toPath(), pathMatcher::matches)) {
        dirStream.forEach(path -> System.out.println(path));
    }

Możesz przekonwertować swój ciąg znaków wieloznacznych na wyrażenie regularne i użyć go z matchesmetodą String . Idąc za twoim przykładem:

String original = "../Test?/sample*.txt";
String regex = original.replace("?", ".?").replace("*", ".*?");

To działa dla twoich przykładów:

Assert.assertTrue("../Test1/sample22b.txt".matches(regex));
Assert.assertTrue("../Test4/sample-spiffy.txt".matches(regex));

I kontrprzykłady:

Assert.assertTrue(!"../Test3/sample2.blah".matches(regex));
Assert.assertTrue(!"../Test44/sample2.txt".matches(regex));

Od Java 8 możesz używać Files#findmetody bezpośrednio z java.nio.file.

public static Stream<Path> find(Path start,
                                int maxDepth,
                                BiPredicate<Path, BasicFileAttributes> matcher,
                                FileVisitOption... options)

Przykładowe użycie

Files.find(startingPath,
           Integer.MAX_VALUE,
           (path, basicFileAttributes) -> path.toFile().getName().matches(".*.pom")
);

Może ci to teraz nie pomóc, ale JDK 7 ma dopasować nazwy plików glob i wyrażeń regularnych w ramach „Więcej funkcji NIO”.

Biblioteka symboli wieloznacznych wydajnie dopasowuje zarówno nazwy plików glob, jak i wyrażeń regularnych:

http://code.google.com/p/wildcard/

Wdrożenie jest zwięzłe - JAR ma tylko 12,9 kilobajta.

Prostym sposobem bez użycia zewnętrznego importu jest użycie tej metody

Utworzyłem pliki csv o nazwach billing_201208.csv, billing_201209.csv, billing_201210.csv i wygląda na to, że działają dobrze.

Dane wyjściowe będą następujące, jeśli pliki wymienione powyżej istnieją

found billing_201208.csv
found billing_201209.csv
found billing_201210.csv

    // Użyj importu -> importuj java.io.File
        public static void main (String [] args) {
        String pathToScan = ".";
        String target_file; // fileThatYouWantToFilter
        Plik folderToScan = nowy plik (pathToScan); 


    File[] listOfFiles = folderToScan.listFiles();

     for (int i = 0; i < listOfFiles.length; i++) {
            if (listOfFiles[i].isFile()) {
                target_file = listOfFiles[i].getName();
                if (target_file.startsWith("billing")
                     && target_file.endsWith(".csv")) {
                //You can add these files to fileList by using "list.add" here
                     System.out.println("found" + " " + target_file); 
                }
           }
     }    
}

Jak napisano w innej odpowiedzi, biblioteka symboli wieloznacznych działa zarówno w przypadku dopasowywania nazw plików glob, jak i wyrażeń regularnych: http://code.google.com/p/wildcard/

Użyłem następującego kodu, aby dopasować wzorce glob, w tym bezwzględne i względne w systemach plików w stylu * nix:

String filePattern = String baseDir = "./";
// If absolute path. TODO handle windows absolute path?
if (filePattern.charAt(0) == File.separatorChar) {
    baseDir = File.separator;
    filePattern = filePattern.substring(1);
}
Paths paths = new Paths(baseDir, filePattern);
List files = paths.getFiles();

Spędziłem trochę czasu próbując uzyskać metody FileUtils.listFiles w bibliotece Apache commons io (zobacz odpowiedź Vladimira), aby to zrobić, ale bez powodzenia (teraz zdaję sobie sprawę / myślę, że może obsługiwać tylko wzorce pasujące do jednego katalogu lub pliku na raz) .

Dodatkowo, użycie filtrów wyrażeń regularnych (patrz odpowiedź Fabiana) do przetwarzania dowolnych wzorców glob typu absolutnego dostarczonych przez użytkownika bez przeszukiwania całego systemu plików wymagałoby pewnego wstępnego przetworzenia dostarczonego globu w celu określenia największego prefiksu innego niż wyrażenia regularne / glob.

Oczywiście Java 7 może ładnie obsłużyć żądaną funkcjonalność, ale niestety na razie utknąłem w Javie 6. Biblioteka jest stosunkowo malutka i ma rozmiar 13,5 kb.

Uwaga dla recenzentów: próbowałem dodać powyższe do istniejącej odpowiedzi wspominającej o tej bibliotece, ale zmiana została odrzucona. Nie mam wystarczającej liczby przedstawicieli, aby dodać to jako komentarz. Czy nie ma lepszego sposobu ...

Powinieneś być w stanie użyć WildcardFileFilter. Po prostu użyj, System.getProperty("user.dir")aby uzyskać katalog roboczy. Spróbuj tego:

public static void main(String[] args) {
File[] files = (new File(System.getProperty("user.dir"))).listFiles(new WildcardFileFilter(args));
//...
}

Nie powinieneś zastępować *go [.*], zakładając, że używany jest filtr wieloznaczny java.regex.Pattern. Nie testowałem tego, ale stale używam wzorców i filtrów plików.

Glob of Java7: Finding Files . ( Próbka )

Filtr Apache jest zbudowany w celu iteracji plików w znanym katalogu. Aby zezwolić na używanie symboli wieloznacznych również w katalogu, musisz podzielić ścieżkę na „ \” lub „ /” i wykonać filtr dla każdej części osobno.

Dlaczego nie użyć, zrób coś takiego:

File myRelativeDir = new File("../../foo");
String fullPath = myRelativeDir.getCanonicalPath();
Sting wildCard = fullPath + File.separator + "*.txt";

// now you have a fully qualified path

Wtedy nie będziesz musiał martwić się o ścieżki względne i w razie potrzeby możesz użyć symboli wieloznacznych.

Zaimplementuj interfejs JDK FileVisitor. Oto przykład http://wilddiary.com/list-files-matching-a-naming-pattern-java/

Metoda użytkowa:

public static boolean isFileMatchTargetFilePattern(final File f, final String targetPattern) {
        String regex = targetPattern.replace(".", "\\.");  //escape the dot first
        regex = regex.replace("?", ".?").replace("*", ".*");
        return f.getName().matches(regex);

    }

Test jUnit:

@Test
public void testIsFileMatchTargetFilePattern()  {
    String dir = "D:\\repository\\org\my\\modules\\mobile\\mobile-web\\b1605.0.1";
    String[] regexPatterns = new String[] {"_*.repositories", "*.pom", "*-b1605.0.1*","*-b1605.0.1", "mobile*"};
    File fDir = new File(dir);
    File[] files = fDir.listFiles();

    for (String regexPattern : regexPatterns) {
        System.out.println("match pattern [" + regexPattern + "]:");
        for (File file : files) {
            System.out.println("\t" + file.getName() + " matches:" + FileUtils.isFileMatchTargetFilePattern(file, regexPattern));
        }
    }
}

Wynik:

match pattern [_*.repositories]:
    mobile-web-b1605.0.1.pom matches:false
    mobile-web-b1605.0.1.war matches:false
    _remote.repositories matches:true
match pattern [*.pom]:
    mobile-web-b1605.0.1.pom matches:true
    mobile-web-b1605.0.1.war matches:false
    _remote.repositories matches:false
match pattern [*-b1605.0.1*]:
    mobile-web-b1605.0.1.pom matches:true
    mobile-web-b1605.0.1.war matches:true
    _remote.repositories matches:false
match pattern [*-b1605.0.1]:
    mobile-web-b1605.0.1.pom matches:false
    mobile-web-b1605.0.1.war matches:false
    _remote.repositories matches:false
match pattern [mobile*]:
    mobile-web-b1605.0.1.pom matches:true
    mobile-web-b1605.0.1.war matches:true
    _remote.repositories matches:false

Path testPath = Paths.get("C:\");

Stream<Path> stream =
                Files.find(testPath, 1,
                        (path, basicFileAttributes) -> {
                            File file = path.toFile();
                            return file.getName().endsWith(".java");
                        });

// Print all files found
stream.forEach(System.out::println);