it-swarm.com.de

Finden Sie Dateien in einem Ordner mit Java

Was muss ich tun, wenn ein Ordner durchsucht wird, sagen Sie C:\example

Ich muss dann jede Datei durchgehen und überprüfen, ob sie mit einigen Startzeichen übereinstimmt, also ob die Dateien starten

temp****.txt
tempONE.txt
tempTWO.txt

Wenn die Datei also mit temp beginnt und die Erweiterung .txt hat, möchte ich diesen Dateinamen in eine File file = new File("C:/example/temp***.txt); setzen, damit ich die Datei dann lesen kann. Die Schleife muss dann zur nächsten Datei wechseln, um zu sehen, ob sie vorhanden ist trifft sich wie oben.

40
Sii

Was Sie wollen, ist File.listFiles(FileNameFilter filter) .

Dadurch erhalten Sie eine Liste der Dateien in dem gewünschten Verzeichnis, die einem bestimmten Filter entsprechen.

Der Code sieht ähnlich aus:

// your directory
File f = new File("C:\\example");
File[] matchingFiles = f.listFiles(new FilenameFilter() {
    public boolean accept(File dir, String name) {
        return name.startsWith("temp") && name.endsWith("txt");
    }
});
65
jjnguy

Sie können einen FilenameFilter wie folgt verwenden:

File dir = new File(directory);

File[] matches = dir.listFiles(new FilenameFilter()
{
  public boolean accept(File dir, String name)
  {
     return name.startsWith("temp") && name.endsWith(".txt");
  }
});
30
Mia Clarke

Ich weiß, das ist eine alte Frage. Aber nur der Vollständigkeit halber die Lambda-Version. 

File dir = new File(directory);
File[] files = dir.listFiles((dir1, name) -> name.startsWith("temp") && name.endsWith(".txt"));
9
pan

Betrachten Sie Apache Commons IO. Es hat eine Klasse namens FileUtils , die eine listFiles -Methode hat, die in Ihrem Fall sehr nützlich sein kann.

3
Waleed Madanat

Schau dir Java.io.File.list() und FilenameFilter an.

3
jhouse

Zum Auflisten von Json-Dateien aus dem angegebenen Verzeichnis.

import Java.io.File;
    import Java.io.FilenameFilter;

    public class ListOutFilesInDir {
        public static void main(String[] args) throws Exception {

            File[] fileList = getFileList("directory path");

            for(File file : fileList) {
                System.out.println(file.getName());
            }
        }

        private static File[] getFileList(String dirPath) {
            File dir = new File(dirPath);   

            File[] fileList = dir.listFiles(new FilenameFilter() {
                public boolean accept(File dir, String name) {
                    return name.endsWith(".json");
                }
            });
            return fileList;
        }
    }
2

Wie @ Clarke sagte, können Sie Java.io.FilenameFilter verwenden, um die Datei nach bestimmten Bedingungen zu filtern. 

Ergänzend möchte ich Ihnen zeigen, wie Sie mit Java.io.FilenameFilter nach Dateien im aktuellen Verzeichnis und dessen Unterverzeichnis suchen.

Die üblichen Methoden getTargetFiles und printFiles werden verwendet, um Dateien zu suchen und zu drucken.

public class SearchFiles {

    //It's used in dfs
    private Map<String, Boolean> map = new HashMap<String, Boolean>();

    private File root;

    public SearchFiles(File root){
        this.root = root;
    }

    /**
     * List eligible files on current path
     * @param directory
     *      The directory to be searched
     * @return
     *      Eligible files
     */
    private String[] getTargetFiles(File directory){
        if(directory == null){
            return null;
        }

        String[] files = directory.list(new FilenameFilter(){

            @Override
            public boolean accept(File dir, String name) {
                // TODO Auto-generated method stub
                return name.startsWith("Temp") && name.endsWith(".txt");
            }

        });

        return files;
    }

    /**
     * Print all eligible files
     */
    private void printFiles(String[] targets){
        for(String target: targets){
            System.out.println(target);
        }
    }
}

Ich werde demonstrieren, wie man rekursiv , bfs und dfs verwendet, um die Arbeit zu erledigen.

Rekursiv :

    /**
 * How many files in the parent directory and its subdirectory <br>
 * depends on how many files in each subdirectory and their subdirectory
 */
private void recursive(File path){

    printFiles(getTargetFiles(path));
    for(File file: path.listFiles()){
        if(file.isDirectory()){
            recursive(file);
        }
    }
    if(path.isDirectory()){
        printFiles(getTargetFiles(path));
    }
}

public static void main(String args[]){
    SearchFiles searcher = new SearchFiles(new File("C:\\example"));
    searcher.recursive(searcher.root);
}

Breite erste Suche :

/**
 * Search the node's neighbors firstly before moving to the next level neighbors
 */
private void bfs(){
    if(root == null){
        return;
    }

    Queue<File> queue = new LinkedList<File>();
    queue.add(root);

    while(!queue.isEmpty()){
        File node = queue.remove();
        printFiles(getTargetFiles(node));
        File[] childs = node.listFiles(new FileFilter(){

            @Override
            public boolean accept(File pathname) {
                // TODO Auto-generated method stub
                if(pathname.isDirectory())
                    return true;

                return false;
            }

        });

        if(childs != null){
            for(File child: childs){
                queue.add(child);
            }
        }
    }
}

public static void main(String args[]){
    SearchFiles searcher = new SearchFiles(new File("C:\\example"));
    searcher.bfs();
}

Tiefe erste Suche :

/** * Suchen Sie so lange wie möglich in jedem Zweig, bevor Sie zurückgehen */ private void dfs () {

    if(root == null){
        return;
    }

    Stack<File> stack = new Stack<File>();
    stack.Push(root);
    map.put(root.getAbsolutePath(), true);
    while(!stack.isEmpty()){
        File node = stack.peek();
        File child = getUnvisitedChild(node);

        if(child != null){
            stack.Push(child);
            printFiles(getTargetFiles(child));
            map.put(child.getAbsolutePath(), true);
        }else{
            stack.pop();
        }

    }
}

/**
 * Get unvisited node of the node
 * 
 */
private File getUnvisitedChild(File node){

    File[] childs = node.listFiles(new FileFilter(){

        @Override
        public boolean accept(File pathname) {
            // TODO Auto-generated method stub
            if(pathname.isDirectory())
                return true;

            return false;
        }

    });

    if(childs == null){
        return null;
    }

    for(File child: childs){

        if(map.containsKey(child.getAbsolutePath()) == false){
            map.put(child.getAbsolutePath(), false);
        }

        if(map.get(child.getAbsolutePath()) == false){
            return child; 
        }
    }

    return null;
}

public static void main(String args[]){
    SearchFiles searcher = new SearchFiles(new File("C:\\example"));
    searcher.dfs();
}
2
Gearon

Apache Commons IO verschiedene

FilenameUtils.wildcardMatch

Siehe Apache Javadoc hier . Es stimmt den Platzhalter mit dem Dateinamen überein. Sie können diese Methode also für Ihre Vergleiche verwenden.

1
eugene

Ab Java 1.8 können Sie Files.list verwenden, um einen Stream abzurufen:

Path findFile(Path targetDir, String fileName) throws IOException {
    return Files.list(targetDir).filter( (p) -> {
        if (Files.isRegularFile(p)) {
            return p.getFileName().toString().equals(fileName);
        } else {
            return false;
        }
    }).findFirst().orElse(null);
}
1
Ted

Um auf diese Antwort einzugehen, kann Apache IO Utils Ihnen etwas Zeit sparen. Betrachten Sie das folgende Beispiel, das rekursiv nach einer Datei mit einem bestimmten Namen sucht:

    File file = FileUtils.listFiles(new File("the/desired/root/path"), 
                new NameFileFilter("filename.ext"), 
                FileFilterUtils.trueFileFilter()
            ).iterator().next();

Sehen:

0
Kyle

Sie geben den Namen Ihrer Datei und den Pfad des zu durchsuchenden Verzeichnisses an und lassen den Job erledigen.

private static String getPath(String drl, String whereIAm) {
    File dir = new File(whereIAm); //StaticMethods.currentPath() + "\\src\\main\\resources\\" + 
    for(File e : dir.listFiles()) {
        if(e.isFile() && e.getName().equals(drl)) {return e.getPath();}
        if(e.isDirectory()) {
            String idiot = getPath(drl, e.getPath());
            if(idiot != null) {return idiot;}
        }
    }
    return null;
}
0
Amiel
  • Matcher . find und Files . walk Methoden könnten eine Option sein, um Dateien flexibler zu durchsuchen
  • String . format kombiniert reguläre Ausdrücke, um Sucheinschränkungen zu erstellen
  • Files . isRegularFile prüft, ob ein Pfad kein Verzeichnis, keine symbolische Verknüpfung usw. ist.

Verwendung:

//Searches file names (start with "temp" and extension ".txt")
//in the current directory and subdirectories recursively
Path initialPath = Paths.get(".");
PathUtils.searchRegularFilesStartsWith(initialPath, "temp", ".txt").
                                       stream().forEach(System.out::println);

Quelle:

public final class PathUtils {

    private static final String startsWithRegex = "(?<![_ \\-\\p{L}\\d\\[\\]\\(\\) ])";
    private static final String endsWithRegex = "(?=[\\.\\n])";
    private static final String containsRegex = "%s(?:[^\\/\\\\]*(?=((?i)%s(?!.))))";

    public static List<Path> searchRegularFilesStartsWith(final Path initialPath, 
                             final String fileName, final String fileExt) throws IOException {
        return searchRegularFiles(initialPath, startsWithRegex + fileName, fileExt);
    }

    public static List<Path> searchRegularFilesEndsWith(final Path initialPath, 
                             final String fileName, final String fileExt) throws IOException {
        return searchRegularFiles(initialPath, fileName + endsWithRegex, fileExt);
    }

    public static List<Path> searchRegularFilesAll(final Path initialPath) throws IOException {
        return searchRegularFiles(initialPath, "", "");
    }

    public static List<Path> searchRegularFiles(final Path initialPath,
                             final String fileName, final String fileExt)
            throws IOException {
        final String regex = String.format(containsRegex, fileName, fileExt);
        final Pattern pattern = Pattern.compile(regex);
        try (Stream<Path> walk = Files.walk(initialPath.toRealPath())) {
            return walk.filter(path -> Files.isRegularFile(path) &&
                                       pattern.matcher(path.toString()).find())
                    .collect(Collectors.toList());
        }
    }

    private PathUtils() {
    }
}

Try startsWith Regex für\txt\temp\tempZERO0.txt:

(?<![_ \-\p{L}\d\[\]\(\) ])temp(?:[^\/\\]*(?=((?i)\.txt(?!.))))

Try endsWith Regex für\txt\temp\ZERO0temp.txt:

temp(?=[\\.\\n])(?:[^\/\\]*(?=((?i)\.txt(?!.))))

Try enthält Regex für\txt\temp\tempZERO0tempZERO0temp.txt:

temp(?:[^\/\\]*(?=((?i)\.txt(?!.))))
0
Oleksandr