day23-递归练习/集合练习

23.01_File类递归练习(统计该文件夹大小)

• 需求:1,从键盘接收一个文件夹路径,统计该文件夹大小

/**
 * 统计文件夹大小
 */
public static long getFileLength(File file) {
    long length = 0;
    for (File f : file.listFiles()) {
        if (f.isFile()) {
            length += f.length();
        }else {  //文件夹就递归
            length += getFileLength(f);  
        }
    }
    return length ;
}

/**
 * 键盘录入文件夹路径
 * @return 文件夹路径
 */
public static File getDir() {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入文件夹路径...");
    
    while(true) {
        File file = new File(sc.nextLine());
        if (!file.exists()) {  //是否存在路径或文件
            System.out.println("路径不存在，请重新输入...");
            continue;
        } else if(file.isFile()) { //是文件，就以当前文件所在文件夹为目标文件夹
            sc.close();
            return file.getParentFile();
        } else {
            sc.close();
            return file ;
        }
    }
}

long size = getFileLength(getDir());
float t = (float) (size / 1024.0 / 1024.0 / 1024.0);
DecimalFormat df = new DecimalFormat("#.##");    //四舍五入保留小数
System.out.println("文件夹大小是: " + df.format(t) + "GB");
System.out.println("文件夹大小是: " + t + "字节");

23.02_File类递归练习(删除该文件夹)

• 需求:2,从键盘接收一个文件夹路径,删除该文件夹

/**
 * 删除文件夹
 * @param file 文件夹路径
 */
public static void deleteFile(File file) {
    for (File f : file.listFiles()) {  //如果文件夹不是空的，那么delete()是删不掉的，
        if (f.isFile()) {
            f.delete();  //文件就直接删除
        } else {
            deleteFile(f);  //递归删除文件夹子内容
        }
    }
    file.delete();
}

23.03_File类递归练习(拷贝)

• 需求:3,从键盘接收两个文件夹路径,把其中一个文件夹中(包含内容)拷贝到另一个文件夹中

/**
 * 将path1文件内的子内容拷贝到path2文件夹内
 * @param initPath 源文件夹路径
 * @param path1 源文件夹路径
 * @param path2 目标文件夹
 * @throws IOException
 */
public static void copyFile(String initPath, File path1, File path2) throws IOException {
    if (path1.equals(path2)) return ; //防止相同文件夹造成死循环
    
    for (File subFile : path1.listFiles()) {
        if (subFile.isFile()) {  // 是否文件直接拷贝
            // 处理路径问题，拷贝过去，要求层级目录不变
            String path = subFile.getPath();
            String sp = path.substring(initPath.length()); //得到文件的层级结构
            File newDir = new File(path2.getPath() + sp).getParentFile();
            if (!newDir.exists()) {  //在新文件夹下，建立层级结构
                newDir.mkdirs();
            }
            FileInputStream fis = new FileInputStream(subFile);
            FileOutputStream fos = new FileOutputStream(path2.getPath() + sp);
            
            byte[] data = new byte[1024 * 10];
            int len ;
            while( (len = fis.read(data)) != -1) {
                fos.write(data, 0, len);
            }
            
            fis.close();
            fos.close();
        } else {  // 文件夹就递归
            copyFile(initPath, subFile, path2);
        }
    }
}

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

• 需求:4,从键盘接收一个文件夹路径,把文件夹中的所有文件以及文件夹的名字按层级打印

/**
 * 按层级结构打印文件夹目录
 * @param file 文件夹路径
 * @param lev 递归计数器，调用时，必须传入0
 */
public static void printFile(File file , int lev) {
    for ( File subFile : file.listFiles() ) {
        
        for(int i = 0 ; i < lev ; i++) { //打印层级结构，这种思路很巧妙
            System.out.print("\t");
        }
        System.out.println(subFile); //无论是文件还是文件夹，都需要直接打印
        
        if (subFile.isDirectory()) {  //是文件夹就递归
            printFile(subFile, lev+1); //这里不能 ++ 运算符，思考一下为什么
        }
    }
}

23.05_递归练习(斐波那契数列)

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

// 方法二： 递归解决
public static int fun(int mou) {  // mou为任意月份，返回此月份的兔子数量
    if (mou == 1 || mou == 2) {
        return 1 ;
    }
    return fun(mou - 2) + fun(mou - 1) ;
}

// 方法一： 数组解决
public static void demo1() {
    int[] arr = new int[12];  //长度就是多少个月份
    arr[0] = 1;  //根据数列规律，前2个数的和就是第三个的数，而前2个数确定是1
    arr[1] = 1;
    
    // 遍历数组，对其他月份赋值
    for (int i = 2; i < arr.length; i++) {
        arr[i] = arr[i-1] + arr[i-2]; 
    }
    
    System.out.println(arr[12]);
}

23.06_递归练习(1000的阶乘所有零和尾部零的个数)

• 需求:求出1000的阶乘所有零和尾部零的个数,不用递归做

BigInteger bi1 = new BigInteger("1");
for(int i = 1 ; i <= 1000 ; i++) {
    BigInteger bi2 = new BigInteger(i+"");
    bi1 = bi1.multiply(bi2); //将 bi1 和 bi2的结果相乘再赋值给bi1
}
String str = bi1.toString();
int count = 0 ;
for (char c : str.toCharArray()) {
    if ('0' == c) count++ ;
}
System.out.println("所有零的个数：" + count);

// 字符串反转 (链式编程)，最好记住下面的方法
str = new StringBuilder(str).reverse().toString();
int num= 0 ;
for(char c : str.toCharArray()) {
    if('0' != c) break ;
    num++;
}
System.out.println("尾部零的个数：" + num);

23.07_递归练习(1000的阶乘尾部零的个数)

• 需求:求出1000的阶乘尾部零的个数,用递归做

public static int fun(int num) {
    if (num > 0 && num < 5) {
        return 0;
    } else {
        return num / 5 + fun(num / 5);
    }
}
// 推导过程十分麻烦，百度吧，比如下面链接的讲解
http://blog.csdn.net/yahohi/article/details/7528803

23.08_集合练习(约瑟夫环)

• 幸运数字

/**
 * 约瑟夫环，幸运数字
 * @param num 人数，多少人进约瑟夫环游戏
 * @return 最后那个幸运的人的位置
 */
public static int getLuckNum(int num) {
    ArrayList list = new ArrayList<>();  
    for (int i = 1; i <= num; i++) { //将1...num个元素存储到集合里
        list.add(i);
    }
    
    int count = 1 ;  //用来数数，计算器，只要是3的倍数就杀人
    for(int i = 0; list.size() != 1 ; i++) {  //只要集合人数不是1，就循环杀人
        if (i == list.size()) i = 0 ; //到数组末尾，就重新从头开始遍历
        if (count % 3 == 0) list.remove(i--);  //如果是3的倍数，就杀人。,--是因为数组元素减少了，索引也要跟着减少
        count++;
    }
    return list.get(0);
}

END。
我是小侯爷。
在魔都艰苦奋斗，白天是上班族，晚上是知识服务工作者。
如果读完觉得有收获的话，记得关注和点赞哦。
非要打赏的话，我也是不会拒绝的。