JavaSE基础——（23）File类递归练习

目录

一、统计文件夹大小

二、删除文件夹

三、文件的拷贝

四、按层级打印文件夹内容

五、斐波拉契数列

六、计算1000的阶乘

6.1非递归实现

6.2递归实现

七、约瑟夫环问题

---

 

一、统计文件夹大小

要求从键盘接收一个文件夹路径，统计该文件夹的大小，

import java.io.File;
import java.util.Scanner;

public class FileTest {
    private File dir;

    public static void main(String[] args){
        File dir=getDir();
        System.out.println("文件夹大小为："+getFileLength(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()){
                System.out.println("您录入的文件夹不存在，请重新录入：");
            }else if(dir.isFile()){
                System.out.println("您录入不是文件夹，请重新录入：");
            }else{
                return dir;
            }
        }
    }

    public static long getFileLength(File dir){
        long len=0;
        File subFiles[]=dir.listFiles();
        for (File subFile: subFiles) {
            if(subFile.isFile()){
                len=len+subFile.length();
            }else{
                len=len+getFileLength(subFile);
            }
        }
        return len;
    }
}

我们验证一下该文件夹的大小， 发现是一致的，

 

二、删除文件夹

要求现在有一个文件夹，里面装了一些文件夹和文件，从键盘接收该文件夹路径并递归删除该文件夹，

import java.io.File;
import java.util.Scanner;

public class FileTest {
    private File dir;

    public static void main(String[] args){
        File dir=getDir();
        deleteFile(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()){
                System.out.println("您录入的文件夹不存在，请重新录入：");
            }else if(dir.isFile()){
                System.out.println("您录入不是文件夹，请重新录入：");
            }else{
                return dir;
            }
        }
    }

    public static void deleteFile(File dir){
        File subFiles[]=dir.listFiles();
        for (File subFile: subFiles) {
            if(subFile.isFile()){
                subFile.delete();
            }else{
                deleteFile(subFile);
            }
        }
        dir.delete();
    }
}

我们首先创建一个文件夹，里面装一些垃圾文件和文件夹，看看能不能正常删除，

我们可以看到E盘里面已经没有deleteDir文件夹了，而且回收站里面也没有（用java删除文件要小心！），

 

三、文件的拷贝

要求从键盘接收两个文件夹路径，将第一个文件夹中的所有文件与文件夹拷贝到第二个文件夹中，

import java.io.*;
import java.util.Scanner;

public class FileTest {
    public static void main(String[] args) throws IOException {
        while(true){
            File src=getDir();
            File dest=getDir();
            if(src.equals(dest)){
                System.out.println("不允许目标文件夹和源文件夹相同！请重新输入！");
            }else{
                copy(src,dest);
                break;
            }
        }
    }

    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()){
                System.out.println("您录入的文件夹不存在，请重新录入：");
            }else if(dir.isFile()){
                System.out.println("您录入不是文件夹，请重新录入：");
            }else{
                return dir;
            }
        }
    }

    public static void copy(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{
                copy(subFile,newDir);
            }
        }
    }
}

我们新建两个文件夹，src装要拷贝的内容，dest为一个空文件夹，

然后把这两个文件夹路径作为参数输入到程序中，看看dest文件夹中有没有拷贝成功，

可以看到src中的文件都被拷贝到dest文件夹中来了，

 

四、按层级打印文件夹内容

要求从键盘接收一个文件夹路径，把所有文件夹中的所有文件和文件夹的名字按层级打印，

import java.io.*;
import java.util.Scanner;

public class FileTest {
    public static void main(String[] args) throws IOException {
        File dir=getDir();
        printLev(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()){
                System.out.println("您录入的文件夹不存在，请重新录入：");
            }else if(dir.isFile()){
                System.out.println("您录入不是文件夹，请重新录入：");
            }else{
                return dir;
            }
        }
    }

    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");
            }
            System.out.println(subFile);
            if(subFile.isDirectory()){
                printLev(subFile,lev+1);
            }
        }
    }
}

可以看到文件夹中的文件已经按照层级进行打印了，

 

五、斐波拉契数列

假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，

假设一年内没有发生死亡，请问一对刚出生的兔子，一年内可以繁殖成多少对兔子？

这种问题我们可以抽取为斐波拉契数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……

在数学上，斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*），

public class FileTest {
    public static void main(String[] args) throws IOException {
        System.out.println(Fibonacci(20));
    }

    public static int Fibonacci(int day){
        if(day==1||day==2){
            return 1;
        }else{
            return Fibonacci(day-1)+Fibonacci(day-2);
        }
    }
}

 

六、计算1000的阶乘

要求求出1000的阶乘所有零和尾部零的个数，

例如：100100，所有零的个数为4，尾部零的个数为2。

6.1非递归实现

import java.io.*;
import java.math.BigInteger;

public class FileTest {
    public static void main(String[] args) throws IOException {
        //利用BigInteger计算1000的阶乘
        BigInteger res=new BigInteger("1");
        for (int i = 1; i <= 1000; i++) {
            BigInteger temp=new BigInteger(i+"");
            res=res.multiply(temp);
        }

        //对结果的0进行计数
        String str=res.toString();//将结果转换为字符串形式
        int zerosAll=0;//所有0的个数计数器
        int zerosTail=0;//尾部0的个数计数器
        boolean flag=true;
        for (int i = str.length()-1; i >0; i--) {
            if('0'==str.charAt(i)){
                if(flag){
                    zerosTail++;
                }
                zerosAll++;
            }else if(flag){
                flag=false;
            }
        }

        System.out.println("所有零个数为："+zerosAll);
        System.out.println("尾部零个数为："+zerosTail);
    }
}

 

6.2递归实现

这里的递归实现，是实现的求解1000的阶乘的过程，后面对0进行计数是相同的方法，

import java.io.*;
import java.math.BigInteger;

public class FileTest {
    public static void main(String[] args) throws IOException {
        //利用BigInteger计算1000的阶乘
        BigInteger res=Factorial(1000);

        //对结果的0进行计数
        String str=res.toString();//将结果转换为字符串形式
        int zerosAll=0;//所有0的个数计数器
        int zerosTail=0;//尾部0的个数计数器
        boolean flag=true;
        for (int i = str.length()-1; i >0; i--) {
            if('0'==str.charAt(i)){
                if(flag){
                    zerosTail++;
                }
                zerosAll++;
            }else if(flag){
                flag=false;
            }
        }

        System.out.println("所有零个数为："+zerosAll);
        System.out.println("尾部零个数为："+zerosTail);
    }

    public static BigInteger Factorial(int num){
        if(num<0){
            System.out.println("负数没有阶乘！");
            return new BigInteger(-1+"");
        }else if(num ==0||num==1){
            return new BigInteger(1+"");
        }else{
            return Factorial(num-1).multiply(new BigInteger(num+""));
        }
    }
}

 

七、约瑟夫环问题

据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。那么一开始站在什么位置可以保证活下来呢？这就是著名的约瑟夫环问题。

import java.util.ArrayList;

public class FileTest {
    public static void main(String[] args){
        System.out.println(getLuckyNum(41));
    }

    public static int getLuckyNum(int num){
        ArrayList list=new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(i);
        }
        int count=1;//计数器
        for (int i = 0; list.size()!=1 ; i++) {
            if(i==list.size()){//如果到最后一个人，则接着第一个人继续报数
                i=0;
            }
            if(count%3==0){
                list.remove(i--);//当count为3的倍数时从列表中移除当前元素
                //注意这里要i--，指针若继续++则会跳过一个人
            }
            count++;
        }
        return list.get(0)+1;//返回最后一个人的初始位置编号（从1开始编号）
    }
}