Wie lese ich alle Dateien in einem Ordner von Java?

Wie lese ich alle Dateien in einem Ordner über Java?

public void listFilesForFolder(final File folder) {
    for (final File fileEntry : folder.listFiles()) {
        if (fileEntry.isDirectory()) {
            listFilesForFolder(fileEntry);
        } else {
            System.out.println(fileEntry.getName());
        }
    }
}

final File folder = new File("/home/you/Desktop");
listFilesForFolder(folder);

Die Files.walk- API ist in Java 8 verfügbar.

try (Stream<Path> paths = Files.walk(Paths.get("/home/you/Desktop"))) {
    paths
        .filter(Files::isRegularFile)
        .forEach(System.out::println);
} 

In diesem Beispiel wird das im API-Handbuch empfohlene Try-with-Resources- Muster verwendet. Es stellt sicher, dass der Stream unabhängig von den Umständen geschlossen wird.

File folder = new File("/Users/you/folder/");
File[] listOfFiles = folder.listFiles();

for (File file : listOfFiles) {
    if (file.isFile()) {
        System.out.println(file.getName());
    }
}

In Java 8 können Sie dies tun

Files.walk(Paths.get("/path/to/folder"))
     .filter(Files::isRegularFile)
     .forEach(System.out::println);

Dadurch werden alle Dateien in einem Ordner gedruckt, wobei alle Verzeichnisse ausgeschlossen werden. Wenn Sie eine Liste benötigen, reicht Folgendes aus:

Files.walk(Paths.get("/path/to/folder"))
     .filter(Files::isRegularFile)
     .collect(Collectors.toList())

Wenn Sie zurückkehren möchten, List<File>anstatt es List<Path>nur zuzuordnen:

List<File> filesInFolder = Files.walk(Paths.get("/path/to/folder"))
                                .filter(Files::isRegularFile)
                                .map(Path::toFile)
                                .collect(Collectors.toList());

Sie müssen auch sicherstellen, dass der Stream geschlossen wird! Andernfalls tritt möglicherweise eine Ausnahme auf, die Sie darüber informiert, dass zu viele Dateien geöffnet sind. Lesen Sie hier für weitere Informationen.

Alle Antworten zu diesem Thema, die die neuen Java 8-Funktionen verwenden, vernachlässigen das Schließen des Streams. Das Beispiel in der akzeptierten Antwort sollte sein:

try (Stream<Path> filePathStream=Files.walk(Paths.get("/home/you/Desktop"))) {
    filePathStream.forEach(filePath -> {
        if (Files.isRegularFile(filePath)) {
            System.out.println(filePath);
        }
    });
}

Aus dem Javadoc der Files.walkMethode:

Der zurückgegebene Stream kapselt einen oder mehrere DirectoryStreams. Wenn eine rechtzeitige Entsorgung von Dateisystemressourcen erforderlich ist, sollte das Try-with-Resources-Konstrukt verwendet werden, um sicherzustellen, dass die Abschlussmethode des Streams nach Abschluss der Stream-Vorgänge aufgerufen wird.

import java.io.File;


public class ReadFilesFromFolder {
  public static File folder = new File("C:/Documents and Settings/My Documents/Downloads");
  static String temp = "";

  public static void main(String[] args) {
    // TODO Auto-generated method stub
    System.out.println("Reading files under the folder "+ folder.getAbsolutePath());
    listFilesForFolder(folder);
  }

  public static void listFilesForFolder(final File folder) {

    for (final File fileEntry : folder.listFiles()) {
      if (fileEntry.isDirectory()) {
        // System.out.println("Reading files under the folder "+folder.getAbsolutePath());
        listFilesForFolder(fileEntry);
      } else {
        if (fileEntry.isFile()) {
          temp = fileEntry.getName();
          if ((temp.substring(temp.lastIndexOf('.') + 1, temp.length()).toLowerCase()).equals("txt"))
            System.out.println("File= " + folder.getAbsolutePath()+ "\\" + fileEntry.getName());
        }

      }
    }
  }
}

private static final String ROOT_FILE_PATH="/";
File f=new File(ROOT_FILE_PATH);
File[] allSubFiles=f.listFiles();
for (File file : allSubFiles) {
    if(file.isDirectory())
    {
        System.out.println(file.getAbsolutePath()+" is directory");
        //Steps for directory
    }
    else
    {
        System.out.println(file.getAbsolutePath()+" is file");
        //steps for files
    }
}

In Java 7 können Sie dies jetzt auf folgende Weise tun: http://docs.oracle.com/javase/tutorial/essential/io/dirs.html#listdir

Path dir = ...;
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
    for (Path file: stream) {
        System.out.println(file.getFileName());
    }
} catch (IOException | DirectoryIteratorException x) {
    // IOException can never be thrown by the iteration.
    // In this snippet, it can only be thrown by newDirectoryStream.
    System.err.println(x);
}

Sie können auch einen Filter erstellen, der dann an die newDirectoryStreamobige Methode übergeben werden kann

DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<Path>() {
    public boolean accept(Path file) throws IOException {
        try {
            return (Files.isRegularFile(path));
        } catch (IOException x) {
            // Failed to determine if it's a file.
            System.err.println(x);
            return false;
        }
    }
};

Andere Filterbeispiele - http://docs.oracle.com/javase/tutorial/essential/io/dirs.html#glob

Eine Bemerkung laut bekommen alle Dateien im Verzeichnis.
Die MethodeFiles.walk(path) gibt alle Dateien zurück, indem sie den Dateibaum durchläuft, der in der angegebenen gestarteten Datei verwurzelt ist.

Zum Beispiel gibt es den nächsten Dateibaum:

\---folder
    |   file1.txt
    |   file2.txt
    |
    \---subfolder
            file3.txt
            file4.txt

Verwenden der java.nio.file.Files.walk(Path):

Files.walk(Paths.get("folder"))
        .filter(Files::isRegularFile)
        .forEach(System.out::println);

Gibt das folgende Ergebnis:

folder\file1.txt
folder\file2.txt
folder\subfolder\file3.txt
folder\subfolder\file4.txt

Um alle Dateien nur im aktuellen Verzeichnis abzurufen, verwenden Sie Folgendes java.nio.file.Files.list(Path):

Files.list(Paths.get("folder"))
        .filter(Files::isRegularFile)
        .forEach(System.out::println);

Ergebnis:

folder\file1.txt
folder\file2.txt

Gehen Sie einfach mit Files.walkFileTree(Java 7) durch alle Dateien.

Files.walkFileTree(Paths.get(dir), new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        System.out.println("file: " + file);
        return FileVisitResult.CONTINUE;
    }
});

Wenn Sie weitere Optionen wünschen, können Sie diese Funktion verwenden, um eine Arrayliste der in einem Ordner vorhandenen Dateien zu füllen. Folgende Optionen stehen zur Verfügung: Rekursivität und Muster.

public static ArrayList<File> listFilesForFolder(final File folder,
        final boolean recursivity,
        final String patternFileFilter) {

    // Inputs
    boolean filteredFile = false;

    // Ouput
    final ArrayList<File> output = new ArrayList<File> ();

    // Foreach elements
    for (final File fileEntry : folder.listFiles()) {

        // If this element is a directory, do it recursivly
        if (fileEntry.isDirectory()) {
            if (recursivity) {
                output.addAll(listFilesForFolder(fileEntry, recursivity, patternFileFilter));
            }
        }
        else {
            // If there is no pattern, the file is correct
            if (patternFileFilter.length() == 0) {
                filteredFile = true;
            }
            // Otherwise we need to filter by pattern
            else {
                filteredFile = Pattern.matches(patternFileFilter, fileEntry.getName());
            }

            // If the file has a name which match with the pattern, then add it to the list
            if (filteredFile) {
                output.add(fileEntry);
            }
        }
    }

    return output;
}

Am besten, Adrien

File directory = new File("/user/folder");      
File[] myarray;  
myarray=new File[10];
myarray=directory.listFiles();
for (int j = 0; j < myarray.length; j++)
{
       File path=myarray[j];
       FileReader fr = new FileReader(path);
       BufferedReader br = new BufferedReader(fr);
       String s = "";
       while (br.ready()) {
          s += br.readLine() + "\n";
       }
}

nette Verwendung von java.io.FileFilterwie auf https://stackoverflow.com/a/286001/146745 zu sehen

File fl = new File(dir);
File[] files = fl.listFiles(new FileFilter() {          
    public boolean accept(File file) {
        return file.isFile();
    }
});

    static File mainFolder = new File("Folder");
    public static void main(String[] args) {

        lf.getFiles(lf.mainFolder);
    }
    public void getFiles(File f) {
        File files[];
        if (f.isFile()) {
            String name=f.getName();

        } else {
            files = f.listFiles();
            for (int i = 0; i < files.length; i++) {
                getFiles(files[i]);
            }
        }
    }

Ich denke, dies ist eine gute Möglichkeit, alle Dateien in einem Ordner und Unterordner zu lesen

private static void addfiles (File input,ArrayList<File> files)
{
    if(input.isDirectory())
    {
        ArrayList <File> path = new ArrayList<File>(Arrays.asList(input.listFiles()));
        for(int i=0 ; i<path.size();++i)
        {
            if(path.get(i).isDirectory())
            {
                addfiles(path.get(i),files);
            }
            if(path.get(i).isFile())
            {
                files.add(path.get(i));
            }
        }
    }
    if(input.isFile())
    {
        files.add(input);
    }
}

Einfaches Beispiel, das mit Java 1.7 funktioniert, um Dateien in Verzeichnissen, die in der Befehlszeile angegeben sind, rekursiv aufzulisten:

import java.io.File;

public class List {
    public static void main(String[] args) {
        for (String f : args) {
            listDir(f);
        }
    }

    private static void listDir(String dir) {
        File f = new File(dir);
        File[] list = f.listFiles();

        if (list == null) {
            return;
        }

        for (File entry : list) {
            System.out.println(entry.getName());
            if (entry.isDirectory()) {
                listDir(entry.getAbsolutePath());
            }
        }
    }
}

Während ich Rich, Orian und den anderen zustimme, verwenden sie:

    final File keysFileFolder = new File(<path>); 
    File[] fileslist = keysFileFolder.listFiles();

    if(fileslist != null)
    {
        //Do your thing here...
    }

Aus irgendeinem Grund verwenden alle Beispiele hier den absoluten Pfad (dh den gesamten Weg von root oder beispielsweise den Laufwerksbuchstaben (C: \) für Windows.)

Ich möchte hinzufügen, dass es möglich ist, auch den relativen Pfad zu verwenden . Wenn Sie also pwd (aktuelles Verzeichnis / Ordner) Ordner1 ist und Ordner1 / Unterordner analysieren möchten, schreiben Sie einfach (im obigen Code anstelle von):

    final File keysFileFolder = new File("subfolder");

package com;


import java.io.File;

/**
 *
 * @author ?Mukesh
 */
public class ListFiles {

     static File mainFolder = new File("D:\\Movies");

     public static void main(String[] args)
     {
         ListFiles lf = new ListFiles();
         lf.getFiles(lf.mainFolder);

         long fileSize = mainFolder.length();
             System.out.println("mainFolder size in bytes is: " + fileSize);
             System.out.println("File size in KB is : " + (double)fileSize/1024);
             System.out.println("File size in MB is :" + (double)fileSize/(1024*1024));
     }
     public void getFiles(File f){
         File files[];
         if(f.isFile())
             System.out.println(f.getAbsolutePath());
         else{
             files = f.listFiles();
             for (int i = 0; i < files.length; i++) {
                 getFiles(files[i]);
             }
         }
     }
}

Java 8 Files.walk(..)ist gut, wenn Sie soore sind, dass es keine Java 8 Files.walk (..) -Kündigungsursache von (java.nio.file.AccessDeniedException) auslöst .

Hier ist eine sichere Lösung, die jedoch nicht so elegant ist wie Java 8 Files.walk(..):

int[] count = {0};
try {
    Files.walkFileTree(Paths.get(dir.getPath()), new HashSet<FileVisitOption>(Arrays.asList(FileVisitOption.FOLLOW_LINKS)),
            Integer.MAX_VALUE, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file , BasicFileAttributes attrs) throws IOException {
                    System.out.printf("Visiting file %s\n", file);
                    ++count[0];

                    return FileVisitResult.CONTINUE;
                }

                @Override
                public FileVisitResult visitFileFailed(Path file , IOException e) throws IOException {
                    System.err.printf("Visiting failed for %s\n", file);

                    return FileVisitResult.SKIP_SUBTREE;
                }

                @Override
                public FileVisitResult preVisitDirectory(Path dir , BasicFileAttributes attrs) throws IOException {
                     System.out.printf("About to visit directory %s\n", dir);
                    return FileVisitResult.CONTINUE;
                }
            });
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

void getFiles(){
        String dirPath = "E:/folder_name";
        File dir = new File(dirPath);
        String[] files = dir.list();
        if (files.length == 0) {
            System.out.println("The directory is empty");
        } else {
            for (String aFile : files) {
                System.out.println(aFile);
            }
        }
    }

Um die akzeptierte Antwort zu erweitern, speichere ich die Dateinamen in einer ArrayList (anstatt sie nur in System.out.println abzulegen). Ich habe eine Hilfsklasse "MyFileUtils" erstellt, damit sie von anderen Projekten importiert werden kann:

class MyFileUtils {
    public static void loadFilesForFolder(final File folder, List<String> fileList){
        for (final File fileEntry : folder.listFiles()) {
            if (fileEntry.isDirectory()) {
                loadFilesForFolder(fileEntry, fileList);
            } else {
                fileList.add( fileEntry.getParent() + File.separator + fileEntry.getName() );
            }
        }
    }
}

Ich habe den vollständigen Pfad zum Dateinamen hinzugefügt. Sie würden es so verwenden:

import MyFileUtils;

List<String> fileList = new ArrayList<String>();
final File folder = new File("/home/you/Desktop");
MyFileUtils.loadFilesForFolder(folder, fileList);

// Dump file list values
for (String fileName : fileList){
    System.out.println(fileName);
}

Die ArrayList wird von "value" übergeben, aber der Wert wird verwendet, um auf dasselbe ArrayList-Objekt zu verweisen, das sich im JVM-Heap befindet. Auf diese Weise fügt jeder Rekursionsaufruf Dateinamen zur gleichen ArrayList hinzu (wir erstellen NICHT bei jedem rekursiven Aufruf eine neue ArrayList).

Sie können den Dateipfad zum Argument setzen und eine Liste mit allen Dateipfaden erstellen und nicht manuell in die Liste einfügen. Verwenden Sie dann eine for-Schleife und einen Reader. Beispiel für txt-Dateien:

public static void main(String[] args) throws IOException{    
File[] files = new File(args[0].replace("\\", "\\\\")).listFiles(new FilenameFilter() { @Override public boolean accept(File dir, String name) { return name.endsWith(".txt"); } });
    ArrayList<String> filedir = new ArrayList<String>();
    String FILE_TEST = null;
    for (i=0; i<files.length; i++){
            filedir.add(files[i].toString());
            CSV_FILE_TEST=filedir.get(i) 

        try(Reader testreader = Files.newBufferedReader(Paths.get(FILE_TEST));
            ){
              //write your stuff
                 }}}

package com.commandline.folder;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class FolderReadingDemo {
    public static void main(String[] args) {
        String str = args[0];
        final File folder = new File(str);
//      listFilesForFolder(folder);
        listFilesForFolder(str);
    }

    public static void listFilesForFolder(String str) {
        try (Stream<Path> paths = Files.walk(Paths.get(str))) {
            paths.filter(Files::isRegularFile).forEach(System.out::println);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void listFilesForFolder(final File folder) {
        for (final File fileEntry : folder.listFiles()) {
            if (fileEntry.isDirectory()) {
                listFilesForFolder(fileEntry);
            } else {
                System.out.println(fileEntry.getName());
            }
        }
    }

}

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class AvoidNullExp {

public static void main(String[] args) {

    List<File> fileList =new ArrayList<>();
     final File folder = new File("g:/master");
     new AvoidNullExp().listFilesForFolder(folder, fileList);
}

    public void listFilesForFolder(final File folder,List<File> fileList) {
        File[] filesInFolder = folder.listFiles();
        if (filesInFolder != null) {
            for (final File fileEntry : filesInFolder) {
                if (fileEntry.isDirectory()) {
                    System.out.println("DIR : "+fileEntry.getName());
                listFilesForFolder(fileEntry,fileList);
            } else {
                System.out.println("FILE : "+fileEntry.getName());
                fileList.add(fileEntry);
            }
         }
        }
     }


}

Listen Sie die Dateien aus dem Testordner auf, die im Klassenpfad vorhanden sind

import java.io.File;
import java.io.IOException;

public class Hello {

    public static void main(final String[] args) throws IOException {

        System.out.println("List down all the files present on the server directory");
        File file1 = new File("/prog/FileTest/src/Test");
        File[] files = file1.listFiles();
        if (null != files) {
            for (int fileIntList = 0; fileIntList < files.length; fileIntList++) {
                String ss = files[fileIntList].toString();
                if (null != ss && ss.length() > 0) {
                    System.out.println("File: " + (fileIntList + 1) + " :" + ss.substring(ss.lastIndexOf("\\") + 1, ss.length()));
                }
            }
        }


    }


}

/**
 * Function to read all mp3 files from sdcard and store the details in an
 * ArrayList
 */


public ArrayList<HashMap<String, String>> getPlayList() 
    {
        ArrayList<HashMap<String, String>> songsList=new ArrayList<>();
        File home = new File(MEDIA_PATH);

        if (home.listFiles(new FileExtensionFilter()).length > 0) {
            for (File file : home.listFiles(new FileExtensionFilter())) {
                HashMap<String, String> song = new HashMap<String, String>();
                song.put(
                        "songTitle",
                        file.getName().substring(0,
                                (file.getName().length() - 4)));
                song.put("songPath", file.getPath());

                // Adding each song to SongList
                songsList.add(song);
            }
        }
        // return songs list array
        return songsList;
    }

    /**
     * Class to filter files which have a .mp3 extension
     * */
    class FileExtensionFilter implements FilenameFilter 
    {
        @Override
        public boolean accept(File dir, String name) {
            return (name.endsWith(".mp3") || name.endsWith(".MP3"));
        }
    }

Sie können beliebige Textdateien oder andere Erweiterungen filtern. Ersetzen Sie sie einfach durch .MP3

Oben gibt es viele gute Antworten. Hier ist ein anderer Ansatz: In einem Maven-Projekt wird alles, was Sie in den Ressourcenordner legen, standardmäßig in den Ordner target / classes kopiert. Um zu sehen, was zur Laufzeit verfügbar ist

 ClassLoader contextClassLoader = 
 Thread.currentThread().getContextClassLoader();
    URL resource = contextClassLoader.getResource("");
    File file = new File(resource.toURI());
    File[] files = file.listFiles();
    for (File f : files) {
        System.out.println(f.getName());
    }

Um die Dateien aus einem bestimmten Ordner abzurufen, nehmen wir an, Sie haben einen Ordner mit dem Namen "res" in Ihrem Ressourcenordner. Ersetzen Sie einfach:

URL resource = contextClassLoader.getResource("res");

Wenn Sie Zugriff auf Ihr com.companyName-Paket haben möchten, gehen Sie wie folgt vor:

contextClassLoader.getResource("com.companyName");

Dadurch werden die angegebenen Dateierweiterungsdateien im angegebenen Pfad gelesen (siehe auch Unterordner).

public static Map<String,List<File>> getFileNames(String 
dirName,Map<String,List<File>> filesContainer,final String fileExt){
    String dirPath = dirName;
    List<File>files = new ArrayList<>();
    Map<String,List<File>> completeFiles = filesContainer; 
    if(completeFiles == null) {
        completeFiles = new HashMap<>();
    }
    File file = new File(dirName);

    FileFilter fileFilter = new FileFilter() {
        @Override
        public boolean accept(File file) {
            boolean acceptFile = false;
            if(file.isDirectory()) {
                acceptFile = true;
            }else if (file.getName().toLowerCase().endsWith(fileExt))
              {
                acceptFile = true;
              }
            return acceptFile;
        }
    };
    for(File dirfile : file.listFiles(fileFilter)) {
        if(dirfile.isFile() && 
dirfile.getName().toLowerCase().endsWith(fileExt)) {
            files.add(dirfile);
        }else if(dirfile.isDirectory()) {
            if(!files.isEmpty()) {
                completeFiles.put(dirPath, files);  
            }

getFileNames(dirfile.getAbsolutePath(),completeFiles,fileExt);
        }
    }
    if(!files.isEmpty()) {
        completeFiles.put(dirPath, files);  
    }
    return completeFiles;
}

Dies wird gut funktionieren:

private static void addfiles(File inputValVal, ArrayList<File> files)
{
  if(inputVal.isDirectory())
  {
    ArrayList <File> path = new ArrayList<File>(Arrays.asList(inputVal.listFiles()));

    for(int i=0; i<path.size(); ++i)
    {
        if(path.get(i).isDirectory())
        {
            addfiles(path.get(i),files);
        }
        if(path.get(i).isFile())
        {
            files.add(path.get(i));
        }
     }

    /*  Optional : if you need to have the counts of all the folders and files you can create 2 global arrays 
        and store the results of the above 2 if loops inside these arrays */
   }

   if(inputVal.isFile())
   {
     files.add(inputVal);
   }

}

Listet bei einem BaseDir alle Dateien und Verzeichnisse darunter auf, die iterativ geschrieben wurden.

    public static List<File> listLocalFilesAndDirsAllLevels(File baseDir) {

    List<File>  collectedFilesAndDirs   = new ArrayList<>();
    Deque<File> remainingDirs           = new ArrayDeque<>();

    if(baseDir.exists()) {
        remainingDirs.add(baseDir);

        while(!remainingDirs.isEmpty()) {
            File dir = remainingDirs.removeLast();
            List<File> filesInDir = Arrays.asList(dir.listFiles());
            for(File fileOrDir : filesInDir)  {
                collectedFilesAndDirs.add(fileOrDir);
                if(fileOrDir.isDirectory()) {
                    remainingDirs.add(fileOrDir);
                }
            }
        }
    }

    return collectedFilesAndDirs;
}

um Nullpointerexceptions in der Funktion listFiles () zu verhindern und rekursiv auch alle Dateien aus Unterverzeichnissen abzurufen.

 public void listFilesForFolder(final File folder,List<File> fileList) {
    File[] filesInFolder = folder.listFiles();
    if (filesInFolder != null) {
        for (final File fileEntry : filesInFolder) {
            if (fileEntry.isDirectory()) {
            listFilesForFolder(fileEntry,fileList);
        } else {
            fileList.add(fileEntry);
        }
     }
    }
 }

 List<File> fileList = new List<File>();
 final File folder = new File("/home/you/Desktop");
 listFilesForFolder(folder);