Java递归的整理带三个小案例

1. package 递归的使用;
   /*
    * 实现5的阶乘
    */
   public class DiGuiDemo {
       public static void main(String[] args) {
           System.out.println(JiCheng(5));
       }
       
       //递归计算阶乘
       public static int JieCheng(int n){
           if(n == 1){
               return 1;
           }else {
               return n*JieCheng(n-1);  //自己调用自己
           }
       }
   }

   /*
    * 获取数列第二十个位置的数：
    * 数列的规律如下：1、1、2、3、5、8、13、21、34...切波那切数列
       * 三种方式
   　　         1.使用数组获取
               2.使用变量获取
               3.使用递归实现　　
    */
   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]);
   
           // 使用变量获取
           int a = 1;
           int b = 1;
           for (int x = 0; x < 18; x++) {
               int tmp = a;
               a = b;
               b = tmp + b;
           }
           System.out.println(b);
   
           //
           System.out.println(birthRubbit(20));
       }
   
       // 切波那切数列，生兔子算法
       // 出口条件是第一个数是1，第二个数是1，
       // 规律：从第三个月开始，每一个月都是前两个月之和。
       public static int birthRubbit(int n) {
           if (n == 1 || n == 2) {
               return 1;
           }
           return birthRubbit(n - 1) + birthRubbit(n - 2);
       }
   }

    

   2 
   import java.io.File;
   import java.io.FilenameFilter;
   import java.util.ArrayList;
   
   /*
    * 获取指定盘符下的指定后缀的全部文件。
    */
   public class DiGuiDemo {
       public static void main(String[] args) {
           // 封装路径
           File file = new File("E:\\1-个人资料");
           // File[] fileArr = file.listFiles(new FilenameFilter() {
           // @Override
           // public boolean accept(File dir, String name) {
           // // TODO Auto-generated method stub
           // File file2 = new File(dir, name);
           // // System.out.println(dir + "--" + name);
           // if (file2.isDirectory()) {
           //
           // }
           // return false;
           // }
           // });
           // File[] fileArr = file.listFiles();
           // for (File f : fileArr) {
           // if (f.isFile()) {
           //
           // }
           // }
           getFile(file);
   
       }
   
       public static void getFile(File f) {
           File[] fileArr = f.listFiles();
           ArrayList<String> list = new ArrayList<String>();
           // 遍历该集合
           // 如果得到的是一个文件同时该文件的后缀是.java那么久将该文件添加到list中，后面输出
              //如果获取到的文件对象仍然是一个文件夹那个继续递归获取该文件夹内部的文件，知道该最后的文件夹起内部全部为文件为止。
   
   
           for (File file : fileArr) {
               if (file.isDirectory()) {
                   getFile(file); 
               } else if (file.getName().endsWith(".jpeg")
               // || file.getName().endsWith(".jpg")此处可以通过添加||符号继续添加查找的条件
               ) {
                   // System.out.println(file.getAbsolutePath());  //获取到的满足条件的文件可以直接打印，或者将该文件对象存入的路径存入list后续使用
                   list.add(file.getAbsolutePath());
               }
   
           }
           // 遍历获得的结果
           for (String s : list) {
               System.out.println(s);
           }
   
       }
   }

   10:18:40在使用递归的时候，每一次的调用都会在栈内存中开辟一个内存加载该方法，执行完毕后，如果继续遇到递归，那么继续加载方法，一次递归，最后方法会一次销毁，和栈的数据存储一致，先进入的main函数加载在底部，最后被弹出输出结果。