Come leggere tutti i file in una cartella da Java?

Come leggere tutti i file in una cartella tramite 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); 

L’ API Files.walk è disponibile da Java 8.

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

L’esempio utilizza il pattern try-with-resource raccomandato nella guida API. Garantisce che, indipendentemente dalle circostanze, il stream verrà chiuso.

 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 puoi farlo

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

che stamperà tutti i file in una cartella escludendo tutte le directory. Se hai bisogno di una lista, il seguente farà:

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

Se si desidera restituire List invece di List basta mapparlo:

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

Devi anche assicurarti di chiudere lo stream! Altrimenti potresti incorrere in un’eccezione che ti dice che troppi file sono aperti. Leggi qui per maggiori informazioni.

Tutte le risposte su questo argomento che fanno uso delle nuove funzioni di Java 8 stanno trascurando di chiudere il stream. L’esempio nella risposta accettata dovrebbe essere:

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

Dal javadoc del metodo Files.walk :

Il stream restituito incapsula uno o più DirectoryStreams. Se è richiesto lo smaltimento tempestivo delle risorse del file system, è necessario utilizzare il costrutto try-with-resources per garantire che il metodo di chiusura del stream venga richiamato al termine delle operazioni dello stream.

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

Basta camminare tra tutti i file usando Files.walkFileTree (Java 7)

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

In Java 7 ora puoi farlo in questo modo: http://docs.oracle.com/javase/tutorial/essential/io/dirs.html#listdir

 Path dir = ...; try (DirectoryStream 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); } 

È inoltre ansible creare un filtro che può essere passato al metodo newDirectoryStream precedenza

 DirectoryStream.Filter filter = new DirectoryStream.Filter() { 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; } } }; 

Altri esempi di filtri: http://docs.oracle.com/javase/tutorial/essential/io/dirs.html#glob

Se vuoi più opzioni, puoi usare questa funzione che mira a popolare un arraylist di file presenti in una cartella. Le opzioni sono: ricorsività e modello da abbinare.

 public static ArrayList listFilesForFolder(final File folder, final boolean recursivity, final String patternFileFilter) { // Inputs boolean filteredFile = false; // Ouput final ArrayList output = new ArrayList (); // 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; } 

Il migliore, Adrien

buon uso di java.io.FileFilter come visto su https://stackoverflow.com/a/286001/146745

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

Penso che questo sia un buon modo per leggere tutti i file in una cartella e sottocartella

 private static void addfiles (File input,ArrayList files) { if(input.isDirectory()) { ArrayList  path = new ArrayList(Arrays.asList(input.listFiles())); for(int i=0 ; i 

Semplice esempio che funziona con Java 1.7 per elencare in modo ricorsivo i file nelle directory specificate sulla riga di comando:

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

Mentre sono d’accordo con Rich, Orian e il resto per l’utilizzo di:

  final File keysFileFolder = new File(); File[] fileslist = keysFileFolder.listFiles(); if(fileslist != null) { //Do your thing here... } 

per qualche ragione tutti gli esempi qui usano il percorso assoluto (cioè interamente da root, o, per esempio, lettera di unità (C: \) per Windows ..)

Vorrei aggiungere che è ansible utilizzare il percorso relativo come bene. Quindi, se sei pwd (current directory / folder) è folder1 e vuoi analizzare folder1 / subfolder, scrivi semplicemente (nel codice sopra invece di):

  final File keysFileFolder = new File("subfolder"); 
 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"; } } 
 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(..) è utile quando si rilassa il problema. Evita Java 8 File.walk (..) causa della terminazione di (java.nio.file.AccessDeniedException) .

Ecco una soluzione sicura, non così elegante come Java 8 Files.walk(..) :

 int[] count = {0}; try { Files.walkFileTree(Paths.get(dir.getPath()), new HashSet(Arrays.asList(FileVisitOption.FOLLOW_LINKS)), Integer.MAX_VALUE, new SimpleFileVisitor() { @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(); } 
 import java.io.File; import java.util.ArrayList; import java.util.List; public class AvoidNullExp { public static void main(String[] args) { List fileList =new ArrayList<>(); final File folder = new File("g:/master"); new AvoidNullExp().listFilesForFolder(folder, fileList); } public void listFilesForFolder(final File folder,List 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); } } } } } 

elenca i file dalla cartella Test presente nel percorso della class

 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> getPlayList() { ArrayList> songsList=new ArrayList<>(); File home = new File(MEDIA_PATH); if (home.listFiles(new FileExtensionFilter()).length > 0) { for (File file : home.listFiles(new FileExtensionFilter())) { HashMap song = new HashMap(); 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")); } } 

Puoi filtrare qualsiasi file di testo o qualsiasi altra estensione .. semplicemente sostituirlo con .MP3

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

Solo per espandere la risposta accettata, memorizzo i nomi dei file su ArrayList (invece di limitarli a System.out.println) ho creato una class helper “MyFileUtils” in modo che potesse essere importata da altri progetti:

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

Ho aggiunto il percorso completo al nome del file. Lo useresti in questo modo:

 import MyFileUtils; List fileList = new ArrayList(); final File folder = new File("/home/you/Desktop"); MyFileUtils.loadFilesForFolder(folder, fileList); // Dump file list values for (String fileName : fileList){ System.out.println(fileName); } 

L’ArrayList viene passato per “valore”, ma il valore viene utilizzato per puntare allo stesso object ArrayList che vive nell’heap JVM. In questo modo, ogni chiamata di ricorsione aggiunge nomi di file allo stesso ArrayList (NON stiamo creando un nuovo ArrayList su ogni chiamata ricorsiva).

Ci sono molte buone risposte sopra, ecco un approccio diverso: in un progetto di maven, tutto ciò che inserisci nella cartella delle risorse viene copiato di default nella cartella target / classs. Per vedere cosa è disponibile in fase di esecuzione

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

Ora per ottenere i file da una cartella specifica, supponiamo di avere una cartella chiamata “res” nella cartella delle risorse, basta sostituire:

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

Se vuoi avere accesso al tuo pacchetto com.companyName allora:

 contextClassLoader.getResource("com.companyName"); 

Questo leggerà i file di estensione del file specificati nel percorso dato (guarda anche le sottocartelle)

 public static Map> getFileNames(String dirName,Map> filesContainer,final String fileExt){ String dirPath = dirName; Listfiles = new ArrayList<>(); Map> 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; } 

Questo funzionerà bene:

 private static void addfiles(File inputValVal, ArrayList files) { if(inputVal.isDirectory()) { ArrayList  path = new ArrayList(Arrays.asList(inputVal.listFiles())); for(int i=0; i 

Puoi inserire il percorso del file in argomento e creare un elenco con tutti i percorsi file e non metterlo manualmente nell’elenco. Quindi utilizzare un ciclo for e un lettore. Esempio per i file txt:

 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 filedir = new ArrayList(); String FILE_TEST = null; for (i=0; i 

per prevenire Nullpointerecepceptions sulla funzione listFiles () e ricorsivamente ottenere tutti i file da sottodirectory anche ..

  public void listFilesForFolder(final File folder,List fileList) { File[] filesInFolder = folder.listFiles(); if (filesInFolder != null) { for (final File fileEntry : filesInFolder) { if (fileEntry.isDirectory()) { listFilesForFolder(fileEntry,fileList); } else { fileList.add(fileEntry); } } } } List fileList = new List(); final File folder = new File("/home/you/Desktop"); listFilesForFolder(folder); 
 import java.io.File; public class Test { public void test1() { System.out.println("TEST 1"); } public static void main(String[] args) throws SecurityException, ClassNotFoundException{ File actual = new File("src"); File list[] = actual.listFiles(); for(int i=0; i 

Basta passare la cartella che ti dirà la class principale sul metodo.