模拟文件管理系统

学校的期末课程设计，进行一个简单的分享，不足之处请各位大佬指正。

一、主要内容

综合运用操作系统理论知识和编程知识设计实现一个可视化操作的文件管理模拟系统，该系统包含的基本信息：创建用户、登录用户、创建文件、删除文件、打开文件、显示文件、关闭文件等信息，能显示文件内容（50字符换行显示）、更改文件内容和更改文件名，并能修改文件的读写权限控制，支持查看文件的属性，主要包括：文件类型、文件大小、创建时间、文件权限、修改时间等。

二、效果展示

1.登录注册和模拟磁盘划分的实现

2.功能展示

3.磁盘目录

![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/6f739ecb3b3a41789829a8878c801b80.png4.目录创建和文件创建

4.目录和文件的创建

实现多级子目录的创建

5.实现文件的读写权限

6.修改文件名

7.删除目录和文件

大致功能演示完毕

大致代码实现

主要实现类

用户类

在public class User {
    // 用户名
    private String UserName;
    // 密码
    private String Password;
    private MyDisk disk;
    // 是否对磁盘分区
    private boolean flag;
    public User(String userName, String password){
        UserName = userName;
        Password = password;
    }
    public User(String userName, String password, MyDisk disk) {
        UserName = userName;
        Password = password;
        this.disk = disk;
    }
    public User(){}
    public String getUserName() {
        return UserName;
    }

    public void setUserName(String userName) {
        UserName = userName;
    }

    public String getPassword() {
        return Password;
    }

    public void setPassword(String password) {
        Password = password;
    }

    public MyDisk getDisk() {
        return disk;
    }

    public void setDisk(MyDisk disk) {
        this.disk = disk;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

MyDirectory类主要属性

public class MyDirectory {
    private String name;
    // 目录创建时间
    private String createTime;
    // 目录修改时间
    private String updaTime;
    // 目录权限
    private String status;
    /*存储文件*/
    private Map<String, MyFile> files;

    /*下一个节点*/
    private MyDirectory nextNode;
    /*上一个节点*/
    private MyDirectory prevNode;
    /*根节点*/
    private MyDirectory rootDirectory;
    public MyDirectory(String name){
            this.name=name;
            this.rootDirectory =new MyDirectory();
            this.files=new HashMap<>();
    }
    public MyDirectory(){

    }
    }
    

MyDisk

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;

/**
 * @author GH Fire
 * @version 1.0
 * @description: TODO
 * @date 2024/5/12 21:25
 */
public class MyDisk {
    private long size;// 磁盘大小
    // 存储分区
    private HashMap<String,MyParts> parts;
    /* n 为创建磁盘数量*/
    public MyDisk(int n){
        // 存储分区
        this.parts = new HashMap<>();
        Scanner scanner=new Scanner(System.in);
        for (int i = 0; i < n; i++) {
            System.out.println("输入第"+(i+1)+"个磁盘名");
            String partName=scanner.next();
            System.out.print("输入"+partName+"的容量:");
            long length= scanner.nextLong();
            size+=length;
            parts.put(partName,new MyParts(partName, length));
        }

    }
    public MyDisk(){

    }
    public long getSize() {
      return size;
    }

    public void setSize(long size) {
        this.size = size;
    }

    public HashMap<String, MyParts> getParts() {
        return parts;
    }

    public void setParts(HashMap<String, MyParts> parts) {
        this.parts = parts;
    }
}

MyFile

主要属性

public class MyFile {
    //文件类型
    private String type;
    // 文件大小
    private long length;
    // 文件创建时间
    private String createTime;
    // 文件修改时间
    private String updaTime;
    // 文件权限
    private String status;
    // 文件名
    private String Name;
    // 文件内容
    private String string;

MyParts

模拟实现磁盘分区效果

import java.nio.file.FileSystem;
import java.time.LocalDateTime;

/**
 * @author GH Fire
 * @version 1.0
 * @description: TODO
 * @date 2024/5/12 21:40
 */
/*表示磁盘分区*/
public class MyParts {
    private String name;
    private long size; // 分区大小，以字节为单位
    private MyFileSystem fileSystem; // 分区上的文件系统*/
    /*文件数量*/
    private int fileCount;
    public int getFileCount() {
        return fileCount;
    }

    public void setFileCount(int fileCount) {
        this.fileCount = fileCount;
    }

    public MyParts(String name, long size) {
        this.size=size;
        this.name=name+":";
        this.fileSystem=new MyFileSystem(this);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public long getSize() {
        return size;
    }

    public void setSize(long size) {
        this.size = size;
    }

    public MyFileSystem getFileSystem() {
        return fileSystem;
    }

    public void setFileSystem(MyFileSystem fileSystem) {
        this.fileSystem = fileSystem;
    }

    /*-------creat 创建文件--------*/
    public MyFile create(String fileName,long length,String status,String Type){
        /*1.判断当前容量是否足够*/
            if(this.size<length){
                System.out.println("磁盘容量不足");
                return null;
            }else {
                MyFile myFile=new MyFile();
                // 创建时间
                /*2024-05-13T12:49:07.795777200*/
                String string=LocalDateTime.now().toString();
                int lastIndex=string.lastIndexOf(".");
                String createTime=string.substring(0,lastIndex);
                /*-----------------*/
                myFile.setCreateTime(createTime);
                myFile.setUpdaTime(createTime);
                myFile.setName(fileName);
                myFile.setLength(length);
                myFile.setStatus(status);
                myFile.setType(Type);
                /*  磁盘容量减少*/
                this.size-=length;
                /*文件数量增加*/
                this.fileCount++;
                return myFile;
            }

    }
}

MyFileSystem

大部分的功能都是在这个类中实现的

import java.time.LocalDateTime;
import java.util.*;
import java.util.regex.Pattern;

/**
 * @author GH Fire
 * @version 1.0
 * @description: TODO
 * @date 2024/5/12 22:40
 */
public class MyFileSystem {

    private MyParts parts;
    private MyDirectory rootDirectory; // 文件系统的根目录
    /*指向当前目录*/
    private MyDirectory currentDir;// 指向当前目录的一个指针
    private  HashMap<String,String> orders; /*命令表*/
    private HashMap<String,MyDirectory> dirMap;/*存储所有目录的绝对路径*/
    private ArrayList<String> filesList;/*存储所有文件的绝对路径*/
    /*存储下一级和上一级的目录*/
    private MyDirectory[] cd_arr=new MyDirectory[2];
    /*路径*/
    private String path;
    private long  fileOfSum;/*文件总容量*/
    public MyFileSystem(MyParts parts){
        this.parts=parts;
        this.rootDirectory=new MyDirectory(parts.getName()+"\\");
        this.currentDir=rootDirectory;
        this.dirMap =new HashMap<>();//初始化集合目录
        dirMap.put(rootDirectory.getName(),rootDirectory);
        this.orders=new HashMap<>();// 初始化命令集合
        this.filesList=new ArrayList<>();// 初始化存储文件的集合
        this.path=rootDirectory.getName();
        this.orderList();// 初始化指令
    }


    public MyFileSystem() {
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public MyDirectory getCurrentDir() {
        return currentDir;
    }


    public void setCurrentDir(MyDirectory currentDir) {
        this.currentDir = currentDir;
    }

    public HashMap<String, String> getOrders() {
        return orders;
    }

    public void setOrders(HashMap<String, String> orders) {
        this.orders = orders;
    }

    public MyParts getParts() {
        return parts;
    }

    public void setParts(MyParts parts) {
        this.parts = parts;
    }

    public MyDirectory getRootDirectory() {
        return rootDirectory;
    }

    public void setRootDirectory(MyDirectory rootDirectory) {
        this.rootDirectory = rootDirectory;
    }

    public HashMap<String, MyDirectory> getDirMap() {
        return dirMap;
    }

    public void setDirMap(HashMap<String, MyDirectory> dirMap) {
        this.dirMap = dirMap;
    }

    public ArrayList<String> getFilesList() {
        return filesList;
    }


    /*--------------------文件系统管理方法------------------------------------------------*/
    /*文件创建*/
    public void create(String fileName,String length,String status){
       // 1.判断文件是否有后缀名
            if(fileName.contains("."))
            {
                /*获取最后一个.的位置*/
                int lastIndex=fileName.lastIndexOf(".");
                String fileType=fileName.substring(lastIndex,fileName.length());// 获取文件后缀名称
                String absolute=this.getAbsolute(fileName);
                if(this.getFileByName(fileName)!=null){
                    System.out.println("文件已存在！");
                }else{
                    /*当前目录下存储文件的集合 局部的*/
                    /*获得当前绝对路径所对应的目录列*/

                    MyDirectory myDirectory = this.dirMap.get(this.path);
                    Map<String, MyFile> filesMap= myDirectory.getFiles();

                    // 3.创建文件
                        MyFile myFile = this.parts.create(fileName, Long.parseLong(length), status, fileType);
                        // 4.添加目录到集合
                        if (myFile != null) {
                            filesMap.put(fileName, myFile);
                            filesList.add(absolute);// 存储全局的文件名 用于 dir展示全部信息
                            this.fileOfSum+=myFile.getLength();
                            System.out.println("文件创建成功！");
                        } else {
                            System.out.println("文件创建失败");
                        }
                    }
                }else {
                System.out.println("输入文件后缀名！");
            }



    }
    /*删除文件，删除目录*/
    public void remove(String fileName){
        if(fileName.contains(".")){
            // 文件删除
            // 1.判断文件是否存在
            if(this.getFileByName(fileName)!=null){
                /*获得该文件大小*/
                MyFile f=this.getFileByName(fileName);
                long f_size=f.getLength();
                /*分区容量增加*/
                this.parts.setSize(parts.getSize()+f_size);
                /*文件数量减少*/
                this.parts.setFileCount(this.getFileNum()-1);
                /**/
                this.fileOfSum-=f.getLength();

                Map<String, MyFile> filesMap = this.getFilesMap(this.path);
                filesMap.remove(fileName);
                this.filesList.remove(this.path+"\\"+fileName);

            }
            else {
                System.out.println("文件不存在！");
            }
        }else
        {
            String absolute=this.getAbsolute(fileName);
            // 判断目录是否存在
            if (this.exitsDir(absolute)) {
                // 目录存在 获得这个目录对象  通过绝对路径
                MyDirectory currentDir=this.getDirByAbsolute(absolute);
                /*删除目录之前再次判断是否存在文件*/
                if(currentDir.getFiles().size()>0){
                    System.out.println("该目录存在文件！请先删除文件");
                }else{
                    /*------------删除逻辑-------------*/
                    /*如果这个目录节点是最后一个节点，则让这个目录的前一个的节点的nextNode为空*/
                    if(currentDir.getNextNode()==null){
                        MyDirectory prev=currentDir.getPrevNode();
                        prev.setNextNode(null);
                        // 让目录指针指向这个节点
                        this.currentDir=prev;

                    }else {
                        /*这个目录节点有前节点A和后节点C
                        * 让 A的后节点指向C
                        * 让C的前节点执行A
                        * */
                        MyDirectory prevNode=currentDir.getPrevNode();
                        MyDirectory nextNode=currentDir.getNextNode();
                        prevNode.setNextNode(nextNode);
                        nextNode.setPrevNode(prevNode);
                    }
                    // 在系统目录表中删除这个目录节点的信息
                    this.getDirMap().remove(absolute);
                }

            }
            else {
                System.out.println("目录不存在！");
            }
        }


    }
    /*写入文件*/
    public void write(String fileName){
        // 1.判断文件是否存在
        if(this.getFileByName(fileName)!=null){
            // 2.是否有w的权限
            MyFile f=this.getFileByName(fileName);
            if(f.getStatus().contains("w")||f.getStatus().contains("W")){
                Scanner scanner=new Scanner(System.in);
                StringBuilder sb=new StringBuilder();
                String close="close "+fileName;
                System.out.println("写入文件：");
                String nextLine;
                while (true) {
                    nextLine = scanner.nextLine();
                    if (nextLine.contains(close)) {
                        nextLine="";
                        break;
                    }
                    // 否则，将输入追加到StringBuilder中
                    sb.append(nextLine).append("\n");
                }
                /*判断写入文件是否超出指定大小*/
                if(sb.toString().length()>f.getLength()){
                    System.out.println("超出文件指定内容");
                }else{
                    /*写入信息*/
                    f.setString(sb.toString());
                  /*   修改文件时间*/
                    f.setUpdaTime(this.getNowTime());
                }

            }else {
                System.out.println("没有写入权限");
            }

        }
        else {
            System.out.println("文件不存在！");
        }
    }
    /*查看文件内容*/
    public void cat(String fileName){
        // 1.判断文件是否存在
        if(this.getFileByName(fileName)!=null){
            // 获取当前文件
            MyFile f=this.getFileByName(fileName);
            // 判断文件权限
            if(f.getStatus().contains("r")||f.getStatus().contains("R")){
                String string = f.getString();
                System.out.println(string);
            }else {
                System.out.println("文件没有r的权限");
            }
        }else {
            System.out.println("文件不存在！");
        }
    }
    /*查看文件属性*/
    public void file(String fileName){
        // 1.判断文件是否存在
        if(this.getFileByName(fileName)!=null){
           MyFile myFile=this.getFileByName(fileName);
            if (myFile != null) {
                System.out.println(myFile.toString());
            }
        }else {
            System.out.println("文件不存在！");
        }
    }
    /*重命名文件*/
    public void rename(String oldName,String newName){
        if(this.getFileByName(newName)!=null){
            System.out.println(newName+"已存在");
            return;
        }
        // 1.判断文件是否存在
        if(this.getFileByName(oldName)!=null){
//            MyFile myFile=this.exits(oldName);
            /*oldName 指向*/
            MyFile myFile1 = this.getFileByName(oldName);
            /*改名*/
            myFile1.setName(newName);
            /*修改文件时间*/
            myFile1.setUpdaTime(this.getNowTime());
            Map<String, MyFile> filesMap = this.getFilesMap(this.path);
            filesMap.remove(oldName);
            this.filesList.remove(this.path+"\\"+oldName);
            this.filesList.add(this.path+"\\"+newName);
            filesMap.put(newName,myFile1);

        }else {
            System.out.println("文件不存在！");
        }
    }

    /*显示当前用户所有文件,文件夹 dir userName*/
    public void show(){

            /*遍历所以文件名*/
            for (String fileName:this.filesList){
                System.out.println(fileName);
            }
            /*遍历所以目录名*/
        Set<String> dirNames = this.dirMap.keySet();
        for (String dirName:dirNames){
                System.out.println(dirName);
            }
    }
    /*命令提示*/
    public void help(){
        System.out.println("***********************************");
        System.out.println("create fileName length status |创建文件");
        System.out.println("rm [fileName][dirName]|删除文件 删除目录");
        System.out.println("cat fileName|查看文件内容");
        System.out.println("write fileName|写入文件");
        System.out.println("file fileName|查询文件属性");
        System.out.println("chmod fileName status|修改文件权限");
        System.out.println("rename oldName newName|重命名文件");
        System.out.println("dir userName|显示当前用户下的所有文件");
        System.out.println("df|产看磁盘");
        System.out.println("close fileName|关闭文件");
        System.out.println("return|返回登录界面");
        System.out.println("exit|退出程序");
        System.out.println("mkdir dirName|新建目录");
        System.out.println("ls|产看当前目录下文件和子目录");
        System.out.println("cd[dirName][..]|进入子目录或或者退出");
        System.out.println("***********************************");
    }
    /*显示磁盘空间使用情况*/
    public void display(MyDisk disk){
        HashMap<String, MyParts> map = disk.getParts();
        Collection<MyParts> values = map.values();

        System.out.println("分区名---------文件数量---------使用容量---------剩余容量");
        long allUsed=0;
        for (MyParts myParts :values ) {
            String partName = myParts.getName();
            int fileNums = myParts.getFileCount();
            long used = myParts.getFileSystem().getSystemFileSize();
            long Available = myParts.getSize();
            allUsed+=used;
            System.out.println(partName + "             " + fileNums + "             " + used + "Byte" + "             " + Available + "Byte");

        }
        System.out.println("**************************************************");
        System.out.println("系统总容量:"+disk.getSize()+"Byte      使用容量:"+allUsed+"Byte        剩余容量:"+(disk.getSize()-allUsed)+"Byte");
        /*分区名---------文件数量--------------使用容量------剩余容量------*/

    }
    /*修改文件权限*/
    public void chmod(String fileName,String status){
        //1.判断文件是否存在
        if(this.getFileByName(fileName)!=null){
           MyFile f=getFileByName(fileName);
           f.setStatus(status);
           /*修改文件时间*/
            f.setUpdaTime(this.getNowTime());
        }else {
            System.out.println("文件不存在！");
        }
    }
    /*获取当前系统文件使用容量*/
    public long getSystemFileSize(){

        return  this.fileOfSum;
    }
    /*----------------------------------------------------------*/
    /*创建目录*/
    public void mkdir(String dirName){
        String regex = "^[^\\\\/<>\\.?]*$";
        boolean matches = Pattern.matches(regex, dirName);
        if(!matches){
            System.out.println("目录名不能包含\\/<>.");
            return;
        }

        /*创造绝对路径*/
         String absolute=getAbsolute(dirName);
        // 1.判断是否存在目录
        if(exitsDir(absolute)){
            System.out.println("目录已存在");
            return;
        }
        // 创建目录
        MyDirectory dir=new MyDirectory(dirName);
        dir.setCreateTime(this.getNowTime());
        dir.setUpdaTime(this.getNowTime());
        if(rootDirectory.getNextNode()==null){
            rootDirectory.setNextNode(dir);
            dir.setPrevNode(rootDirectory);
        }else {
            this.currentDir.setNextNode(dir);
            dir.setPrevNode(this.currentDir);
        }
        this.currentDir=dir;
        /*添加绝对路径*/
       dirMap.put(absolute,dir);

    }
    /*进入下一级 返回上一级 目录 cd */
    public void cdDir(String DirName){
       if (DirName.equals("..")){
            /*返回上一级目录 ..*/
            try {
                this.currentDir=cd_arr[0];// 返回上一级的目录指向
                this.path=this.path.substring(0,this.getPath().lastIndexOf("\\"));
                if(path.length()==2){
                    path+="\\";
                }
            } catch (Exception e) {
                System.out.println("系统找不到指定的路径");
            }

        }
       else{
            /*进入目录*/
            /*1.获得 DirName的绝对路径*/
            String absolutePath=this.getAbsolute(DirName);
            if(exitsDir(absolutePath)){
                /*存在 指向该目录的内部*/
                cd_arr[0]=this.currentDir;// 保存父目录的指向
                this.path=absolutePath;
                /*进入一个目录
                * 该目录如果没有子目录 指向->root
                * 该目录不为空  指向最后一个目录
                *this.currentDir.getRootDirectory() 表示该目录内部的起点
                * */
                MyDirectory cd_Dir= dirMap.get(absolutePath);//进入该目录
                MyDirectory rootNode=cd_Dir.getRootDirectory();
               if(rootNode.getNextNode()==null){
                   /*没有子目录  指针指向起点*/
                  this.currentDir=rootNode;
               }else {
                   /*存在子目录*/
                   //1.获得最后一个目录位置的指向
                   this.currentDir=this.getLastNode(rootNode);

               }
            }else{
                System.out.println("系统找不到指定的路径");
            }

        }




    }
    /* 显示当前目录下的所有文件，目录*/
    public void ls(){
        /*当前根节点*/
       MyDirectory root=this.returnRootDir(this.currentDir);
       /*遍历目录名*/
       while (true){
           if(root.getNextNode()!=null){
               /*若果root的下一个节点不为空，输出root下一个节点的值*/
               System.out.println(root.getNextNode().getName());
               root=root.getNextNode();
           }else{
                break;
           }
       }
       /*遍历文件名*/
        /*获得当前绝对路径*/


        Map<String, MyFile> filesMap=this.getFilesMap(path);
        Set<String> files = filesMap.keySet();
        for (String fileName:files){
            System.out.println(fileName);
        }


    }
    /*返回登录界面前让指针指向系统根节点*/
    public void returnLogin() {
        this.currentDir=rootDirectory;
        // path 回到最初样式
        this.path=rootDirectory.getName();
    }
    public void clear()  {
        System.out.println("清除屏幕");
    }
    /*对输入命令的检验*/
    public boolean compareTo(HashMap<String,String> orders,String[] receive){
        /*获得键*/
        Set<String> keys = orders.keySet();
        /*判断是否存在命令*/
        for (String key:keys){
            if(receive[0].equals(key)){
                /*该命令存在*/
                String value = orders.get(key);//根据键获的值
                String[] split = value.split(";");//拆分指令 获得各项参数;
                // 比较参数数量
                if(receive.length-1==Integer.parseInt(split[1])){
                    return true;
                }
            }
        }
        return false;
    }
    /*----------------------------------------------------------*/
    /*调用当前系统下目录的存储文件集合*/
    /*获取当前时间*/
    private  String getNowTime(){
       /* LocalDateTime now = LocalDateTime.now();*/
        String string=LocalDateTime.now().toString();
        int lastIndex=string.lastIndexOf(".");
        return string.substring(0,lastIndex);
    }
    /*获取当前文件对象*/
    /*获得分区文件数量*/
    private int getFileNum(){
        return this.parts.getFileCount();
    }
    /*命令表*/
    private void orderList(){
        /*    参数长度;*/
        String c1="create;3;";
        String c2="rm;1";
        String c3="cat;1";
        String c4="write;1";
        String c5="file;1";
        String c6="chmod;2";
        String c7="rename;2";
        String c8="dir;1";
        String c9="df;0";
        String c10="close;1";
        String c11="return;0";
        String c12="exit;0";
        String c13="cd;1";
        String c14="mkdir;1";
        String c15="ls;0";
        String c16="help;0";
        String c17="clear;0";
        orders.put("create",c1);
        orders.put("rm",c2);
        orders.put("cat",c3);
        orders.put("write",c4);
        orders.put("file",c5);
        orders.put("chmod",c6);
        orders.put("rename",c7);
        orders.put("dir",c8);
        orders.put("df",c9);
        orders.put("close",c10);
        orders.put("return",c11);
        orders.put("exit",c12);
        orders.put("cd",c13);
        orders.put("mkdir",c14);
        orders.put("ls",c15);
        orders.put("help",c16);
        orders.put("clear",c17);



    }
    /*------------------------------------ 目录相关-----------------------------------------------------------*/
    /*该目录是否存在
    * 通过命令行的当前路径和 目录名 组成一个新的路径
    * 然后和系统的目录表进行比较判断是否存在！ 啧啧
    *
    *
    * */
   /*判断是否存目录*/
    private boolean exitsDir(String absolute){
        Set<String> dirNames = this.dirMap.keySet();
        for(String s:dirNames){
            if(s.equals(absolute))
                return true;
        }
        return false;
        /*岂不是可以用键值对存储目录？*/
    }
    /*获得绝对路径*/
    private String getAbsolute(String dirName){
        String absolute;
        if(this.path.endsWith("\\")){
            /*    C:\    */
            absolute=this.path+dirName;
        }else{
            /*   C:\xxx */
            absolute=this.path+"\\"+dirName;
        }
        return absolute;
    }
    /*获得当前目录下的文件---根据绝对路径获得文件*/
    private MyFile getFileByName(String fileName){

        /*获得目录绝对路径*/
        String absolute=this.path;
        /*获得文件绝对路径*/
        String absolutFile=absolute+"\\"+fileName;
        /*根据路径获得所在目录*/
        MyDirectory myDirectory = this.dirMap.get(absolute);
        /**/
        return myDirectory.getFiles().get(fileName);
    }
    /*找到当前目录下的根节点*/
    private MyDirectory returnRootDir(MyDirectory currentDir) {
       while (true){
           if(currentDir.getPrevNode()!=null){
               currentDir=currentDir.getPrevNode();
           }else {
               return currentDir;
           }
       }

    }
    /*根据根节点找到最后一个节点*/
    private MyDirectory getLastNode(MyDirectory rootNode){
        while (true){
            if(rootNode.getNextNode()!=null){
                rootNode=rootNode.getNextNode();
            }else {
                return rootNode;
            }

        }
    }
    /*当前目录下存储文件的集合*/
    private Map<String, MyFile> getFilesMap(String path){
        MyDirectory myDirectory = dirMap.get(path);
        return myDirectory.getFiles();
    }
    /*判断文件还是目录*/
    private boolean fileOrDir(String name){
        // 为文件 true
        // 为目录 false
        return name.contains(".");


    }
    /* 根据绝对路径获得对应的目录对象*/
    private MyDirectory getDirByAbsolute(String absolutePath){
        HashMap<String, MyDirectory> dirMap = this.getDirMap();
        return dirMap.get(absolutePath);

    }



}

Login

注册登录业务的实现

import java.util.*;

/**
 * @author GH Fire
 * @version 1.0
 * @description: TODO
 * @date 2024/5/12 21:42
 */
public class Login {

    // 存储用户信息
    static ArrayList<User> uesrArrayList=new ArrayList<>();
    static {
        uesrArrayList.add(new User("zgh","123456"));
    }

    public Login(){
        showlogin();
    }

    /*用户登录*/
    private static void login(String username, String password) {
        // 1.判断用户是否存在
        if(!exitsUser(username)){
            System.out.println("用户不存在！请注册");
        }else{
           for (User user:uesrArrayList){
               if(user.getPassword().equals(password)&&user.getUserName().equals(username)){
                   User u=user;
                   System.out.println("登录成功！");
                   /*  进入磁盘划分   */
                   createDisk(u);
                   break;
               }
           }
            System.out.println("密码错误！");
        }
    }
    public static void showlogin(){
        Scanner sc=new Scanner(System.in);
        String command;
        while (true) {
            System.out.println("****文件管理系统****");
            System.out.println("*---1.Login-------*");
            System.out.println("*---2.Register----*");
            System.out.println("*******************");
            System.out.print("输入命令:");
            command=sc.nextLine();
            switch (command) {
                case "1":
                    System.out.println("输入用户名:");
                    String username = sc.nextLine();
                    System.out.println("输入密码：");
                    String password = sc.nextLine();
                    login(username, password);
                    break;
                case "2":
                        System.out.println("输入用户名:");
                        String username2 = sc.nextLine();
                        System.out.println("输入密码：");
                        String password2 = sc.nextLine();
                        System.out.println("确认密码：");
                        String passwordAgai = sc.nextLine();
                        // 检查两次密码是否一致
                      check(username2, password2, passwordAgai);
                    break;
                default:
                    System.out.println("指令错误！");
            }

        }

    }
    /*注册用户*/
    private static boolean check(String username2, String password2, String passwordAgai) {
        //1.检查用户是否存在
       if(!exitsUser(username2)){
           /*用户不存在*/
         if(compareTo( password2,  passwordAgai)){

             // 添加用户
             User user=new User();
             user.setUserName(username2);
             user.setPassword(passwordAgai);
             // 磁盘指向

             uesrArrayList.add(user);
             System.out.println("注册成功！");
             return true;
         } else {
             System.out.println("两次密码不一致！");
             return false;
         }
       }else {
           System.out.println("用户已存在！");
           return false;
       }

    }
    /*判断两次密码是否一致*/
    private static boolean compareTo(String password2, String passwordAgai){
        if (password2.equals(passwordAgai)){
            return true;
        }else{
            return false;
        }
    }
    /*判断用户是否存在*/
    private static boolean exitsUser(String username2) {
        for (User user:uesrArrayList){
            if(user.getUserName().equals(username2)){
                /*用户存在*/
                return true;
            }
        }
        return  false;
    }
    /*-----------------------------------------------------------------------------------*/
    /*创建磁盘进行划分*/
    private static void createDisk(User u) {
        Scanner sc=new Scanner(System.in);
        String name;
        // 还未分区
        if(!u.isFlag()) {
            System.out.print("输入划分磁盘数量:");
            int num=sc.nextInt();
            /*磁盘划分数量 名称 每个磁盘容量*/
            /* 构造一个磁盘对象*/
            MyDisk myDisk=new MyDisk(num);
            u.setDisk(myDisk);
            u.setFlag(true);
            HashMap<String, MyParts> parts = myDisk.getParts();
            Set<String> keys = parts.keySet();
            while (true) {
                System.out.println("选择分区进入：");
                name=sc.next();
                for (String s:keys){
                    if(s.equals(name)){
                        menu(u,name);
                        break;
                    }
                }
                System.out.println("分区不存在");
            }

        }else{
            HashMap<String, MyParts> parts = u.getDisk().getParts();
            Set<String> keys = parts.keySet();
            while (true) {
                System.out.println("选择分区进入：");
                name=sc.next();
                for (String s:keys){
                    if(s.equals(name)){
                        menu(u,name);
                        break;
                    }
                }
                System.out.println("-----分区不存在----");
                System.out.println("可能存在的分区");
                for (String s:keys){
                    System.out.println(s);
                }
                System.out.println("----------------");
            }


        }


    }
    /*主要功能*/
    public static void  menu(User u ,String partName){
        Scanner sc=new Scanner(System.in);
        /*文件管理系统*/
        HashMap<String, MyParts> partsMap = u.getDisk().getParts();

            MyParts  myParts = partsMap.get(partName);
            MyFileSystem myFileSystem=myParts.getFileSystem();
            String[] receive;
            while (true){
                /*文件路径*/
                String path= myFileSystem.getPath();
                System.out.println("-----------------"+u.getUserName()+"的文件管理系统--------------------------------");
                System.out.print("输入指令 "+path+">");
                /*命令接收*/
                receive= sc.nextLine().split("\\s+");// 至少匹配一个空格
                if(myFileSystem.compareTo(myFileSystem.getOrders(),receive)){
                    switch (receive[0]){
                        /*创建文件*/
                        case  "create":
                            try {
                                Long.parseLong(receive[2]);
                                myFileSystem.create(receive[1],receive[2],receive[3]);
                            } catch (NumberFormatException e) {
                                System.err.println("file size Exception!");
                            }
                            break;
                        case "rm":
                            myFileSystem.remove(receive[1]);
                            break;
                        case"cat":
                            myFileSystem.cat(receive[1]);
                            break;
                        case "write":
                            myFileSystem.write(receive[1]);
                            break;
                        case "file":
                            myFileSystem.file(receive[1]);
                            break;
                        case "rename":
                            myFileSystem.rename(receive[1],receive[2]);
                            break;
                        case "dir":
                                    if(!u.getUserName().equals(receive[1])){
                                        System.out.println("请输入当前用户！");
                                    }else
                                        myFileSystem.show();
                            break;
                        case "df":
                            myFileSystem.display(u.getDisk());
                            break;
                        case "close":
                            System.out.println(".....");
                            break;
                        case "chmod":
                            myFileSystem.chmod(receive[1],receive[2]);
                            break;
                        case  "return":
                            /*返回登录界面*/
                            myFileSystem.returnLogin();
                        showlogin();
                            break;
                        case "exit":
                            /*退出程序*/
                            System.exit(0);
                        case "help":
                            /*命令提示*/
                            myFileSystem.help();
                            break;
                        case "mkdir":
                            myFileSystem.mkdir(receive[1]);
                            break;
                        case"cd":/*进入下一级目录*/
                            myFileSystem.cdDir(receive[1]);
                            break;
                        case "ls":
                            myFileSystem.ls();
                            break;
                        case "clear":
                            myFileSystem.clear();
                            break;
                        default:
                            System.out.println("指令错误！");
                            break;

                    }
                }
                else {
                    System.out.println("请输入正确的指令！");
                }


            }




    }
    /*输入格式的检验  int except */
    public static boolean checkout(int except,int actual){
        if(except!=actual){
            return false;
        }
        else{
            return true;
        }

    }

    }