文件管理系统

编写⼀个⽂件管理系统，通过控制台的输出内容进⾏⽂件操作：

1 -创建⽂件、2-删除⽂件、3-复制⽂件和4-根据输⼊⽂件名称，读取⽂件内容执⾏对应的指令。

当⽤户输⼊1时， 会读取⽤户的下⼀⾏输⼊，会根据⽤户的名称和后续输⼊创建⼀个⽂件并将输⼊录⼊⽂件；当⽤户输⼊2，则会检索当前⽬录下的⽂件，如果⽂件存在，则删除该⽂件，否则， 提示⽂件不存在；当⽤户输⼊3，则读取⽤户输⼊的⽂件名称进⾏复制，默认是⽂件名称加后缀“.copy“标注；当⽤户输⼊4，会查找当前⽬录下的⽂件，如果⽂件存在， 则执⾏⽂件的⾏内容；当⽤户输⼊“exit”并在后续输⼊“Y”则退出当前系统

实现思路

1. ⾸先需要读取控制台的输⼊内容，获取⽤户想要处理的下⼀个操作内容
2. 根据输⼊的指令和输⼊内容，进⾏对应的操作，例如⽂件创建，创建的⽂件名称、⽂件内容等。
3. 当输⼊指定4时，需要读取⽂件内容，判断⽂件内容是否符合要求，如果内容复合要求，则循环执⾏⽂件内容。

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

public class FileSystemClient {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);   // 获取控制台输⼊的内容

        // ⽂件处理对象初始化
        FileOperator fo = new FileOperator();

        while (true) {
            System.out.println("1-创建⽂件\n2-删除⽂件\n3-复制⽂件\n4-执⾏⽂件\nexit-退出系统：");
            switch (scan.nextLine()) {
                case "1": fo.createFile(scan);break;
                case "2": fo.delFile(scan);break;
                case "3": fo.copyFile(scan);break;
                case "4": fo.execFile(scan);break;
                case "exit": System.exit(0);break;
                default: System.out.println("未知指令！请输⼊正确的指令:");break;
            }
        }
    }
}

class FileOperator {
    public static final String LINE_END_TAG = "\r\n";
    public static final String END_INPUT = "--END";

    // 创建⽂件并写⼊数据
    public void createFile(Scanner scanner) {
        System.out.println("请输入文件的名称:");
        String fileName = scanner.nextLine();       // 获取⽂件名称

        File file = new File(fileName);
        // 如果⽂件不存在，则创建⽂件
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("请输入想要写入文件的内容，以--END结束输入:");
        // 获取想要写⼊⽂件的内容
        String line = scanner.nextLine();

        try (BufferedWriter bw = new BufferedWriter(new FileWriter(file))) {
            while (true) {
                // 如果不是结束输⼊的标识，则直接结束输⼊
                if (END_INPUT.equals(line)) {
                    return;
                }
                bw.write(line.concat(LINE_END_TAG));
                line = scanner.nextLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("文件创建成功！请执行后续指令！");
    }

    // 删除⽂件
    public void delFile(Scanner scanner) {
        System.out.println("请输入想要删除的文件全路径:");
        String filePath = scanner.nextLine();

        File file = new File(filePath);
        if (file.exists() && file.isFile()) {
            // ⽂件存在且不是⽬录，则删除⽂件
            file.delete();
            //file.getAbsolutePath() 获得绝对路径
            System.out.println("⽂件删除成功！删除⽂件：" + file.getAbsolutePath());
        } else {
            System.out.println("⽂件不存在，⽆法删除！请执⾏后续指令！");
        }
    }

    // 复制⽂件
    public void copyFile(Scanner scanner) {
        System.out.println("请输⼊想要复制的⽂件全路径：");
        String filePath = scanner.nextLine();

        File file = new File(filePath);
        if (!file.exists()) {
            System.out.println("⽂件不存在！");
            return;
        }
        if (!file.isFile()) {
            System.out.println("不是⽂件，⽆法复制！");
            return;
        }
        // 获取⽂件路径
        String path = filePath.substring(0, filePath.lastIndexOf("\\") + 1);
        System.out.println("请输⼊想要复制到的⽂件名称：");
        String name = scanner.nextLine();

        File newFile = new File(path.concat(name));
        if (newFile.exists()) {
            System.out.println("⽬标⽂件已存在，是否要覆盖（Y/N）：");
            String tag = scanner.nextLine();
            if ("N".equals(tag)) {
                System.out.println("请输⼊想要复制到的⽂件名称：");
                name = scanner.nextLine();
                newFile = new File(path.concat(name));
            }
        }
        // 读取源⽂件内容并写⼊⽬标⽂件中
        try (FileInputStream fis = new FileInputStream(file);
             FileOutputStream fos = new FileOutputStream(newFile)) {
            byte[] buf = new byte[1024];
            // 读取数据
            while (fis.read(buf) != -1) {
                // 如果有内容，则进⾏⽂件写⼊
                fos.write(buf);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("⽂件复制成功！");
    }

    // 读取执⾏⽂件，进⾏⾮实事⽂件处理
    public void execFile(Scanner scanner) {
        System.out.println("请输⼊想要执⾏的执⾏⽂件：");
        String filePath = scanner.nextLine();

        File file = new File(filePath);
        if (!file.exists()) {
            System.out.println("执⾏⽂件不存在！");
            return;
        }
        if (!file.isFile()) {
            System.out.println("不是⽂件，⽆法进⾏执⾏！");
            return;
        }

        System.out.println("开始执⾏执⾏⽂件：");
        // 执⾏执⾏⽂件的逻辑
        try (BufferedReader br = new BufferedReader(new FileReader(file))) {
            String line = br.readLine();
            while (null != line && !"".equals(line)) {
                String[] infos = line.split(" ");
                switch (infos[0]) {
                    case "1": createFileByBatch(infos);break;
                    case "2": delFileByBatch(infos);break;
                    case "3": copyFileByBatch(infos);break;
                    default: System.out.println("指令错误！");break;
                }
                line = br.readLine(); // 读取下⼀⾏
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("结束执⾏执⾏⽂件！");
    }

    // 执⾏⽂件的⽂件创建⽅法
    public void createFileByBatch(String[] infos) {
        File file = new File(infos[1]);
        // ⽂件不存在就创建，否则覆盖
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // 没有默认写⼊的数据
        if (null == infos[2] || "".equals(infos[2])) {
            return;
        }
        // 将数据写⼊创建的⽂件中
        try (FileOutputStream fos = new FileOutputStream(file)) {
            for (int i = 2; i < infos.length; i++) {
                // 如果是⽂件结束
                if (END_INPUT.equals(infos[i])) {
                    System.out.println(" ⽂件创建内容插⼊结束！创建成功！");
                    return;
                }
                if (!LINE_END_TAG.equals(infos[2])) {
                    fos.write(infos[2].getBytes());
                    fos.write(" ".getBytes());
                } else {
                    fos.write(LINE_END_TAG.getBytes());
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("创建⽂件：" + infos[1] + " 成功！");
    }

    // 执⾏⽂件的⽂件删除⽅法
    public void delFileByBatch(String[] infos) {
        File file = new File(infos[1]);
        // ⽂件不存在就创建，否则覆盖
        if (!file.exists() || !file.isFile()) {
            System.out.println("⽂件不存在或者不是⽂件，⽆需删除！");
        } else {
            // ⽂件存在，则删除⽂件
            file.delete();
            System.out.println("⽂件删除成功！");
        }
    }

    // 执⾏⽂件的⽂件赋值⽅法
    public void copyFileByBatch(String[] infos) {
        File file = new File(infos[1]);

        File newFile = new File(infos[2]);

        if (!file.exists() || !file.isFile()) {
            System.out.println("⽂件不存在或者不是⽂件，⽆法复制！");
            return;
        }
        // 复制副本⽂件不存在则创建
        if (!newFile.exists()) {
            try {
                newFile.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // 读取⽬标数据，写⼊副本⽂件
        try (FileOutputStream fos = new
                FileOutputStream(newFile);
             FileInputStream fis = new
                     FileInputStream(file)) {
            byte[] b = new byte[1024];
            while (fis.read(b) != -1) {
                fos.write(b);
            }
            System.out.println("⽂件：" + infos[1] + " 复制成功,副本⽂件是：" + infos[2]);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}