Java教程：如何不使用递归实现文件夹的遍历？

​ 大家好，这篇文章为大家介绍一下怎样遍历电脑上的一个文件夹。

​ 通常遍历文件夹我们都是使用递归进行操作，这种方式比较简单，也比较容易理解，本文的第一种实现也是使用递归。然后再为大家介绍另一种不使用递归的方式，只用到了循环和集合，这种方式由于没有使用递归，所以效率更高一些！

一、使用递归遍历文件夹

1.1 实现思路

​ 整体思路：

​ 1). 使用File封装初始目录。

​ 2). 打印这个目录。

​ 3). 获取这个目录下所有的子文件和子目录的数组。

​ 4). 遍历这个数组，取出每个File对象

​ 5).判断这个File是否是一个文件，是：

​ 打印

​ 6).否则(就是一个目录)：

​ 递归调用(从步骤2到这里，就可以形成一个递归方法)

1.2 代码实现

public class Demo{
    public static void main(String[] args){
    	//1).使用File封装初始目录
        File dir = new File("d:\\多级目录");
        //调用递归方法
        searchFile(dir);
    }
    //递归方法
    public static void searchFile(File dir){
        //2).打印这个目录
        System.out.println(dir.getAbsolutePath());
        //3). 获取这个目录下所有的子文件和子目录的数组。
        File[] files = dir.listFiles();
        //4). 遍历这个数组，取出每个File对象
        if(files != null){
            for(File f : files){
                //5).判断这个File是否是一个文件，是：
                if(f.isFile()){
                    //打印
                    System.out.println(f);
                }else{//6).否则就是一个目录，继续递归
                    //递归
                    searchFile(f);
                }
            }
        }
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

​ 这种实现方式的核心就是每个目录都会调用searchFile()方法，而searchFile()方法针对每个目录的工作都是一样的：打印目录、获取目录下所偶有的子文件和子目录的数组、遍历数组…从而形成了递归调用。

​ 由于递归需要再次调用方法，导致方法入栈，从而降低程序的执行效率！

二、不使用递归遍历文件夹

2.1 实现思路

​ 不使用递归的思路

​ 1). 使用File封装初始目录。

​ 2). 定义一个集合，用于存储"一个目录下所有的子文件和子目录的File对象"。

​ 3). 集合中先添加"初始目录"。

​ 4). 循环，条件：集合非空

​ 1). 取出，并删除集合中的索引为0的"File对象"(此File对象可能是文件，也可能是目录)

​ 2). 打印这个File对象。

​ 3). 判断此File对象是否是"目录"，是：

​ 获取此目录下所有子文件和子目录的File数组，并添加到这个集合的前面

​ 循环结束

​ 这个流程用循环代替了递归，每次将目录的File对象添加到集合，然后再取出，删除。再获取这个目录下所有的子目录和子文件的数组，并添加到集合，然后再循环。最终直至把所有文件都取出，并删除，打印，集合为空，结束循环。

2.2 代码实现

/**
 * 非递归遍历目录
 * 创建一个List对象，把目录放到List中
 * 循环遍历，每次取出第一个元素，如果是目录就把目录中的内容放到List最前面，如果不是目录只取出即可。
 */
public class SearchDir {
    public static void main(String[] args) {
        File dir = new File("d:\\多级目录");
        searchDir(dir);
    }

    public static void searchDir(File dir) {
        //定义集合
        List<File> list = new ArrayList<>();
        //将参数dir对象添加到集合
        list.add(dir);
        //循环，条件：集合非空
        while (!list.isEmpty()) {
            //取出，并删除集合的第一个File对象
            File file = list.remove(0);
            //打印这个File对象
            System.out.println(file.getAbsoluteFile());
            //如果此File对象是一个目录
            if(file.isDirectory()) {
                //获取此File对象下所有子文件和子目录的数组，并添加到集合的前面
                list.addAll(0, Arrays.asList(file.listFiles()));
            }
            //继续下一次循环......
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

这种方式仅仅用到了集合，没有使用递归，所以占用系统资源较小，效率比较高！是不是很巧妙？大家学会了吗？