IO流高级习题

1. 记录⼀个程序的使⽤次数，超过5次提示去注册

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

public class Work1 {
    public static void main(String[] args) throws IOException {
        File file = new File("zz.exe");
        if (!file.exists())
            file.createNewFile();
        FileInputStream inputStream = new FileInputStream(file);
        Properties properties = new Properties();
        properties.load(inputStream);

        int count = 1;
        String value = properties.getProperty("time");
        if (value != null)
            count = Integer.parseInt(value);
        if (count > 5){
            System.out.println("请注册");
        }
        count++;

        properties.setProperty("time",count+"");
        FileOutputStream outputStream = new FileOutputStream(file);

        properties.store(outputStream,"haha");

        inputStream.close();
        outputStream.close();
    }
}

2. 有五个学⽣，每个学⽣有3⻔课的成绩， 从键盘输⼊以上数据（包括姓名，三⻔课成绩）， 输⼊的格式：如：zhagnsan，30，40，60计算出总成绩， 并把学⽣的信息和计算出的总分数⾼低顺序存放在磁盘⽂件"stud.txt"中。

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

public class Work2 {
    public static void main(String[] args) throws IOException {
        File file = new File("Bigdataday20\\src\\file\\stud.txt");
        if (!file.exists())
            file.createNewFile();
        Compare bj = new Compare();

        TreeSet<String> ts = new TreeSet<>(bj);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        for (int i = 1; i <= 5; i++) {

            String line = null;
            System.out.println("请输⼊第" + i + "个学⽣的姓名和三⻔课的成绩");
            line = br.readLine();
            String ar = line;
            String arr[] = new String[4];
            arr = ar.split(",");
            int sum = Integer.parseInt(arr[1]) + Integer.parseInt(arr[2]) + Integer.parseInt(arr[3]);

            ts.add(arr[0] + "," + arr[1] + "," + arr[2] + "," + arr[3] + "," + sum + "");
        }
        br.close();
        FileWriter fw = new FileWriter(file);
        Iterator<String> ite = ts.iterator();
        while (ite.hasNext()) {
            String ss = ite.next();
            fw.write(ss);
            fw.write("\r\n");
            fw.flush();
        }
        fw.close();
    }
}

class Compare implements Comparator<String> {
    public int compare(String s1, String s2) {
        String ss1[] = new String[5];
        String ss2[] = new String[5];
        ss1 = s1.split(",");
        ss2 = s2.split(",");
        return Integer.parseInt(ss1[4]) - Integer.parseInt(ss2[4]);
    }
}

1. 【难】设计⼀个⽅法，计算⼀个⽂件夹的总⼤⼩（由所有的⼦⽂件、⼦⽂件夹中的⼦⽂件夹⼤⼩组成）

public class Demo1 {
    public static void main(String[] args) {
        long size = calculate(new File("Bigdataday20\\src\\file"));
        System.out.println(size);
    }

    private static long calculate(File file) {
        // 1. 判断是否是⼀个⽂件夹
        if (file.isDirectory()) {
            long length = 0;
            // 得到⼦⽂件夹下⾯所有的⽂件
            File[] files = file.listFiles();
            // 计算每⼀个⼦⽂件的⼤⼩
            for (File file1 : files) {
                length += calculate(file1);
            }
            return length;
        }else{
            return file.length();
        }
    }
}

2. 【简】在桌⾯上创建⼀个30层的⽂件夹

import java.io.File;

public class Demo2 {
    public static void main(String[] args) {
        String[] names = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n"};
        StringBuilder path = new StringBuilder("C:\\Users\\22150\\Desktop");

        for (int i = 0; i < 30; i++) {
            path.append(names[i% names.length]).append("\\");
        }

        boolean ret = new File(path.toString()).mkdirs();
        System.out.println(ret);
    }
}

3. 【中】获取桌⾯上所有的⾮隐藏的⽂件（不要⽂件夹）

import java.io.File;

public class Demo3 {
    public static void main(String[] args) {
        File file = new File("C:\\Users\\22150\\Desktop");
        File[] files = file.listFiles(f->!f.isHidden()&&f.isFile());
        for (File file1 : files) {
            System.out.println(file1);
        }
    }
}

4. 【中】递归删除⼀个⾮空的⽂件夹

import java.io.File;

public class Demo4 {
    public static void main(String[] args) {
        File file = new File("Bigdataday20\\src\\file");
        deleteDir(file);
    }

    private static void deleteDir(File file){
        // 1、获取⼀个路径下所有的⼦⽂件
        File[] files = file.listFiles();
        // 2、遍历这个数组，依次判断能否删除
        for (File f : files) {
            // 判断是⽂件还是⽂件夹
            if(f.isFile()){
                f.delete();
            }else if(f.isDirectory()){
                deleteDir(f);
                f.delete();
            }
        }
        file.delete();
    }
}

5. 【难】列举⼀个⽂件夹中的所有的⽂件，及⼦⽂件夹中的⼦⽂件

格式如下：
| a
|----|b
|----|c
|----|----|a.txt
|----|----|b.txt
|----|d
|----|----|e.mp4
|----|----|f
|----|----|----|a.avi

import java.io.File;

public class Demo5 {
    public static void main(String[] args) {
        showDir("C:\\Users\\22150\\Desktop");
    }

    private static void showDir(String file) {
        showDir(new File(file), 0);
    }

    private static void showDir(File file, int level) {
        // 1. 拼接前半部分缩进符
        StringBuilder builder = new StringBuilder("|");
        for (int i = 0; i < level; i++) {
            builder.append("----|");
        }
        // 2. 判断file本身
        builder.append(file.getName());
        // 3. 输出结果
        System.out.println(builder);
        // 4. 判断file是否是⽂件夹
        if (file.isDirectory()) {
            // 5. 获取所有⼦⽂件
            File[] files = file.listFiles();
            // 6. 递归输出
            for (File file1 : files) {
                showDir(file1, level + 1);
            }
        }
    }
}

6. 【难】设计⼀个⽅法，实现⼀个⽂件夹的拷⻉（包括⽂件夹中的⼦⽂件和⼦⽂件夹）

import java.io.*;

public class Demo6 {
    public static void main(String[] args) {
        // 思路：递归的思想。
        // 设计⼀个⽅法，作⽤是拷⻉⼀个⽂件中的所有的⼦⽂件。
        // 如果⼦⽂件也是⼀个⽂件夹，则再递归调⽤这个⽅法。
        
        copyDir(new File("Bigdataday20\\src\\file"),new File("Bigdataday19\\src\\file"));
    }

    /**
     * 拷贝文件夹
     * @param src   原路径
     * @param dst   拷贝路径
     */
    private static void copyDir(File src,File dst){
        // 1、先在⽬标位置创建⼀个⽂件夹
        dst.mkdirs();
        // 2、获取到源⽂件夹下⾯所有的⼦⽂件
        File[] files = src.listFiles();
        // 3、将每⼀个⼦⽂件拷⻉到⽬标⽂件夹下
        for (File file : files) {
            if(file.isDirectory()){
                // 拷⻉⽂件夹
                copyDir(file,new File(dst,file.getName()));
            }else{
                copyFile(file,new File(dst,file.getName()));
            }
        }
    }

    /**
     * ⽂件的拷⻉
     * @param src   原路径
     * @param dst   拷贝路径
     */
    private static void copyFile(File src,File dst){
        // 实例化两个流，读取源⽂件，往⽬标⽂件写
        try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dst))){

            // 1、实例化⼀个字节数组，⽤来存储每次读取到的数据
            byte[] array = new byte[1024];
            // 2、定义⼀个变量，⽤来记录每次读取到了多少数据
            int length = 0;
            // 3、循环读取数据
            while((length = bis.read())!=-1){
                bos.write(array,0,length);
                bos.flush();
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}