Java-IO流（二）获取当前目录下所有文件以及文件夹

File类的listFiles()列出当前目录下文件以及文件夹。

            1,无非遍历当前目录内容的功能在功能内部被重复使用。
            只不过每次使用这个功能操作的子目录不同，所以就将子目录作为参数进行传递。
            这就是递归。
            2，递归
                2.1 函数自身调用自身。
                2.2 必须加入判断条件，避免栈内存溢出。
                2.3 控制递归次数，否则也容易栈内存溢出。
                2.4什么时候用递归呢？
                    当功能被重复使用，而且重复使用都会之前的运算结果作为参数传递到下次的调用。
                2.5对于文件夹递归变量，如果层级很深担心溢出，可以使用任务队列的方式完成。

• 递归方式

import java.io.File;

public class GetAllFiles {

    public static void main(String[] args) {
        /*
         * File类的listFiles()列出当前目录下文件以及文件夹。
         * 
         * 需求：能不能列出当前目录下的子目录中的所有内容。 思路： 1，在遍历当前目录时，会获取到当前的所有的文件以及文件夹，
         * 2，要遍历子目录需要对获取到的当前的file对象进行判断，只有是目录才可以作为子目录进行继续遍历。
         */

        File dir = new File("file");

        listAll(dir);
    }

    public static void listAll(File dir) {// dir:接收目录以及子目录。

        System.out.println("dir:" + dir.getName());
        File[] files = dir.listFiles();
        for (File file : files) {

            if (file.isDirectory()) {// 如果遍历到当前的file对象是个目录，继续遍历。
                listAll(file);
            } else {
                System.out.println("file:"+file.getName());
            }
        }

    }

}

• 队列方式

import java.io.File;
import java.util.LinkedList;

public class GetAllFileByQueue {

    /**
     * @param args
     */
    public static void main(String[] args) {

        /*
         * 遍历文件夹，不用递归咋办？ 
         * 思路：
         * 1，可以通过对每一个目录进行for循环，但是目录层级很多，for会死掉。
         * 2，每遍历到一个目录，不对其进行遍历，而是先临时存储起来。 相当于把所有目录（无论同级不同级）都存储起来。
         * 3，遍历容器时取到就是目录，然后对目录遍历即可。 4，从容器中取到目录遍历时发现内部还有目录，一样将这些目录存储到容器中。
         * 5，只要不断的遍历这个容器就哦了。
         * 
         * 发现这个容器只要是一个简单的队列就可以解决这个问题。
         */

        File dir = new File("file");
        System.out.println(dir.getName());
        Queue queue = new Queue();

        // 1,对dir进行当前目录的遍历。
        File[] files = dir.listFiles();
        for (File file : files) {
            // 2, 如果有子目录，存储到队列中。
            if (file.isDirectory()) {
                queue.myAdd(file);
            } else {
                System.out.println(file.getName());
            }
        }
        System.out.println("---------------------");
        //3,遍历队列容器。因为子目录都在队列中。
        while(!queue.isNull()){
            
            File subDir = queue.myGet();//从队列中取出子目录。
            System.out.println(subDir.getName());
            //4,遍历子目录。
            File[] subFiles = subDir.listFiles();
            for(File subFile : subFiles){
                if(subFile.isDirectory()){//如果子目录中还有子目录，继续存储到队列中。
                    queue.myAdd(subFile);
                }else{
                    System.out.println(subFile.getName());
                }
            }
            
            
        }
    }

}

/**
 * 队列结构。先进先出。
 */
class Queue {

    private LinkedList link;

    /**
     * 提供了构造队列对象的构造器。
     */
    public Queue() {
        link = new LinkedList();
    }

    /**
     * 添加元素的方法。
     */
    public void myAdd(E obj) {
        link.addFirst(obj);
    }

    /**
     * 获取的方法。
     */
    public E myGet() {
        return link.removeLast();
    }

    /**
     * 判断队列是否有元素。
     */
    public boolean isNull() {
        return link.isEmpty();
    }
}