列出Java中目录和子目录中的所有文件

列出1000多个目录和子目录中的文件名的最快方法是什么

编辑； 我目前使用的代码是：

import java.io.File;

public class DirectoryReader {

  static int spc_count=-1;

  static void Process(File aFile) {
    spc_count++;
    String spcs = "";
    for (int i = 0; i < spc_count; i++)
      spcs += " ";
    if(aFile.isFile())
      System.out.println(spcs + "[FILE] " + aFile.getName());
    else if (aFile.isDirectory()) {
      System.out.println(spcs + "[DIR] " + aFile.getName());
      File[] listOfFiles = aFile.listFiles();
      if(listOfFiles!=null) {
        for (int i = 0; i < listOfFiles.length; i++)
          Process(listOfFiles[i]);
      } else {
        System.out.println(spcs + " [ACCESS DENIED]");
      }
    }
    spc_count--;
  }

  public static void main(String[] args) {
    String nam = "D:/";
    File aFile = new File(nam);
    Process(aFile);
  }

}

导入java.io.File；
公共类DirectoryReader{
静态整数spc_计数=-1；
静态无效进程（文件文件）{
spc_计数++；
字符串spcs=“”；
对于（int i=0；i

这看起来不错（递归地遍历目录）瓶颈将是您需要执行的所有文件i/o，优化Java不会显示任何真正的改进。

直到Java 7引入新类（如），恐怕您已经拥有的将是最快的。

唯一的改进是去掉

静态spc\u计数

，并将

spcs

字符串作为参数传递给处理

public static void main(String[] args) {
  String nam = "D:/";
  File aFile = new File(nam);
  Process("", aFile);
}

当执行递归调用时，请执行以下操作

static void Process( String spcs, File aFile) {
  ...
  Process(spcs + " ", listOfFiles[i]);
  ...
}

---

通过这种方式，您可以从多个线程调用此方法。

当这个答案显示在google顶部时，我添加了一个java 7 nio解决方案，用于列出所有文件和目录，它在我的系统上花费的时间大约减少了80%

try {
    Path startPath = Paths.get("c:/");
    Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult preVisitDirectory(Path dir,
                BasicFileAttributes attrs) {
            System.out.println("Dir: " + dir.toString());
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
            System.out.println("File: " + file.toString());    
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFileFailed(Path file, IOException e) {
            return FileVisitResult.CONTINUE;
        }
    });
} catch (IOException e) {
    e.printStackTrace();
}

试试看{
Path startPath=Path.get（“c:/”；
walkFileTree（startPath，新的SimpleFileVisitor（）{
@凌驾
公共文件VisitResult preVisitDirectory（路径目录，
基本文件属性（属性属性）{
System.out.println（“Dir:+Dir.toString（））；
返回FileVisitResult.CONTINUE；
}
@凌驾
公共文件VisitResult visitFile（路径文件，基本文件属性属性属性）{
System.out.println（“文件：“+File.toString（））；
返回FileVisitResult.CONTINUE；
}
@凌驾
公共文件VisitResult visitFileFailed（路径文件，IOE异常）{
返回FileVisitResult.CONTINUE；
}
});
}捕获（IOE异常）{
e、 printStackTrace（）；
}

如果您愿意使用第三方库，请退出。它包括一个多线程递归目录搜索，应该比一次遍历一个目录更快。这里有一些例子：

---

我写了一个简单得多的代码…试试这个。。。它将显示每个文件夹、子文件夹和文件

 int Files=0,Directory=0,HiddenFiles=0,HiddenDirectory=0;

 public void listf(String directoryName){

File file=new File(directoryName);

File[] fileList=file.listFiles();

if(fileList!=null){

for(int i=0;i<fileList.length;i++){

if(fileList[i].isHidden()){

if(fileList[i].isFile())

{

   System.out.println(fileList[i]);

HiddenFiles++;

}

else{

  listf(String.valueOf(fileList[i]));

  HiddenDirectory++;

}

}

else if (fileList[i].isFile()) {

//System.out.println(fileList[i]);

Files++;

}

else if(fileList[i].isDirectory()){

Directory++;

listf(String.valueOf(fileList[i]));

}

}

}

}



public void Numbers(){

   System.out.println("Files: "+Files+" HiddenFiles: "+HiddenFiles+"Hidden Directories"+HiddenDirectory+" Directories: "+Directory);`

    }  

int Files=0，Directory=0，HiddenFiles=0，HiddenDirectory=0；
public void listf（字符串directoryName）{
文件=新文件（目录名）；
File[]fileList=File.listFiles（）；
如果（文件列表！=null）{
对于（int i=0；i）你说的最快是什么意思？编码最简单，在某个操作系统上表现最好，还是在某个目录结构上表现最好？在我的例子中，是指在WinXP上表现最快，并且尽可能最简单。升级投票，因为这是一个常见的用例，它肯定有助于我向你推荐@Alexander Pogrebnyak