递归（Recursive）

1. 所谓递归（Recursion），就是方法调用自身。 对于递归来说，一定有一个出口，让递
   归结束，只有这样才能保证不出现死循环。

阶乘

package JavaBase.Recursive;

public class Test1 {

    //循环方式计算阶乘，又叫迭代方式
    public int compute(int number) {

        int result = 1;

        for (int i = number; i > 0; i--) {
            result *= i;
        }
        return result;
    }

    //使用递归方式计算阶乘
    public int compute2(int number) {

        if (1 == number) {
            return 1;
        }
        else {
            return number * compute2(number - 1);
        }
    }

    public static void main(String[] args) {

        Test1 test1 = new Test1();
        System.out.println(test1.compute(5));
        System.out.println(test1.compute2(5));
    }
}

结果是：
120

斐波那契额数列

package JavaBase.Recursive;

public class Fab {

    //使用递归计算斐波那契额数列
    public int comput(int n) {
        if (1 == n || 2 == n) {
            return 1;
        } else {
            return comput(n - 1) + comput(n - 2);
        }
    }

    public static void main(String[] args) {
        Fab fab = new Fab();
        System.out.println(fab.comput(9));
    }
}

结果是：
34

删除目录

delete

public boolean delete()
Deletes the file or directory denoted by this abstract pathname. If this pathname denotes a directory, then the directory must be empty in order to be deleted.
（删除此抽象路径名表示的文件或目录。 如果此路径名表示目录，则该目录必须为空才能被删除。）

package JavaBase.Recursive;

import java.io.File;

public class FileTest9 {

    public static void deleAll(File file) {
        /**
         * 如果是文件直接删除，如果是文件夹，长度为0时说明目录下没有文件了，就删除目录
         * 如果是文件就短路，后面就不用执行了
         */
        if (file.isFile() || file.list().length == 0) {
            file.delete();
        }
        else {
            File[] files = file.listFiles();

            for (File f : files) {
                /**
                 * 先删除目录里面的全部内容，然后再把自己删掉。
                 */
                deleAll(f);
                f.delete();
            }
        }
    }

    public static void main(String[] args) {
        /**
         * 删除目录下的所有文件，但不删除这个目录
         */
        deleAll(new File("D:/abc"));

    }
}

2. 作业： 给定任意一个目录，以树形方式展现出该目录中的所有子目录和文件。 另外，
   在展现的时候将目录排在上面，文件排在下面。 每一层要加上缩进。

package JavaBase.Recursive;

import java.io.File;
import java.util.ArrayList;

public class HomeWork {
    //用于判断目录或文件所处的层次
    private static int time = 0;

    public static void select(File file) {
        //递归先想出口
        if (file.isFile() || file.list().length == 0) {

            return;
        }
        else{
            File[] files = file.listFiles();

            files = sort(files);

            for (File f : files) {

                StringBuffer output = new StringBuffer();
                if (f.isFile()) {
                    output.append(getTabs(time));
                    output.append(f.getName());
                }
                else {
                    output.append(getTabs(time));
                    output.append(f.getName());
                    output.append("/");
                }

                System.out.println(output);

                if (f.isDirectory()) {
                    time++;

                    select(f);

                    time--;
                }
            }
        }
    }

    //整理文件数组，使得目录排在文件之前
    private static File[] sort(File[] files) {
        ArrayList<File> sorted = new ArrayList<File>();

        //寻找到所有的目录
        for(File f : files){
            if (f.isDirectory()) {
                sorted.add(f);
            }
        }

        //寻找到所有的文件
        for (File f : files) {
            if (f.isFile()) {
                sorted.add(f);
            }
        }

        //集合转数组用toArray,数组转集合用asList
        return sorted.toArray(new File[files.length]);
    }

    //判断需要加多少tab的方法
    private static String getTabs(int time) {
        StringBuffer buffer = new StringBuffer();

        for (int i = 0; i < time; i++) {
            buffer.append("\t");
        }

        return  buffer.toString();
    }

    public static void main(String[] args) {
        select(new File("D:/abc"));
    }
}

结果是：
s/
zx/
zxczxc/
zux/
sadsa/