递归的使用以及案例

递归

    (1)方法定义中调用方法本身的现象

        举例：老和尚给小和尚讲故事，我们学编程

    (2)递归的注意事项；

        A:递归一定要有出口，否则就是死递归

        B:递归的次数不能太多，否则就内存溢出

        C:构造方法不能递归使用

    (3)递归的案例：

        A:递归求阶乘

/*

 * 需求：请用代码实现求5的阶乘。

 * 下面的知识要知道：

 *         5! = 1*2*3*4*5

 *         5! = 5*4!

 *

 * 有几种方案实现呢?

 *         A:循环实现

 *         B:递归实现

 *             a:做递归要写一个方法

 *             b:出口条件

 *             c:规律

 */

public class DiGuiDemo {

    public static void main(String[] args) {

        int jc = 1;

        for (int x = 2; x <= 5; x++) {

            jc *= x;

        }

        System.out.println("5的阶乘是：" + jc);



        System.out.println("5的阶乘是："+jieCheng(5));

    }

   

/*

     * 做递归要写一个方法:

     *         返回值类型：int

     *         参数列表：int n

     * 出口条件:

     *         if(n == 1) {return 1;}

     * 规律:

     *         if(n != 1) {return n*方法名(n-1);}

     */

    public static int jieCheng(int n){

        if(n==1){

            return 1;

        }else {

            return n*jieCheng(n-1);

        }

    }

}

 

 

        B:兔子问题

 

/*

 * 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

 * 分析：我们要想办法找规律

 *             兔子对数

 * 第一个月：     1

 * 第二个月：    1

 * 第三个月：    2

 * 第四个月：    3   

 * 第五个月：    5

 * 第六个月：    8

 * ...

 *

 * 由此可见兔子对象的数据是：

 *         1,1,2,3,5,8...

 * 规则：

 *         A:从第三项开始，每一项是前两项之和

 *         B:而且说明前两项是已知的

 *

 * 如何实现这个程序呢?

 *         A:数组实现

 *         B:变量的变化实现

 *         C:递归实现

 *

 * 假如相邻的两个月的兔子对数是a,b

 * 第一个相邻的数据：a=1,b=1

 * 第二个相邻的数据：a=1,b=2

 * 第三个相邻的数据：a=2,b=3

 * 第四个相邻的数据：a=3,b=5

 * 看到了：下一次的a是以前的b，下一次是以前的a+b   

 */

public class DiGuiDemo2 {

    public static void main(String[] args) {

        // 定义一个数组

        int[] arr = new int[20];

        arr[0] = 1;

        arr[1] = 1;

   

        for (int x = 2; x < arr.length; x++) {

            arr[x] = arr[x - 2] + arr[x - 1];

        }

        System.out.println(arr[19]);// 6765

        System.out.println("----------------");



        int a = 1;

        int b = 1;

        for (int x = 0; x < 18; x++) {

            // 临时变量存储上一次的a

            int temp = a;

            a = b;

            b = temp + b;

        }

        System.out.println(b);

        System.out.println("----------------");



        System.out.println(fib(20));

    }

 

  /*

     * 方法： 返回值类型：int 参数列表：int n 出口条件： 第一个月是1，第二个月是1 规律： 从第三个月开始，每一个月是前两个月之和

     */

    public static int fib(int n) {

        if (n == 1 || n == 2) {

            return 1;

        } else {

            return fib(n - 1) + fib(n - 2);

        }

    }

}

        C:递归输出指定目录下所有指定后缀名的文件绝对路径

import java.io.File;



/*

 * 需求：把E:\JavaSE目录下所有的java结尾的文件的绝对路径给输出在控制台。

 *

 * 分析：

 *         A:封装目录

 *         B:获取该目录下所有的文件或者文件夹的File数组

 *         C:遍历该File数组，得到每一个File对象

 *         D:判断该File对象是否是文件夹

 *             是：回到B

 *             否：继续判断是否以.java结尾

 *                 是：就输出该文件的绝对路径

 *                 否：不搭理它

 */

public class FilePathDemo {

    public static void main(String[] args) {

        // 封装目录

        File srcFolder = new File("E:\\JavaSE");



        // 递归功能实现

        getAllJavaFilePaths(srcFolder);

    }



    private static void getAllJavaFilePaths(File srcFolder) {

        // 获取该目录下所有的文件或者文件夹的File数组

        File[] fileArray = srcFolder.listFiles();



        // 遍历该File数组，得到每一个File对象

        for (File file : fileArray) {

            // 判断该File对象是否是文件夹

            if (file.isDirectory()) {

                getAllJavaFilePaths(file);

            } else {

                // 继续判断是否以.java结尾

                if (file.getName().endsWith(".java")) {

                    // 就输出该文件的绝对路径

                    System.out.println(file.getAbsolutePath());

                }

            }

        }

    }

}

        D:递归删除带内容的目录(小心使用)

/*

 * 需求：递归删除带内容的目录

 *

 * 分析：

 *         A:封装目录

 *         B:获取该目录下的所有文件或者文件夹的File数组

 *         C:遍历该File数组，得到每一个File对象

 *         D:判断该File对象是否是文件夹

 *             是：回到B

 *             否：就删除

 */

public class FileDeleteDemo {

    public static void main(String[] args) {

        // 封装目录

        File srcFolder = new File("demo");

        // 递归实现

        deleteFolder(srcFolder);

    }



    private static void deleteFolder(File srcFolder) {

        // 获取该目录下的所有文件或者文件夹的File数组

        File[] fileArray = srcFolder.listFiles();



        if (fileArray != null) {

            // 遍历该File数组，得到每一个File对象

            for (File file : fileArray) {

                // 判断该File对象是否是文件夹

                if (file.isDirectory()) {

                    deleteFolder(file);

                } else {

                    System.out.println(file.getName() + "---" + file.delete());

                }

            }

            System.out .println(srcFolder.getName() + "---" + srcFolder.delete());

        }

    }

}