How to Find Files That Match a Wildcard String in Java

How to find files that match a wildcard string in Java?

Consider DirectoryScanner from Apache Ant:

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

You'll need to reference ant.jar (~ 1.3 MB for ant 1.7.1).

How to use a Wildcard in Java filepath

I don't think that it's possible to use wildcard in such way. I propose you to use a way like this for your task:

    File orig = new File("\test\orig");
    File[] directories = orig.listFiles(new FileFilter() {
      public boolean accept(File pathname) {
        return pathname.isDirectory();
      }
    });
    ArrayList<File> files = new ArrayList<File>();
    for (File directory : directories) {
        File file = new File(directory, "test.zip");
        if (file.exists())
            files.add(file);
    }
    System.out.println(files.toString());

how to find wildcard folders search in java 1.7 or in 8

Assuming you have following directory structure

/tmp/usr/local/bar/test1/fol1
/tmp/usr/local/baz/test2/fol2
/tmp/usr/local/foo/test3/fol3
/tmp/usr/local/foobar/test/fol
/tmp/usr/local/foobar/test/dummy
/tmp/usr/local/foobar/dummy

A possible solution for Java 7+ might be

import java.io.IOException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitOption;
import java.nio.file.FileVisitResult;
import static java.nio.file.FileVisitResult.CONTINUE;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.EnumSet;

public class FindWalkFileTree {

    public static class Finder implements FileVisitor<Path> {
        private final PathMatcher matcher;

        Finder(String pattern) {
            final FileSystem fs = FileSystems.getDefault();
            matcher = fs.getPathMatcher("glob:" + pattern);
        }

        void find(Path file) {
            if (matcher.matches(file)) {
                System.out.format("%s%n", file);
            }
        }

        @Override
        public FileVisitResult visitFile(Path file, 
                BasicFileAttributes attrs) {
            find(file);
            return CONTINUE;
        }

        @Override
        public FileVisitResult postVisitDirectory(Path dir, 
                IOException exc) {
            return CONTINUE;
        }

        @Override
        public FileVisitResult visitFileFailed(Path file, IOException exc) {
            return CONTINUE;
        }

        @Override
        public FileVisitResult preVisitDirectory(Path dir, 
                BasicFileAttributes attrs) throws IOException {
            find(dir);
            return CONTINUE;
        }
    }

    public static void main(String[] args) throws IOException {
        Path searchDir = Paths.get("/tmp/usr/local");
        String pattern = "/tmp/usr/local/*/test*/fol*";
        EnumSet<FileVisitOption> opts = EnumSet.of(
                FileVisitOption.FOLLOW_LINKS);
        Finder finder = new Finder(pattern);
        Files.walkFileTree(searchDir, opts, Integer.MAX_VALUE, finder);
    }
}

A possible Java 8 solution might be

import java.io.File;
import java.io.IOException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitOption;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.util.stream.Stream;

public class FindWalk {

    public static void main(String[] args) throws IOException {
        File dataDir = new File("/tmp/usr/local");
        FileSystem fs = FileSystems.getDefault();
        String pattern = "/tmp/usr/local/*/test*/fol*";
        PathMatcher pathMatcher = fs.getPathMatcher("glob:" + pattern);
        FileVisitOption opts = FileVisitOption.FOLLOW_LINKS;
        try (Stream<Path> stream = Files.walk(dataDir.toPath(), opts)) {
            stream.filter(pathMatcher::matches)
                    .forEach(System.out::println);
        }
    }
}

output for both solutions

/tmp/usr/local/bar/test1/fol1
/tmp/usr/local/baz/test2/fol2
/tmp/usr/local/foo/test3/fol3
/tmp/usr/local/foobar/test/fol

The processing always starts from directory /tmp/usr/local/.

How to use wildcards in filenames when reading in files

Try FileUtils from Apache commons-io (listFiles and iterateFiles methods):
The code you need is

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

How to check a file if exists with wildcard in Java?

Pass a FileFilter (coded here anonymously) into the listFiles() method of the dir File, like this:

File dir = new File("some/path/to/dir");
final String id = "XXX"; // needs to be final so the anonymous class can use it
File[] matchingFiles = dir.listFiles(new FileFilter() {
    public boolean accept(File pathname) {
        return pathname.getName().equals("a_id_" + id + ".zip");
    }
});

Bundled as a method, it would look like:

public static File[] findFilesForId(File dir, final String id) {
    return dir.listFiles(new FileFilter() {
        public boolean accept(File pathname) {
            return pathname.getName().equals("a_id_" + id + ".zip");
        }
    });
}

and which you could call like:

File[] matchingFiles = findFilesForId(new File("some/path/to/dir"), "XXX");

or to simply check for existence,

boolean exists = findFilesForId(new File("some/path/to/dir"), "XXX").length > 0

Listing files in a directory matching a pattern in Java

See File#listFiles(FilenameFilter).

File dir = new File(".");
File [] files = dir.listFiles(new FilenameFilter() {
    @Override
    public boolean accept(File dir, String name) {
        return name.endsWith(".xml");
    }
});

for (File xmlfile : files) {
    System.out.println(xmlfile);
}

In Scala find files that match a wildcard String

scala> import reflect.io._, Path._
import reflect.io._
import Path._

scala> val r = """.*\.scala""".r
r: scala.util.matching.Regex = .*\.scala

scala> "/home/amarki/tmp".toDirectory.files map (_.name) flatMap { case n @ r() => Some(n) case _ => None }
res0: Iterator[String] = non-empty iterator

scala> .toList
res1: List[String] = List(bobsrandom.scala, ...)

or recursing

scala> import PartialFunction.{ cond => when }
import PartialFunction.{cond=>when}

scala> "/home/amarki/tmp" walkFilter (p => p.isDirectory || when(p.name) {
     | case r() => true })
res3: Iterator[scala.reflect.io.Path] = non-empty iterator

List all Files from a Directory that match a File Mask (a.k.a Pattern or Glob)

I think I might have solved my own question with the insight received here and other questions mentioning the PathMatcher object

final PathMatcher maskMatcher = FileSystems.getDefault()
                  .getPathMatcher("glob:" + mask);

final List<Path> matchedFiles = Files.walk(path)
                  .collect(Collectors.toList());

final List<Path> filesToRemove = new ArrayList<>(matchedFiles.size());

matchedFiles.forEach(foundPath -> {
            if (!maskMatcher.matches(foundPath.getFileName()) || Files.isDirectory(foundPath)) {
              filesToRemove.add(foundPath);
            }
          });

 matchedFiles.removeAll(filesToRemove);

So basically .getPathMatcher("glob:" + mask); is the same thing that the DirectoryStream was doing to filter the files

All I have to do now after that is filtering the list of paths that I get with Files.walk by removing the elements that do not match my PathMatcher and are not of type File

---

Related Topics