基础4-高级-代码整理

1、统计文件夹大小
package exercise;
import java.io.File;
import java.util.Scanner;
/*
 * 获取文件夹路径，计算文件和文件夹个数
 * */
public class exercise {
    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 {
                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;
    }
}

2、删除该文件夹
package exercise;
import java.io.File;
import java.util.Scanner;
/*
 * 获取文件夹路径，删除文件夹
 * */
public class exercise {
    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 {
                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();
        }
    }
}

3、拷贝
package exercise;
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;
class exercise{
    /*
     * 创建两个文件夹，把其中一个文件夹内容拷贝到另一个文件夹中
     * */
    public static void main(String[] args) throws IOException {
        File src = getDir1();
        File dest = getDir2();
        if(src.equals(dest)) {
            System.out.println("目标文件夹是源文件夹的子文件夹");
        }else {
            copy(src,dest);
        }
    }
    public static File getDir1() {
        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 {
                return dir;//存在返回对象
            }
        }
    }
    public static File getDir2() {
        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 {
                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);
            }
        }
    }
}
4、按层级打印
package exercise;
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
class exercise{
    /*
     * 创建两个文件夹，把其中一个文件夹内容拷贝到另一个文件夹中
     * */
    public static void main(String[] args) throws IOException {
        File dir = getDir1();               //获取文件夹路径
        printLev(dir,0);
    }
    public static void printLev(File dir,int lev) {
        //1,把文件夹中的所有文件以及文件夹的名字按层级打印
        File[] subFiles = dir.listFiles();
        //2,遍历数组
        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);
            }
        }
    }
    public static File getDir1() {
        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 {
                return dir;//存在返回对象
            }
        }
    }

}
5、斐波那契数列
package exercise;
class exercise{
    public static void main(String[] args) {
        //demo1();
        System.out.println(fun(8));
    }

    public static void demo1() {
        //用数组做不死神兔
        int[] arr = new int[8];
        //数组中第一个元素和第二个元素都为1
        arr[0] = 1;
        arr[1] = 1;
        //遍历数组对其他元素赋值
        for(int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 2] + arr[i - 1];
        }
        //如何获取最后一个数
        System.out.println(arr[arr.length - 1]);
    }

    /*
     * 用递归求斐波那契数列
     */
    public static int fun(int num) {
        if(num == 1 || num == 2) {
            return 1;
        }else {
            return fun(num - 2) + fun(num - 1);
        }
    }

}
6、1000的阶乘所有零和尾部零的个数
package exercise;
import java.math.BigInteger;
class exercise{
    public static void main(String[] args) {
        demo2();
    }
    public static void demo2() {        //获取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();    //获取字符串表现形式
        StringBuilder sb = new StringBuilder(str);
        str = sb.reverse().toString();  //链式编程
        
        int count = 0;                  //定义计数器
        for(int i = 0; i < str.length(); i++) {
            if('0' != str.charAt(i)) {
                break;
            }else {
                count++;
            }
        }
        
        System.out.println(count);
    }
}
7、1000的阶乘尾部零的个数
package exercise;
class exercise{
    public static void main(String[] args) {
        System.out.println(fun(1000));
    }

    public static int fun(int num) {
        if(num > 0 && num < 5) {
            return 0;
        }else {
            return num / 5 + fun(num / 5);
        }
    }
}
8、约瑟夫环
package exercise;

import java.util.ArrayList;

class exercise{
    public static void main(String[] args) {
        System.out.println(getLucklyNum(8));
    }

    /*
     * 获取幸运数字
     * 1,返回值类型int
     * 2,参数列表int num
     */
    public static int getLucklyNum(int num) {
        ArrayList<Integer> list = new ArrayList<>();        //创建集合存储1到num的对象
        for(int i = 1; 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()) {                          //如果i增长到集合最大的索引+1时
                i = 0;                                      //重新归零
            }
            
            if(count % 3 == 0) {                            //如果是3的倍数
                list.remove(i--);                               //就杀人
            }
            count++;
        }
        
        return list.get(0);
    }
}