关于递归的一些练习

###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
    
}

}