Come trovare i file che corrispondono a una stringa jolly in Java?

Questo dovrebbe essere davvero semplice. Se ho una stringa come questa:

../Test?/sample*.txt

allora qual è un modo generalmente accettato per ottenere un elenco di file che corrispondono a questo modello? (ad es. dovrebbe corrispondere ../Test1/sample22b.txte ../Test4/sample-spiffy.txtma non ../Test3/sample2.blaho ../Test44/sample2.txt)

Ho dato un'occhiata org.apache.commons.io.filefilter.WildcardFileFiltere sembra la bestia giusta ma non sono sicuro di come usarlo per trovare i file in un relativo percorso di directory.

Suppongo di poter cercare la fonte per la formica poiché utilizza la sintassi jolly, ma qui mi manca qualcosa di abbastanza ovvio.

( modifica : l'esempio sopra era solo un esempio. Sto cercando il modo di analizzare i percorsi generali contenenti caratteri jolly in fase di esecuzione. Ho capito come farlo sulla base del suggerimento di mmyers ma è un po 'fastidioso. Per non parlare del fatto che JRE JRE sembra analizzare automaticamente i caratteri jolly semplici negli argomenti principali (String []) da un singolo argomento per "risparmiare" tempo e seccature ... Sono solo felice di non avere argomenti non file nel mescolare.)

Prendi in considerazione DirectoryScanner da Apache Ant:

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

Dovrai fare riferimento a ant.jar (~ 1.3 MB per ant 1.7.1).

Prova FileUtilsda Apache commons-io ( listFilese iterateFilesmetodi):

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]);
}

Per risolvere il tuo problema con le TestXcartelle, dovrei prima scorrere l'elenco delle cartelle:

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"));
   }
}

Piuttosto una soluzione "forza bruta" ma dovrebbe funzionare bene. Se ciò non soddisfa le tue esigenze, puoi sempre utilizzare RegexFileFilter .

Ecco alcuni esempi di elenchi di file per modello basato su Java 7 nio globbing e Java 8 lambdas:

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

o

    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));
    }

È possibile convertire la stringa di caratteri jolly in un'espressione regolare e utilizzarla con il matchesmetodo String . Seguendo il tuo esempio:

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

Questo funziona per i tuoi esempi:

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

E contro-esempi:

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

Da Java 8 è possibile utilizzare il Files#findmetodo direttamente da java.nio.file.

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

Esempio di utilizzo

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

Potrebbe non esserti di aiuto in questo momento, ma JDK 7 ha lo scopo di far corrispondere il nome del file glob e regex come parte di "Altre funzionalità NIO".

La libreria di caratteri jolly esegue in modo efficiente la corrispondenza sia del nome glob che regex:

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

L'implementazione è concisa: JAR è solo 12,9 kilobyte.

Modo semplice senza utilizzare alcuna importazione esterna è utilizzare questo metodo

Ho creato file CSV denominati con billing_201208.csv, billing_201209.csv, billing_201210.csv e sembra funzionare bene.

L'output sarà il seguente se esistono file elencati sopra

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

    // Usa Import -> import java.io.File
        public static void main (String [] args) {
        String pathToScan = ".";
        String target_file; // fileThatYouWantToFilter
        File folderToScan = nuovo file (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); 
                }
           }
     }    
}

Come pubblicato in un'altra risposta, la libreria di caratteri jolly funziona sia per la corrispondenza dei nomi glob che regex: http://code.google.com/p/wildcard/

Ho usato il seguente codice per abbinare i pattern glob inclusi i file system assoluti e relativi su * nix style:

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();

Ho impiegato un po 'di tempo a cercare di ottenere i metodi FileUtils.listFiles nella libreria dei comuni di Apache (vedi la risposta di Vladimir) per fare questo, ma non ho avuto successo (mi rendo conto ora / penso che possa gestire solo pattern matching per una directory o un file alla volta) .

Inoltre, l'uso di filtri regex (vedere la risposta di Fabian) per l'elaborazione di schemi glob di tipo assoluto forniti dall'utente arbitrario senza la ricerca dell'intero file system richiederebbe una preelaborazione del glob fornito per determinare il più grande prefisso non regex / glob.

Naturalmente, Java 7 può gestire bene la funzionalità richiesta, ma sfortunatamente sono bloccato con Java 6 per ora. La libreria è relativamente minuscola con dimensioni di 13,5 KB.

Nota per i revisori: ho tentato di aggiungere quanto sopra alla risposta esistente menzionando questa libreria ma la modifica è stata respinta. Non ho abbastanza rappresentante per aggiungere questo come commento. Non c'è un modo migliore ...

Dovresti essere in grado di usare il WildcardFileFilter. Basta usare System.getProperty("user.dir")per ottenere la directory di lavoro. Prova questo:

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

Non è necessario sostituirlo *con [.*], presupponendo che il filtro con caratteri jolly sia utilizzato java.regex.Pattern. Non l'ho provato, ma uso costantemente modelli e filtri di file.

Glob di Java7: ricerca di file . ( Campione )

Il filtro Apache è creato per iterare i file in una directory nota. Per consentire anche i caratteri jolly nella directory, dovresti dividere il percorso su ' \' o ' /' e fare un filtro su ogni parte separatamente.

Perché non usare qualcosa come:

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

// now you have a fully qualified path

Quindi non dovrai preoccuparti dei percorsi relativi e puoi eseguire il jolly secondo necessità.

Implementare l'interfaccia JDK FileVisitor. Ecco un esempio http://wilddiary.com/list-files-matching-a-naming-pattern-java/

Metodo Utile:

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));
        }
    }
}

Produzione:

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);