Java 遍历目录

在各种编程应用中，遍历目录是一个常见任务，涉及浏览文件夹中的文件和子目录。在Java中，存在不同的目录遍历策略，递归和使用栈进行迭代是两种常见的方法。递归需要函数反复调用自身来解决问题，而使用栈进行迭代需要一种数据结构来跟踪程序的状态。这两种方法都有各自的优缺点，最佳方法取决于程序的特定需求。本文深入介绍了这两种方法，提供了在Java中使用它们的示例代码。

方法

方法1 - 通过使用递归的概念，可以通过为每个下级目录调用自身来遍历文件系统的层次结构，保持这种方式直到所有文件和子目录都被检查并相应地处理。
方法2 - 使用迭代。通过使用栈来跟踪要遍历的目录，可以简化目录遍历。采用迭代循环按顺序处理每个目录，从栈中弹出目录，然后将其子目录推入栈中以进行延迟处理。这种方法确保对目录结构进行系统而高效的遍历。

语法

File directory = new File("path/to/directory");
File[] files = directory.listFiles();
for (File file : files) {
   // Perform operations on the file
}

步骤

使用迭代在Java中遍历目录的算法如下所示：

步骤1 - 实例化一个File对象来表示目标目录进行遍历。
步骤2 - 创建一个Stack数据结构，并将File对象推入堆栈以启动进程。
步骤3 - 持续弹出堆栈中的顶部元素，直到堆栈为空。
步骤4 - 使用listFiles()方法检索与弹出元素中的所有文件和目录对应的File对象数组。
步骤5 - 使用for循环遍历File对象数组。
步骤6 - 对于数组中的每个File对象，确定它是否是目录，如果是，则将其推入堆栈以进行进一步遍历。
步骤7 - 对于数组中的每个File对象，执行指定的操作。

迭代方法利用堆栈来跟踪需要遍历的目录。最初，根目录被推入堆栈。随后进入循环，在循环中从堆栈中弹出顶部元素，并获取表示其内部所有文件和目录的File对象数组。然后遍历该数组，遇到任何目录时，将其推入堆栈以供后续遍历，并对每个文件执行所需的操作。此过程重复，直到堆栈为空。

方法1

在这种方法中，我们将设计一个接受File对象并继续遍历目录的递归函数。当函数遇到每个子目录时，它调用自身，从而递归地遍历每个目录。函数开始时，它获取表示目录中所有文件和目录的File对象数组。然后，函数继续遍历数组并验证每个对象是否表示目录或文件。如果对象表示目录，则函数使用目录作为输入调用自身，从而继续递归遍历子目录。这个过程会持续进行，直到所有文件和目录都被完全遍历。

以下是相同的程序代码。

示例1（非执行代码）

import java.io.File;

public class DirectoryTraversal {
   public static void main(String[] args) {
      File directory = new File("path/to/directory");
      traverseDirectory(directory);
   }
   public static void traverseDirectory(File directory) {
      File[] files = directory.listFiles();
      if (files != null) {
         for (File file : files) {
            if (file.isDirectory()) {
               System.out.println("Directory: " + file.getAbsolutePath());
               traverseDirectory(file);
            } else {
               System.out.println("File: " + file.getAbsolutePath());
            }
         }
      }
   }
}

输出

Directory: /path/to/directory
File: /path/to/directory/file1.txt
Directory: /path/to/directory/subdirectory
File: /path/to/directory/subdirectory/file2.txt

方法2

在这个方法中，我们使用堆栈数据结构来保持我们需要导航的目录的记录。初始时，我们将根目录推入堆栈。随后，我们进入一个循环，从堆栈中弹出顶部元素，并检索表示其中所有文件和目录的文件对象数组。然后，我们遍历数组，将遇到的任何目录推入堆栈，并对每个文件执行所需的操作。这个过程持续进行，直到堆栈中没有元素，表示所有目录和文件都已彻底遍历。

以下是相同程序的代码。

示例2（非执行代码）

import java.io.File;
import java.util.Stack;

public class DirectoryTraversal {
   public static void main(String[] args) {
      // Create a File object for the directory to be traversed
      File directory = new File("C:\Users\User\Documents\example_directory");

      // Create a Stack data structure to keep track of directories to be traversed
      Stack<File> stack = new Stack<>();
      stack.push(directory);

      // Loop until the stack is empty
      while (!stack.empty()) {
         // Pop the top directory from the stack
         File currentDirectory = stack.pop();

         // Get an array of File objects representing all files and directories within the current directory
         File[] files = currentDirectory.listFiles();

         // Iterate over the array of File objects
         for (File file : files) {
            if (file.isDirectory()) {
               // If the current file is a directory, push it onto the stack to be traversed later
               stack.push(file);
            } else {
               // If the current file is a file, perform the desired operation(s)
               System.out.println(file.getName());
            }
         }
      }
   }
}

example_directory/
├── file1.txt
├── subdirectory/
│   ├── file2.txt
│   └── file3.txt
└── file4.txt

输出

file1.txt
file2.txt
file3.txt
file4.txt

结论

总之，通过Java遍历目录可以使用多种方法。在这个示例中，我们探讨了两种不同的方法，即使用递归和使用栈进行迭代。虽然递归提供了一种更简单和更简明的方式，但在遍历大量目录时可能不是最佳选择，因为可能会出现堆栈溢出错误。另一方面，使用栈的迭代方法提供了一个更强大的解决方案，可以处理较大的目录，尽管需要更多的代码，并且可能不太直观。最适合采用的方法将取决于程序的具体要求。