递归

递归

1 概述

1.递归：指在当前⽅法内调⽤⾃⼰的这种现象。
2.递归的分类：递归分为两种，直接递归和间接递归。
2.1直接递归称为⽅法⾃身调⽤⾃⼰。
2.2间接递归可以A⽅法调⽤B⽅法，B⽅法调⽤C⽅法，C⽅法调⽤A⽅法。
3.注意事项：
递归⼀定要有条件限定，保证递归能够停⽌下来，否则会发⽣栈内存溢出。
在递归中虽然有限定条件，但是递归次数不能太多。否则也会发⽣栈内存溢出。
构造⽅法,禁⽌递归

public class Demo01DiGui {
 public static void main(String[] args) {
 // a();
 b(1);
 }
 /*
 * 3.构造⽅法,禁⽌递归
 * 编译报错:构造⽅法是创建对象使⽤的,不能让对象⼀直创建下去
 */
  public Demo01DiGui() {
 // Demo01DiGui();
 }
 /*
 * 2.在递归中虽然有限定条件，但是递归次数不能太多。否则也会发⽣栈内存溢出。
 * 4993
 * Exception in thread "main" java.lang.StackOverflowError
 */
 private static void b(int i) {
 System.out.println(i);
 //添加⼀个递归结束的条件,i==5000的时候结束
 if (i == 5000) {
 return; // 结束⽅法
 }
 b(++i);
 }
 /*
 * 1.递归⼀定要有条件限定，保证递归能够停⽌下来，否则会发⽣栈内存溢出。
Exception in thread "main"
 * java.lang.StackOverflowError
 */
 private static void a() {
 System.out.println("a⽅法");
 a();
 } }

2 递归累加求和

计算1 ~ n的和
分析：num的累和 = num + (num-1)的累和，所以可以把累和的操作定义成⼀个⽅法，递归调⽤

public class DiGuiDemo {
 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);
 } }

3递归求阶层

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

n的阶乘：n! = n * (n-1) … 3 * 2 * 1
推理得出：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);
 }
}

4 递归打印多级目录

多级⽬录的打印，就是当⽬录的嵌套。遍历之前，⽆从知道到底有多少级⽬录，所以我们
还是要使⽤递归实现。

public class DiGuiDemo2 {
 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);
 }
 }
 }
}

5⽂件搜索

搜索 D:\aaa ⽬录中的 .java ⽂件
分析：

1. ⽬录搜索，⽆法判断多少级⽬录，所以使⽤递归，遍历所有⽬录。
2. 遍历⽬录时，获取的⼦⽂件，通过⽂件名称，判断是否符合条件

public class DiGuiDemo3 {
 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()) {
 // 是⽂件，判断⽂件名并输出⽂件绝对路径
 if (file.getName().endsWith(".java")) {
 System.out.println("⽂件名:" + file.getAbsolutePath());
 }
 } else {
 // 是⽬录，继续遍历,形成递归
 printDir(file);
 }
 }
 }
}

6 ⽂件过滤器优化

java.io.FileFilter 是⼀个接⼝，是File的过滤器。 该接⼝的对象可以传递给File类的
listFiles(FileFilter) 作为参数， 接⼝中只有⼀个⽅法。
boolean accept(File pathname) ：测试pathname是否应该包含在当前File⽬录中，符合则返
回true。
分析

1. 接⼝作为参数，需要传递⼦类对象，重写其中⽅法。我们选择匿名内部类⽅式，⽐较简单。
2. accept ⽅法，参数为File，表示当前File下所有的⼦⽂件和⼦⽬录。保留住则返回true，过
   滤掉则返回false。保留规则：
3. 要么是.java⽂件。
4. 要么是⽬录，⽤于继续遍历。
5. 通过过滤器的作⽤， listFiles(FileFilter) 返回的数组元素中，⼦⽂件对象都是符合条件
   的，可以直接打印。

public class DiGuiDemo4 {
 public static void main(String[] args) {
 File dir = new File("D:\\aaa");
 printDir2(dir);
 }
 public static void printDir2(File dir) {
 // 匿名内部类⽅式,创建过滤器⼦类对象
 File[] files = dir.listFiles(new FileFilter() {
 @Override
 public boolean accept(File pathname) {
 return pathname.getName().endsWith(".java") ||
pathname.isDirectory();
 }
 });
 // 循环打印
 for (File file : files) {
 if (file.isFile()) {
 System.out.println("⽂件名:" + file.getAbsolutePath());
 } else {
 printDir2(file);
 }
 }
 }
}