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();
     }