How can I read all files in a folder from Java?

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 you can do this

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

which will print all files in a folder while excluding all directories. If you need a list, the following will do:

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

If you want to return List<File> instead of List<Path> just map it:

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

You also need to make sure to close the stream! Otherwise you might run into an exception telling you that too many files are open. Read here for more information.

All of the answers on this topic that make use of the new Java 8 functions are neglecting to close the stream. The example in the accepted answer should be:

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

From the javadoc of the Files.walk method:

The returned stream encapsulates one or more DirectoryStreams. If timely disposal of file system resources is required, the try-with-resources construct should be used to ensure that the stream's close method is invoked after the stream operations are completed.

One remark according to get all files in the directory.
The method Files.walk(path) will return all files by walking the file tree rooted at the given started file.

For instance, there is the next file tree:

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

Using the java.nio.file.Files.walk(Path):

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

Gives the following result:

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

To get all files only in the current directory use the java.nio.file.Files.list(Path):

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

Result:

folder\file1.txt folder\file2.txt 

In Java 7 and higher you can use 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); } 

You can also create a filter that can then be passed into the newDirectoryStream method above

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

For other filtering examples, [see documentation].(http://docs.oracle.com/javase/tutorial/essential/io/dirs.html#glob)

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

Just walk through all Files using Files.walkFileTree (Java 7)

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

If you want more options, you can use this function which aims to populate an arraylist of files present in a folder. Options are: recursivity and the pattern to match.

public static ArrayList<File> listFilesForFolder(final File folder, final boolean recursivity, final String patternFileFilter) { // Inputs boolean filteredFile = false; // Output final ArrayList<File> output = new ArrayList<File> (); // Foreach elements for (final File fileEntry : folder.listFiles()) { // If this element is a directory, do it recursively if (fileEntry.isDirectory()) { if (recursivity) { output.addAll(listFilesForFolder(fileEntry, recursivity, patternFileFilter)); } } else { // If there isn't any 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; } 

A nice usage of java.io.FileFilter, as seen in Java - get the newest file in a directory?:

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

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

Simple example that works with Java 1.7 to recursively list files in directories specified on the command-line:

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

While I do agree with Rich, Orian and the rest for using:

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

for some reason all the examples here uses absolute path (i.e. all the way from root, or, say, drive letter (C:\) for windows..)

I'd like to add that it is possible to use relative path as-well. So, if you're pwd (current directory/folder) is folder1 and you want to parse folder1/subfolder, you simply write (in the code above instead of ):

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

Java 8 Files.walk(..) is good when you are soore it will not throw Avoid Java 8 Files.walk(..) termination cause of ( java.nio.file.AccessDeniedException ) .

Here is a safe solution , not though so elegant as Java 8Files.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(); } 

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

I think this is good way to read all the files in a folder and sub folder's

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

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

Just to expand on the accepted answer I store the filenames to an ArrayList (instead of just dumping them to System.out.println) I created a helper class "MyFileUtils" so it could be imported by other projects:

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

I added the full path to the file name. You would use it like this:

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

The ArrayList is passed by "value", but the value is used to point to the same ArrayList object living in the JVM Heap. In this way, each recursion call adds filenames to the same ArrayList (we are NOT creating a new ArrayList on each recursive call).

There are many good answers above, here's a different approach: In a maven project, everything you put in the resources folder is copied by default in the target/classes folder. To see what is available at runtime

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

Now to get the files from a specific folder, let's say you have a folder called 'res' in your resources folder, just replace:

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

If you want to have access in your com.companyName package then:

contextClassLoader.getResource("com.companyName"); 

A one liner using .map to get all the filenames in yourDirectory:

List<String> files = Files.list(Paths.get(yourDirectory)).map(path -> path.getFileName().toFile().getName()).collect(Collectors.toList());

Here's a short one for getting a list of files in a directory:

 File directory = new File("path"); File[] files = directory.listFiles(File::isFile); 

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

You can put the file path to argument and create a list with all the filepaths and not put it the list manually. Then use a for loop and a reader. Example for txt files:

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

We can use org.apache.commons.io.FileUtils, use listFiles() mehtod to read all the files in a given folder.

eg:

FileUtils.listFiles(directory, new String[] {"ext1", "ext2"}, true) 

This read all the files in the given directory with given extensions, we can pass multiple extensions in the array and read recursively within the folder(true parameter).

This will Read Specified file extension files in given path(looks sub folders also)

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

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

public static List<File> files(String dirname) { if (dirname == null) { return Collections.emptyList(); } File dir = new File(dirname); if (!dir.exists()) { return Collections.emptyList(); } if (!dir.isDirectory()) { return Collections.singletonList(file(dirname)); } return Arrays.stream(Objects.requireNonNull(dir.listFiles())) .collect(Collectors.toList()); } 

to prevent Nullpointerexceptions on the listFiles() function and recursivly get all files from subdirectories too..

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

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