Java 之 递归&递归操作文件

一、概述

　　递归：指在当前方法内调用自己的现象。

　　递归的分类：

• • 　递归分为两种，直接递归和间接递归
    
  •    直接递归称为方法自身调用自己
  •    间接递归可以 A 方法调用 B 方法，B 方法调用 C 方法，C 方法调用 A 方法。

　　注意：

• • 　递归一定要有条件限制，保证递归能够停止下来，否则会发生栈内存溢出。
  •     在递归中虽然有限定条件，但是递归次数不能太多，苟泽也会发生栈内容溢出。
  •     构造方法，进制递归。

　　递归导致栈内存溢出的原理：

　　

二、案例

　　1、递归累加求和

　　　　计算 1~ n 的和，n 的累加 = n + (n+1) 的累和，可以把累和的操作定义成一个方法，递归调用。

　　　　实现：

public class Demo {
    public static void main(String[] args) {
        //计算1~num的和，使用递归完成
        int num = 5;
        // 调用求和的方法
        int sum = getSum(num);
        // 输出结果
        System.out.println(sum);
    } 
    /*
        通过递归算法实现.
        参数列表:int
        返回值类型: int
    */
    public static int getSum(int num) {
        /*
        num为1时,方法返回1,
        相当于是方法的出口,num总有是1的情况
        */
        if(num == 1){
            return 1;
        }
        /*
        num不为1时,方法返回 num +(num‐1)的累和
        递归调用getSum方法
        */
        return num + getSum(num‐1);
    }
}

　　代码执行图解：

 　　　注意：递归一定要有条件限定，保证递归能够停止下来，次数不要太多，否则会发生栈内存溢出。

　　2、递归求阶乘

　　　　阶乘：所有小于及等于该数的正整数的积。

　　　　分析：n! = n * (n-1);

　　　　实现：

public class DiGuiDemo {
    //计算n的阶乘，使用递归完成
    public static void main(String[] args) {
        int n = 3;
        // 调用求阶乘的方法
        int value = getValue(n);
        // 输出结果
        System.out.println("阶乘为:"+ value);
      }
 /* 
    通过递归算法实现.
    参数列表:int
    返回值类型: int
    */
    public static int getValue(int n) {
        // 1的阶乘为1
        if (n == 1) {
            return 1;
        } 
        /*
        n不为1时,方法返回 n! = n*(n‐1)!
       递归调用getValue方法
        */
        return n * getValue(n ‐ 1);
    }
}

　　3、递归求年龄

　　　　问题：第一个人10，第2个比第1个人大2岁，以此类推，请用递归方式计算出第8个人多大？

　　　　实现：

　　public int getAge(int n){
        /*
         * 第一个人10,n=1, 结果10       
         * 第二个人12，n=2, 结果10 + 2       getAge(1) + 2
         * 第三个人14，n=3, 结果10 + 2 + 2   getAge(2) + 2
         * 
         * 第n个人?，n=?, 结果10 + 2 + 2 ...+ ?  getAge(n-1) + 2
         */
        if(n==1){
            return 10;
        }else{
            return getAge(n-1) + 2;
        }
    }

　　4、递归—爬台阶问题

　　　　问题:有n步台阶，一次只能上1步或2步，共有多少种走法？

　　　　实现：

　　public long sum(int n){
        /*
         * n==1  1
         * n==2  2  
         * n==3  最后一步  要么从第1级跨2步，要么从第2级跨1步        把走到第1级的走法 + 走到第2级的走法  sum(1) + sum(2)
         * n==4 最后一步  要么从第2级跨2步，要么从第3级跨1步        把走到第2级的走法 + 走到第3级的走法  sum(2) + sum(3)
         * n==5 最后一步  要么从第3级跨2步，要么从第4级跨1步        把走到第3级的走法 + 走到第4级的走法  sum(3) + sum(4)
         * 
         * n=? 最后一步  要么从第n-2级跨2步，要么从第n-1级跨1步        把走到第n-2级的走法 + 走到第n-1级的走法  sum(n-2) + sum(n-1)
         */
        if(n==1 || n==2){
            return n;
        }else{
            return sum(n-1) + sum(n-2);
        }
    }

三、递归与文件操作

　　1、递归打印多级目录

　　　　分析：多级目录的打印，就是当目录的嵌套。遍历之前，无从知道到底有多少级目录，所以我们还是要使用递归实现。

　　　　实现1：

public class DiGuiDemo {
    public static void main(String[] args) {
        // 创建File对象
        File dir = new File("D:\aaa");
        // 调用打印目录方法
        printDir(dir);
    } 
    public static void printDir(File dir) {
        // 获取子文件和目录
        File[] files = dir.listFiles();
        // 循环打印
        /*
        判断:
        当是文件时,打印绝对路径.
        当是目录时,继续调用打印目录的方法,形成递归调用.
        */
        for (File file : files) {
            // 判断
            if (file.isFile()) {
                // 是文件,输出文件绝对路径
                System.out.println("文件名:"+ file.getAbsolutePath());
            } else {
                // 是目录,输出目录绝对路径
                System.out.println("目录:"+file.getAbsolutePath());
                // 继续遍历,调用printDir,形成递归
                 printDir(file);
            }
        }
　　}
}

 　　　　实现2：

　　 //listAllSub()方法的功能是列出一个文件或一个目录及它的下一级
    public void listAllSub(File dir){
        if(dir.isDirectory()){
            File[] listFiles = dir.listFiles();
            for (File sub : listFiles) {//sub可能是一个文件，也可能是一个文件夹
                listAllSub(sub);//递归：自己调用自己
            }
        }
        System.out.println(dir);
    }

　　2、递归求文件或目录大小

　　　　实现：

　　public long getLength(File dir){
        if (dir != null && dir.isDirectory()) {
            File[] listFiles = dir.listFiles();
            if(listFiles!=null){
                long sum = 0;
                for (File sub : listFiles) {
                    sum += getLength(sub);
                }
                return sum;
            }
        }else if(dir != null && dir.isFile()){
            return dir.length();
        }
        return 0;
    }

　　3、递归删除文件 

　　　实现：

　　public void deleteDir(File file){
        //如果是文件夹，先把它的下一级删除
        if(file.isDirectory()){
            File[] listFiles = file.listFiles();
            //经过这个foreach循环，可以把file的所有的下一级删除
            for (File sub : listFiles) {
                deleteDir(sub);
            }
        }
        
        //文件夹就变成了空文件夹，就可以直接删
        //如果是文件也可以直接删除
        file.delete();
    }