【JAVA基础】24 递归练习
2021-05-07 16:30
标签：strong spl 删除 list mamicode 优点 打印 txt lap 5的阶乘 需求：从键盘输入接收一个文件夹路径，打印出该文件夹下所有的.java文件名 需求：从键盘接收一个文件夹路径，统计该文件夹大小 需求：从键盘接收一个文件夹路径，删除该文件夹 需求：从键盘接收两个文件夹路径，把其中一个文件夹中(包含内容)拷贝到另一个文件夹中 需求：从键盘接收一个文件夹路径，把文件夹中的所有文件以及文件夹的名字按层级打印。 例如：aaa是文件夹，里面有bbb.txt,ccc.txt,ddd.txt这些文件，有eee这样的文件夹，eee中有fff.txt和ggg.txt，打印出层级来 aaa bbb.txt ccc.txt ddd.txt 不死神兔 故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契。 在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，一年内没有发生死亡， 问：一对刚出生的兔子，一年内繁殖成多少对兔子? 1 1 2 3 5 8 13 第一个月一对小兔子 1 第二个月一对大兔子 1 第三个月一对大兔子生了一对小兔子 2 第四个月一对大兔子生了一对小兔子，一对小兔子长成大兔子 3 第五个月两对大兔子生两对小兔子，一对小兔子长成大兔子 5 需求：求出1000的阶乘所有零和尾部零的个数，不用递归做 需求：求出1000的阶乘尾部零的个数，用递归做 幸运数字 【JAVA基础】24 递归练习 标签：strong spl 删除 list mamicode 优点 打印 txt lap 原文地址：https://www.cnblogs.com/zoe233/p/13180543.html1. 递归，就是方法自己调用自己。
View Code
View Code
2. 递归练习1：统计该文件夹大小
package com.heima.test;
import java.io.File;
import java.util.Scanner;
public class Test1 {
/**
需求：从键盘接收一个文件夹路径，统计该文件夹大小
*/
public static void main(String[] args) {
File dir = getDir();
System.out.println(getDirLength(dir));
}
/*
* 对键盘输入的路径进行条件判断
*/
public static File getDir() {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件夹路径：");
while(true){
String line = sc.nextLine();
File dir = new File(line);
if(dir.exists()) {
if(dir.isFile()) {
System.out.println("对不起，您输入的是文件路径，不是文件夹路径，请重新输入：");
} else if(dir.isDirectory()) {
return dir;
}
} else {
System.out.println("对不起，您输入的路径不存在，请重新输入：");
}
}
}
/*
* 统计该文件夹大小
* 1. 定义一个求和变量
* 2. 获取该文件夹下所有的文件和文件夹listFiles();
* 3. 遍历数组
* 4. 判断是否是文件就计算大小并累加
* 5. 判断是文件夹就递归调用
*/
public static long getDirLength(File dir) {
long dirLength = 0;
File[] subFiles = dir.listFiles();
for (File subFile : subFiles) {
if(subFile.isFile()) {
dirLength += subFile.length(); // length()方法无法直接获取文件夹的大小，返回值是0
} else {
dirLength += getDirLength(subFile);
}
}
return dirLength;
}
}
3. 递归练习2：删除该文件夹
package com.heima.test;
import java.io.File;
import java.util.Scanner;
public class Test2 {
/*
* 需求：从键盘接收一个文件夹路径，删除该文件夹
*/
public static void main(String[] args) {
File dir = getDir();
deleteDir(dir);
}
/*
* 对键盘输入的路径进行条件判断
*/
public static File getDir() {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件夹路径：");
while(true){
String line = sc.nextLine();
File dir = new File(line);
if(dir.exists()) {
if(dir.isFile()) {
System.out.println("对不起，您输入的是文件路径，不是文件夹路径，请重新输入：");
} else if(dir.isDirectory()) {
return dir;
}
} else {
System.out.println("对不起，您输入的路径不存在，请重新输入：");
}
}
}
/*
* 删除文件夹
* 1. 获取该文件夹下的所有文件和文件夹
* 2. 遍历数组
* 3. 判断是文件直接删除
* 4. 如果是文件夹，递归调用
* 5. 循环结束后，把文件夹删掉
*/
public static void deleteDir(File dir) {
File[] subFiles = dir.listFiles();
for (File subFile : subFiles) {
if(subFile.isFile()) {
subFile.delete();
} else {
deleteDir(subFile);
}
}
dir.delete();
}
}
4. 递归练习3：文件夹拷贝
package com.heima.test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
public class Test3 {
/**
需求：从键盘接收两个文件夹路径，把其中一个文件夹中(包含内容)拷贝到另一个文件夹中
* @throws IOException
*/
public static void main(String[] args) throws IOException {
File src = getDir();
File dest = getDir();
if(src.equals(dest)) {
System.out.println("目标文件夹和源文件夹名一致，请重新输入");
}else {
copyDir(src,dest);
}
}
/*
* 对键盘输入的路径进行条件判断
*/
public static File getDir() {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件夹路径：");
while(true){
String line = sc.nextLine();
File dir = new File(line);
if(dir.exists()) {
if(dir.isFile()) {
System.out.println("对不起，您输入的是文件路径，不是文件夹路径，请重新输入：");
} else if(dir.isDirectory()) {
return dir;
}
} else {
System.out.println("对不起，您输入的路径不存在，请重新输入：");
}
}
}
/*
* 把其中一个文件夹中(包含内容)拷贝到另一个文件夹中
* 1. 在目标文件夹下面创建原文件夹
* 2. 获取文件夹下面的所有文件和文件夹
* 3. 遍历数组
* 4. 判断如果是文件，则用io流实现拷贝
* 5. 如果是文件夹，则递归调用该文件夹
*/
public static void copyDir(File src, File dest) throws IOException {
File newDir = new File(dest, src.getName());
newDir.mkdir();
File[] subFiles = src.listFiles();
for (File subFile : subFiles) {
if(subFile.isFile()) {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(subFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File(newDir,subFile.getName())));
int b;
while((b = bis.read()) != -1) {
bos.write(b);
}
bis.close();
bos.close();
} else {
copyDir(subFile, newDir);
}
}
}
}
5. 递归练习4：按层级打印
eee
fff.txt
ggg.txtpackage com.heima.test;
import java.io.File;
import java.util.Scanner;
public class Test4 {
/**
需求：从键盘接收一个文件夹路径，把文件夹中的所有文件以及文件夹的名字按层级打印。
例如：aaa是文件夹，里面有bbb.txt,ccc.txt,ddd.txt这些文件，有eee这样的文件夹，eee中有fff.txt和ggg.txt，打印出层级来
aaa
bbb.txt
ccc.txt
ddd.txt
eee
fff.txt
ggg.txt
*/
public static void main(String[] args) {
File dir = getDir();
print(dir,0);
}
/*
* 对键盘输入的路径进行条件判断
*/
public static File getDir() {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件夹路径：");
while(true){
String line = sc.nextLine();
File dir = new File(line);
if(dir.exists()) {
if(dir.isFile()) {
System.out.println("对不起，您输入的是文件路径，不是文件夹路径，请重新输入：");
} else if(dir.isDirectory()) {
return dir;
}
} else {
System.out.println("对不起，您输入的路径不存在，请重新输入：");
}
}
}
/*
* 把文件夹中的所有文件以及文件夹的名字按层级打印
* 1. 获取所有的文件夹和文件数组
* 2. 遍历数组
* 3. 无论是文件夹还是文件，都需要直接打印
* 4. 判断目录，则递归调用
*/
public static void print(File dir, int lev) {
File[] subFiles = dir.listFiles();
for (File subFile : subFiles) {
for(int i = 0; i ) {
System.out.print("\t");
}
System.out.println(subFile);
if(subFile.isDirectory()) {
print(subFile,++lev);
}
}
}
}
6. 递归练习5：斐波那契数列
package com.heima.test;
public class Test5 {
/*
* 斐波那契数列
* 1 1 2 3 5 8 13
*/
public static void main(String[] args) {
System.out.println(fib(9));
demo1(2);
}
/*
* 用递归实现斐波那契数列
*/
public static int fib(int num) {
if(num == 1 || num == 2) {
return 1;
} else {
return fib(num - 2) + fib(num - 1);
}
}
/*
* 用数组遍历的方式实现斐波那契数列
*/
public static void demo1(int num) {
int[] arr = new int[num];
// 数组中的第一个元素和第二个元素都为1
arr[0] = 1;
arr[1] = 1;
// 遍历数组，对其他元素进行赋值
for(int i = 2; i ) {
arr[i] = arr[i - 2] + arr[i - 1]; // arr[2] = arr[0] + arr[1];
}
System.out.println(arr[arr.length - 1]);
}
}
7. 递归练习6：1000的阶乘 所有零和尾部零的个数
package com.heima.test;
import java.math.BigInteger;
public class Test6 {
/**
* 需求:求出1000的阶乘所有零和尾部零的个数，不用递归做
* 需求:求出1000的阶乘尾部零的个数，用递归做
* 如：102220002222000
* 所有零就是：7个
* 尾部零就是：3个
*/
public static void main(String[] args) {
demo1();
}
/*
* 需求:求出1000的阶乘所有零和尾部零的个数，不用递归做
*/
public static void demo1() {
// 1. 计算出1000的阶乘
/*int result = 1;
for (int i = 1; i */
BigInteger bi1 = new BigInteger("1");
for (int i = 1; i ) {
BigInteger bi2 = new BigInteger(i + "");
bi1 = bi1.multiply(bi2); // 将bi1 和 bi2 相乘的结果赋值为bi1
}
String str = bi1.toString(); // 获取字符串表现形式
int count = 0;
for (int i = 0; i ) {
if(‘0‘ == str.charAt(i)) {
count++;
}
}
// 所有零的个数，1000的阶乘的所有零的个数应该为472
System.out.println("1000的阶乘中所有的零：" + count);
// 将1000阶乘的结果存储到StringBuilder中，反转后，遍历，计算前面的0的个数，遇到非0直接跳出循环
StringBuilder sb = new StringBuilder(str);
str = sb.reverse().toString();
int endCount = 0;
for (int i = 0; i ) {
if(‘0‘ == str.charAt(i)) {
endCount++;
} else {
break;
}
}
System.out.println("1000的阶乘中结尾的零：" + endCount);
}
}
package com.heima.test;
public class Test7 {
/**
* @param args
* 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100...1000 1000 / 5 = 200
* 5 * 5 5 * 5 * 2 5 * 5 * 3 5 * 5 * 4 5 * 5 * 5 5 * 5 * 6 200 / 5 = 40
* 5 * 5 * 5 * 1 5 * 5 * 5 * 2 5 * 5 * 5 * 3 5 * 5 * 5 * 4 5 * 5 * 5 * 5 5 * 5 * 5 * 6 5 * 5 * 5 * 7 5 * 5 * 5 * 8
40 / 5 = 8
5 * 5 * 5 * 5 8 / 5 = 1
*/
public static void main(String[] args) {
System.out.println(fun(1000));
}
// 需求：求出1000的阶乘尾部零的个数，用递归做
public static int fun(int num) {
if(num > 0 && num ) {
return 0;
}else {
return num / 5 + fun(num / 5);
}
}
}
8. 递归练习7：约瑟夫环
package com.heima.test;
import java.util.ArrayList;
public class Test8 {
/**
* 约瑟夫环
*/
public static void main(String[] args) {
System.out.println(getLucklyNum(8));
}
/*
* 获取幸运数字
*/
public static int getLucklyNum(int num) {
ArrayList