关于递归的一些练习

###23.01_File类递归练习(统计该文件夹大小)
* 需求:1,从键盘接收一个文件夹路径,统计该文件夹大小
* /**
 * 从键盘接收一个文件夹路径
 * 1.创建键盘录入对象
 * 2.定义一个无限循环（可能录错）
 * 3.将键盘录入的结果存储并封装成File对象
 * 4.对File对象判断
 * 5.将文件夹路径对象返回

 
 * 统计该文件夹大小
 * 1.定义一个求和变量
 * 2.获取该文件夹下所有的文件和文件夹listFiles();
 * 3.遍历数组
 * 4.判断是文件就计算大小并累加（数组中可能是文件也可能是文件夹）
 * 5.判断是文件夹，递归调用（文件夹不能直接获取大小）

 
 * */    

public static void main(String[] args) {
//         File dir = new File("D:\\desktoppicture");
//         System.out.println(dir.length());     //输出为0
File dir = getDir();
System.out.println(getFileLength(dir));

}

/*从键盘获取文件夹路径
* 1.方法的返回值为File
* 2.参数列表无
* */
public static File getDir(){

//        1.创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件夹路径：");
//        2.定义一个无限循环
while(true){
String line = sc.nextLine();
//             3.将键盘录入的结果存储并封装成File对象
File dir= new File(line);
//            4.对File对象判断
if(!dir.exists()){
System.out.println("您录入的文件夹路径不存在，请输入一个文件夹路径：");
}else if(dir.isFile()){
System.out.println("您输入的是文件路径，请输入一个文件夹路径:");

}else{
//                5.将文件夹路径返回
return dir;
}

}
}

/*统计该文件夹大小
* 返回值类型long
* 参数列表 File dir
*
* */
public static long getFileLength(File dir){
//        1.定义一个求和变量
long len = 0;
//        2.获取该文件夹下所有的文件和文件夹listFiles();
File[] subFiles = dir.listFiles();
//        3.遍历数组
for (File subFile : subFiles) {
//            4.判断是文件就计算大小并累加（数组中可能是文件也可能是文件夹）
if(subFile.isFile()){
len=subFile.length()+len;
//                5.判断是文件夹，递归调用（文件夹不能直接获取大小）
}else if(subFile.isDirectory()){
len = getFileLength(subFile)+len;
}
}
return len;
}

}

###23.02_File类递归练习(删除该文件夹)
* 需求:2,从键盘接收一个文件夹路径,删除该文件夹
    /*
     * 删除该文件夹
     * 1.获取文件夹下的所有文件和文件夹
     * 2.遍历数组
     * 3.判断是文件直接删除
     * 4.如果是文件夹，递归调用
     * 5.循环结束以后删除空文件夹
     * 
     * 
     * */
    

public static void main(String[] args) {
//        静态方法可以直接类名.调用
File file = Test1.getDir();
deleteFile(file);

}
/*1.方法返回值类型是void
* 2.方法的参数列表是File dir
*
* */
public static void deleteFile(File dir){
//        1.获取文件夹下的所有文件和文件夹
File[] subFiles = dir.listFiles();
//    2.遍历数组
for (File subFile : subFiles) {
//            3.判断是文件直接删除
if(subFile.isFile()){
subFile.delete();
//                4.如果是文件夹，递归调用
}else{
deleteFile(subFile);
}
}
dir.delete();
}
}

###23.03_File类递归练习(拷贝)
* 需求:3,从键盘接收两个文件夹路径,把其中一个文件夹中(包含内容)拷贝到另一个文件夹中
* /*
     * 分析：
     * 1.在目标文件夹中创建源文件夹
     * 2.获取源文件夹所有文件和文件夹，存储在File数组中
     * 3.遍历数组
     * 4.如果是文件就用io流读写
     * 5.如果是文件夹就递归调用
     * */            
public static void main(String[] args) throws IOException {
File src= Test1.getDir();
File dest = Test1.getDir();
if(src.equals(dest)){
System.out.println("此文件夹是目标文件的子文件夹");
}else{
copy(src,dest);
}
}
/*
* 返回值类型void
* 参数列表File src,File dest
* */
public static void copy(File src,File dest) throws IOException{
// 1.在目标文件夹中创建源文件夹
File newDir = new File(dest,src.getName());
newDir.mkdir();
// 2.获取源文件夹所有文件和文件夹，存储在File数组中
File[] subFiles = src.listFiles();
// 3.遍历数组
for (File subFile : subFiles) {
// 4.如果是文件就用io流读写(可以看看字节流和字符流的区别)
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{
// 如果是文件夹，递归调用
// subfile就是原来src里面的day07 newDir就是dest中的src
copy(subFile,newDir);
}
}
}
}


###23.04_File类递归练习(按层级打印)

需求:4,从键盘接收一个文件夹路径,把文件夹中的所有文件以及文件夹的名字按层级打印, 例如:
    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

/*
 * 获取文件夹，直接打印
 * 分析
 * 1.获取所有的文件和文件夹，返回的File数组
 * 2.遍历数组
 * 3.无论是文件还是文件夹，都需要直接打印
 * 4、如果是文件夹，递归调用
 * 
 * 分层级打印 即在前面添加TAB即可
 * */    

public static void main(String[] args) {
File dir = Test1.getDir();
int lev = 0;
printLev(dir,lev);

}

public static void printLev(File dir,int lev) {
// 把文件夹中的所有文件都打印
File[] subFiles = dir.listFiles();
for (File subFile : subFiles) {
for(int i =0;i<=lev;i++){
System.out.print("\t");
}
//        3.无论是文件还是文件夹，都需要直接打印
System.out.println(subFile);
//         4、如果是文件夹，递归调用
if(subFile.isDirectory()){
printLev(subFile,lev+1);
//        printLev(subFile,lev++);       不能用lev++或者++lev   因为这样的话 前面的lev的也会变化
}
}
}
}

###23.05_递归练习(斐波那契数列)
* 不死神兔
* 故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契。
* 在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，一年内没有发生死亡，
* 问：一对刚出生的兔子，一年内繁殖成多少对兔子?
* 1 1 2 3 5 8 13
* 第一个月一对小兔子                    1
* 第二个月一对大兔子                    1
* 第三个月一对大兔子生了一对小兔子        2
* 第四个月一对大兔子生了一对小兔子
*          一对小兔子长成大兔子            3
* 第五个月两对大兔子生两对小兔子    
*          一对小兔子长成大兔子            5

package com.heima.test;

public class Test5 {
public static void main(String[] args) {
/*斐波那契数列
* 分析 (用数组来做)
* 第一个月 1
* 第二个月1
* 第三个月2
* 第四个月3
* 第五个月5
* arr[0]=1 arr[1]=1 arr[2]=arr[0]+arr[1]
* */
//        int[] arr = new int[8];
//          arr[0]=1;
//          arr[1]=1;
//          for(int i = 2;i<arr.length;i++){
//              arr[i]=arr[i-1]+arr[i-2];
//          }
//          System.out.println(arr[arr.length-1]);
//分析（调用函数）
//          fun(1)=1 fun(2)=1 fun(3)=fun(2)+fun(1)
System.out.println(fun(8));

}
/*函数返回值是int
* 参数列表int num
*
* */
public static int fun(int num) {
if(num==1||num==2){
return 1;
}else{
return fun(num-1)+fun(num-2);
}
}

}

```

###23.06_集合练习(约瑟夫环)
* 幸运数字

```
package com.heima.test;

import java.util.ArrayList;
import java.util.List;

public class Test6 {
// 约瑟夫环
//    遇到3的倍数就杀人
/*
* 分析：用集合来做
* 设置一个指针
* 设置一个计数器
*
* */
public static void main(String[] args) {
System.out.println(getLucklyNumber(8));
}

public static int getLucklyNumber(int num) {
List<Integer> list =  new ArrayList<>();//创建一个存储1到num的容器
for(int i =0;i<num;i++){
list.add(i);//将1到num存储到集合中
}
int count =1;//创建一个计数器用来数数的  到3的倍数就杀人

for(int i =0;list.size()!=1;i++){//只要集合的个数大于1就不断杀
if(i==list.size()){//只要索引等于集合的最大索引+1
i=0;//就重新归0
}
if(count%3==0){
list.remove(i--);//集合被remove一个以后，会自动往前进1
}
count++;
}
return list.get(0);//最后只有一个人  索引肯定是0

}

}