如何递归列出Java目录下的所有文件？该框架是否提供任何实用程序？
我看到了很多 hacky 的实现。但是没有来自框架或nio
问问题
346415 次
30 回答
411
Java 8 提供了一个很好的流来处理树中的所有文件。
Files.walk(Paths.get(path))
.filter(Files::isRegularFile)
.forEach(System.out::println);
这提供了一种自然的方式来遍历文件。由于它是一个流，因此您可以对结果执行所有不错的流操作，例如限制、分组、映射、提前退出等。
更新：我可能会指出还有Files.find采用BiPredicate如果您需要检查文件属性可能会更有效。
Files.find(Paths.get(path),
Integer.MAX_VALUE,
(filePath, fileAttr) -> fileAttr.isRegularFile())
.forEach(System.out::println);
请注意，虽然 JavaDoc 没有提到此方法可能比Files.walk更有效，但它实际上是相同的，但如果您还在过滤器中检索文件属性，则可以观察到性能差异。最后，如果您需要过滤属性使用Files.find，否则使用Files.walk，主要是因为有重载并且更方便。
测试：根据要求，我提供了许多答案的性能比较。查看包含结果和测试用例的 Github 项目。
于 2014-06-03T03:37:29.063 回答
166
FileUtils有iterateFiles和listFiles方法。试一试。（来自commons-io）
编辑：您可以在此处查看不同方法的基准。似乎 commons-io 方法很慢，所以从这里选择一些更快的方法（如果重要的话）
于 2010-01-13T11:36:05.433 回答
142
// 准备运行
import java.io.File;
public class Filewalker {
public void walk( String path ) {
File root = new File( path );
File[] list = root.listFiles();
if (list == null) return;
for ( File f : list ) {
if ( f.isDirectory() ) {
walk( f.getAbsolutePath() );
System.out.println( "Dir:" + f.getAbsoluteFile() );
}
else {
System.out.println( "File:" + f.getAbsoluteFile() );
}
}
}
public static void main(String[] args) {
Filewalker fw = new Filewalker();
fw.walk("c:\\" );
}
}
于 2010-01-13T11:47:57.890 回答
71
Java 7将具有Files.walkFileTree：
如果您提供起点和文件访问者，它将在文件访问者遍历文件树中的文件时调用文件访问者的各种方法。我们希望人们在开发递归副本、递归移动、递归删除或设置权限或对每个文件执行其他操作的递归操作时使用此功能。
现在有一个关于这个问题的完整的 Oracle 教程。
于 2010-01-13T11:52:49.667 回答
29
不需要外部库。
返回一个集合，这样你就可以在调用后对它做任何你想做的事情。
public static Collection<File> listFileTree(File dir) {
Set<File> fileTree = new HashSet<File>();
if(dir==null||dir.listFiles()==null){
return fileTree;
}
for (File entry : dir.listFiles()) {
if (entry.isFile()) fileTree.add(entry);
else fileTree.addAll(listFileTree(entry));
}
return fileTree;
}
于 2012-07-25T20:36:19.450 回答
19
我会选择类似的东西：
public void list(File file) {
System.out.println(file.getName());
File[] children = file.listFiles();
for (File child : children) {
list(child);
}
}
System.out.println 只是用来指示对文件执行某些操作。没有必要区分文件和目录，因为普通文件只会有零个子文件。
于 2010-01-13T11:39:33.073 回答
15
对于这种简单的遍历，我更喜欢使用队列而不是递归：
List<File> allFiles = new ArrayList<File>();
Queue<File> dirs = new LinkedList<File>();
dirs.add(new File("/start/dir/"));
while (!dirs.isEmpty()) {
for (File f : dirs.poll().listFiles()) {
if (f.isDirectory()) {
dirs.add(f);
} else if (f.isFile()) {
allFiles.add(f);
}
}
}
于 2012-05-30T10:17:21.180 回答
12
只需使用简单的递归自己编写：
public List<File> addFiles(List<File> files, File dir)
{
if (files == null)
files = new LinkedList<File>();
if (!dir.isDirectory())
{
files.add(dir);
return files;
}
for (File file : dir.listFiles())
addFiles(files, file);
return files;
}
于 2010-01-13T11:36:26.480 回答
8
使用 Java 7，您可以使用以下类：
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
public class MyFileIterator extends SimpleFileVisitor<Path>
{
public MyFileIterator(String path) throws Exception
{
Files.walkFileTree(Paths.get(path), this);
}
@Override
public FileVisitResult visitFile(Path file,
BasicFileAttributes attributes) throws IOException
{
System.out.println("File: " + file);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult preVisitDirectory(Path dir,
BasicFileAttributes attributes) throws IOException
{
System.out.println("Dir: " + dir);
return FileVisitResult.CONTINUE;
}
}
于 2014-11-22T15:15:24.477 回答
8
此代码已准备好运行
public static void main(String... args) {
File[] files = new File("D:/").listFiles();
if (files != null)
getFiles(files);
}
public static void getFiles(File[] files) {
for (File file : files) {
if (file.isDirectory()) {
getFiles(file.listFiles());
} else {
System.out.println("File: " + file);
}
}
}
于 2017-10-30T17:14:31.410 回答
7
我认为这应该做的工作：
File dir = new File(dirname);
String[] files = dir.list();
这样你就有了文件和目录。现在使用递归并对 dirs 做同样的事情（File类有isDirectory()方法）。
于 2010-01-13T11:35:53.687 回答
7
在 Java 8 中，我们现在可以使用 Files 实用程序来遍历文件树。非常简单。
Files.walk(root.toPath())
.filter(path -> !Files.isDirectory(path))
.forEach(path -> System.out.println(path));
于 2014-10-05T12:38:38.600 回答
4
除了递归遍历之外，还可以使用基于访问者的方法。
下面的代码是使用基于访问者的方法进行遍历。预计程序的输入是要遍历的根目录。
public interface Visitor {
void visit(DirElement d);
void visit(FileElement f);
}
public abstract class Element {
protected File rootPath;
abstract void accept(Visitor v);
@Override
public String toString() {
return rootPath.getAbsolutePath();
}
}
public class FileElement extends Element {
FileElement(final String path) {
rootPath = new File(path);
}
@Override
void accept(final Visitor v) {
v.visit(this);
}
}
public class DirElement extends Element implements Iterable<Element> {
private final List<Element> elemList;
DirElement(final String path) {
elemList = new ArrayList<Element>();
rootPath = new File(path);
for (File f : rootPath.listFiles()) {
if (f.isDirectory()) {
elemList.add(new DirElement(f.getAbsolutePath()));
} else if (f.isFile()) {
elemList.add(new FileElement(f.getAbsolutePath()));
}
}
}
@Override
void accept(final Visitor v) {
v.visit(this);
}
public Iterator<Element> iterator() {
return elemList.iterator();
}
}
public class ElementWalker {
private final String rootDir;
ElementWalker(final String dir) {
rootDir = dir;
}
private void traverse() {
Element d = new DirElement(rootDir);
d.accept(new Walker());
}
public static void main(final String[] args) {
ElementWalker t = new ElementWalker("C:\\temp");
t.traverse();
}
private class Walker implements Visitor {
public void visit(final DirElement d) {
System.out.println(d);
for(Element e:d) {
e.accept(this);
}
}
public void visit(final FileElement f) {
System.out.println(f);
}
}
}
于 2010-01-13T12:53:58.933 回答
3
您可以使用以下代码以递归方式获取特定文件夹或目录的文件列表。
public static void main(String args[]) {
recusiveList("D:");
}
public static void recursiveList(String path) {
File f = new File(path);
File[] fl = f.listFiles();
for (int i = 0; i < fl.length; i++) {
if (fl[i].isDirectory() && !fl[i].isHidden()) {
System.out.println(fl[i].getAbsolutePath());
recusiveList(fl[i].getAbsolutePath());
} else {
System.out.println(fl[i].getName());
}
}
}
于 2017-06-23T05:25:44.040 回答
2
我想出了这个以递归方式打印所有文件/文件名。
private static void printAllFiles(String filePath,File folder) {
if(filePath==null) {
return;
}
File[] files = folder.listFiles();
for(File element : files) {
if(element.isDirectory()) {
printAllFiles(filePath,element);
} else {
System.out.println(" FileName "+ element.getName());
}
}
}
于 2019-08-02T17:40:30.067 回答
2
列出所有具有提供扩展名的文件，并可选择扫描子文件夹（递归）
public static ArrayList<File> listFileTree(File dir,boolean recursive) {
if (null == dir || !dir.isDirectory()) {
return new ArrayList<>();
}
final Set<File> fileTree = new HashSet<File>();
FileFilter fileFilter = new FileFilter() {
private final String[] acceptedExtensions = new String[]{"jpg", "png", "webp", "jpeg"};
@Override
public boolean accept(File file) {
if (file.isDirectory()) {
return true;
}
for (String extension : acceptedExtensions) {
if (file.getName().toLowerCase().endsWith(extension)) {
return true;
}
}
return false;
}
};
File[] listed = dir.listFiles(fileFilter);
if(listed!=null){
for (File entry : listed) {
if (entry.isFile()) {
fileTree.add(entry);
} else if(recursive){
fileTree.addAll(listFileTree(entry,true));
}
}
}
return new ArrayList<>(fileTree);
}
于 2020-09-21T10:54:47.840 回答
1
具有单个列表的非递归 BFS（特定示例是搜索 *.eml 文件）：
final FileFilter filter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.isDirectory() || file.getName().endsWith(".eml");
}
};
// BFS recursive search
List<File> queue = new LinkedList<File>();
queue.addAll(Arrays.asList(dir.listFiles(filter)));
for (ListIterator<File> itr = queue.listIterator(); itr.hasNext();) {
File file = itr.next();
if (file.isDirectory()) {
itr.remove();
for (File f: file.listFiles(filter)) itr.add(f);
}
}
于 2013-09-22T10:17:21.230 回答
1
我的版本（当然我可以使用 Java 8 中的内置 walk ;-)）：
public static List<File> findFilesIn(File rootDir, Predicate<File> predicate) {
ArrayList<File> collected = new ArrayList<>();
walk(rootDir, predicate, collected);
return collected;
}
private static void walk(File dir, Predicate<File> filterFunction, List<File> collected) {
Stream.of(listOnlyWhenDirectory(dir))
.forEach(file -> walk(file, filterFunction, addAndReturn(collected, file, filterFunction)));
}
private static File[] listOnlyWhenDirectory(File dir) {
return dir.isDirectory() ? dir.listFiles() : new File[]{};
}
private static List<File> addAndReturn(List<File> files, File toAdd, Predicate<File> filterFunction) {
if (filterFunction.test(toAdd)) {
files.add(toAdd);
}
return files;
}
于 2015-11-08T12:13:20.607 回答
1
这是一个简单但完美的解决方案，使用recursion：
public static List<Path> listFiles(String rootDirectory)
{
List<Path> files = new ArrayList<>();
listFiles(rootDirectory, files);
return files;
}
private static void listFiles(String path, List<Path> collectedFiles)
{
File root = new File(path);
File[] files = root.listFiles();
if (files == null)
{
return;
}
for (File file : files)
{
if (file.isDirectory())
{
listFiles(file.getAbsolutePath(), collectedFiles);
} else
{
collectedFiles.add(file.toPath());
}
}
}
于 2018-01-01T21:06:42.157 回答
1
private void fillFilesRecursively(File file, List<File> resultFiles) {
if (file.isFile()) {
resultFiles.add(file);
} else {
for (File child : file.listFiles()) {
fillFilesRecursively(child, resultFiles);
}
}
}
于 2018-06-23T09:05:49.097 回答
1
Kotlin 就是FileTreeWalk为了这个目的。例如：
dataDir.walkTopDown().filter { !it.isDirectory }.joinToString("\n") {
"${it.toRelativeString(dataDir)}: ${it.length()}"
}
将生成给定根目录下所有非目录文件的文本列表，每行一个文件，其中包含相对于根目录的路径和长度。
于 2019-12-10T09:55:39.393 回答
1
公认的答案很好，但是当您想在 lambda 中执行 IO 时它会崩溃。
如果您的操作声明 IOExceptions，您可以执行以下操作。
您可以将过滤后的流视为Iterable，然后在常规 for-each 循环中执行您的操作。这样，您不必在 lambda 中处理异常。
try (Stream<Path> pathStream = Files.walk(Paths.get(path))
.filter(Files::isRegularFile)) {
for (Path file : (Iterable<Path>) pathStream::iterator) {
// something that throws IOException
Files.copy(file, System.out);
}
}
于 2019-12-17T14:15:04.027 回答
1
即使有人已经提供了 Java 8 walk，您也可以采用另一种方式。
这将递归地为您提供所有文件
private Stream<File> files(File file) {
return file.isDirectory()
? Arrays.stream(file.listFiles()).flatMap(this::files)
: Stream.of(file);
}
于 2020-01-28T15:51:25.763 回答
1
public static String getExten(String path) {
int i = path.lastIndexOf('.');
if (i > 0) {
return path.substring(i);
}
else return "";
}
public static List<String> GetAllFiles(String path, List<String>fileList){
File file = new File(path);
File[] files = file.listFiles();
for(File folder:files) {
if(extensions.contains(getExten(folder.getPath()))) {
fileList.add(folder.getPath());
}
}
File[] direcs = file.listFiles(File::isDirectory);
for(File dir:direcs) {
GetAllFiles(dir.getPath(),fileList);
}
return fileList;
}
这是一个简单的递归函数，应该为您提供所有文件。extensions 是一个字符串列表，仅包含那些被接受的扩展名。示例扩展 = [".txt",".docx"] 等。
于 2020-08-17T18:47:15.417 回答
1
接受的答案很差，因为它可能导致资源泄漏。
Files.walk由DirectoryStreams支持。
返回的流封装了一个或多个 DirectoryStream。如果需要及时处理文件系统资源，则应使用 try-with-resources 构造来确保在流操作完成后调用流的 close 方法。对关闭的流进行操作将导致 IllegalStateException。
DirectoryStream 必须按照其 javadoc 中的指定关闭：
DirectoryStream 在创建时打开，并通过调用 close 方法关闭。关闭目录流会释放与该流相关的所有资源。未能关闭流可能会导致资源泄漏。try-with-resources 语句提供了一个有用的构造来确保流被关闭：
Path dir = ...
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
for (Path entry: stream) {
...
}
}
结果，真正的答案是：
try (Stream<Path> stream = Files.walk(Paths.get(path))) {
// Do something with the stream.
stream.filter(Files::isRegularFile)
.forEach(System.out::println);
}
于 2021-10-08T00:54:12.660 回答
0
示例使用 java.nio 中的 Files.find() 在目录递归搜索子目录中输出 *.csv 文件：
String path = "C:/Daten/ibiss/ferret/";
logger.debug("Path:" + path);
try (Stream<Path> fileList = Files.find(Paths.get(path), Integer.MAX_VALUE,
(filePath, fileAttr) -> fileAttr.isRegularFile() && filePath.toString().endsWith("csv"))) {
List<String> someThingNew = fileList.sorted().map(String::valueOf).collect(Collectors.toList());
for (String t : someThingNew) {
t.toString();
logger.debug("Filename:" + t);
}
}
发布此示例，因为我无法理解如何在 Bryan 给出的 #1 示例中传递文件名参数，在 Stream-result 上使用 foreach -
希望这可以帮助。
于 2017-10-12T10:43:07.513 回答
0
基于@Michael 的回答，添加检查 listFiles 是否返回 null
static Stream<File> files(File file) {
return file.isDirectory()
? Optional.ofNullable(file.listFiles()).map(Stream::of).orElseGet(Stream::empty).flatMap(MainActivity::files)
: Stream.of(file);
}
或者使用支持 Android5 & Android6的 Lightweight-Stream-API
static Stream<File> files(File f) {
return f.isDirectory() ? Stream.ofNullable(f.listFiles()).flatMap(MainActivity::files) : Stream.of(f);
}
于 2020-10-12T03:25:18.583 回答
0
List<Path> filePaths = Files
.find(Paths.get(dir), Integer.MAX_VALUE, (filePath, fileAttr) -> fileAttr.isRegularFile() || fileAttr.isDirectory())
.collect(Collectors.toList());
filePaths将具有可以迭代并进一步进行的文件和文件夹列表。
于 2022-02-01T00:33:34.597 回答
-1
基于堆垛机的答案。这是一个在 JSP 中工作的解决方案，没有任何外部库，因此您几乎可以将它放在服务器上的任何位置：
<!DOCTYPE html>
<%@ page session="false" %>
<%@ page import="java.util.*" %>
<%@ page import="java.io.*" %>
<%@ page contentType="text/html; charset=UTF-8" %>
<%!
public List<String> files = new ArrayList<String>();
/**
Fills files array with all sub-files.
*/
public void walk( File root ) {
File[] list = root.listFiles();
if (list == null) return;
for ( File f : list ) {
if ( f.isDirectory() ) {
walk( f );
}
else {
files.add(f.getAbsolutePath());
}
}
}
%>
<%
files.clear();
File jsp = new File(request.getRealPath(request.getServletPath()));
File dir = jsp.getParentFile();
walk(dir);
String prefixPath = dir.getAbsolutePath() + "/";
%>
然后，您只需执行以下操作：
<ul>
<% for (String file : files) { %>
<% if (file.matches(".+\\.(apk|ipa|mobileprovision)")) { %>
<li><%=file.replace(prefixPath, "")%></li>
<% } %>
<% } %>
</ul>
于 2014-01-21T09:32:36.970 回答
-1
import java.io.File;
public class Main {
public static void main(String[] args) {
loopFiles(new File("C:\\Users\\serge.klimkovitch\\Documents"));
}
private static void loopFiles(File element) {
if (element.isDirectory()) {
for (File currentFile : element.listFiles()) {
loopFiles(currentFile);
System.out.println(currentFile);
}
}
}
}
于 2021-12-02T17:23:52.630 回答