栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

操作系统仿真实验(YTU)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

操作系统仿真实验(YTU)

实验一:资源分配仿真

PS:实体类使用lombox自动生成getter setter 有参 无参方法(没有的手动生成)
lombox maven仓库地址


  org.projectlombok
  lombok
  1.16.10

实现方式

随机分配算法产生死锁,银行家算法避免死锁

具体代码

随机分配算法:此算法不是模拟死锁而是会真正产生死锁(多运行几次随机的有的时候不会产生死锁)

package com.xu.demo.ytu.bank;

import java.util.ArrayList;
import java.util.List;


public class RandomAgl {
    public static Object A=new Object();
    public static Object B=new Object();
    public static Object C=new Object();
    public static Object D=new Object();

    public static void RanDomTest(List list){
        System.out.println(list);
        new Thread(()->{
            synchronized (A){
                System.out.println(Thread.currentThread().getName()+"我得到了资源:"+A);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Object O=list.get((int) (Math.random() * 4));
                System.out.println("随机分配资源开始:线程"+Thread.currentThread().getName()+"随机去获取的资源是"+O);
                synchronized (O){
                    System.out.println("线程"+Thread.currentThread().getName()+"得到了资源"+O);
                }
            }
        }).start();

        new Thread(()->{
            Object O=list.get((int) (Math.random() * 4));
            synchronized (B){
                System.out.println(Thread.currentThread().getName()+"我得到了资源:"+B);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("随机分配资源开始:线程"+Thread.currentThread().getName()+"随机去获取的资源是"+O);
                synchronized (O){
                    System.out.println("线程"+Thread.currentThread().getName()+"得到了资源"+O);
                }
            }
        }).start();
    }

    public static void main(String[] args) {
        List testList=new ArrayList<>();
        testList.add(A);
        testList.add(B);
        testList.add(C);
        testList.add(D);
        RandomAgl.RanDomTest(testList);
    }

}

 

运行截图
死锁已经产生,接下来进入java的bin目录具体查看
可以看出,线程1得到了资源270ca0并且想要去获取资源270c90,线程0得到了资源270c90并且想要获取资源270ca0死锁产生

银行家算法:
PCB类

package com.xu.demo.ytu.bank;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class PCB {
    String processName;
    int maxUsed;
    int alreadyUsed;
    boolean isFinish;
    @Override
    public String toString() {
        return
                        "t"+processName +
                        "               t" + maxUsed +
                        "                       t" + alreadyUsed +
                        "                       t" +(maxUsed-alreadyUsed)+
                        "                   t" + isFinish ;
    }

}

BankAlg

package com.xu.demo.ytu.bank;

import java.util.*;

public class BankAlg {
    public static int availableSource = 10;
    public static ArrayList safeList = new ArrayList<>();
    public static Map pcbMap = new LinkedHashMap<>();

    
    public static void init() {
        PCB a = new PCB("A", 5, 1, false);
        PCB b = new PCB("B",  3, 1, false);
        PCB c = new PCB("C", 4, 2, false);
        PCB d = new PCB("D", 6, 3, false);

        pcbMap.put(a.processName, a);
        pcbMap.put(b.processName, b);
        pcbMap.put(c.processName, c);
        pcbMap.put(d.processName, d);
        System.out.println("---------------------------------------初始化--------------------------------------------------");
        System.out.println("进程名         " + "最大需求量            " + "占有量             " + "    仍需           " + "         完成");

        pcbMap.forEach((k, v) -> {
            System.out.println(v);
        });
        pcbMap.forEach((k, v) -> {
            availableSource -= v.alreadyUsed;
        });
        System.out.println("剩余资源量:" + availableSource);
    }

    
    public static void safe(String pName, int pNum) {
        //请求的资源大于剩余资源,请求不安全,拒绝分配
        if (availableSource < pNum) {
            System.out.println("请求不安全 拒绝分配");
        } else {
            //尝试分配
            availableSource = availableSource - pNum;
            pcbMap.get(pName).alreadyUsed += pNum;
            //仍需资源如果为0,表明进程请求资源结束,进程释放资源
            if (pcbMap.get(pName).maxUsed - pcbMap.get(pName).alreadyUsed == 0) {
                availableSource += pcbMap.get(pName).maxUsed;
                pcbMap.get(pName).isFinish = true;
                pcbMap.get(pName).maxUsed = pcbMap.get(pName).alreadyUsed = 0;
            }
            //添加安全序列
            pcbMap.forEach((k, v) -> {
                if (v.maxUsed - v.alreadyUsed <= availableSource && !v.isFinish) {
                    safeList.add(k);
                }
            });
            //如果安全队列没有满,就说明当前分配资源可能不安全,继续尝试
            //找不到安全序列,拒绝请求
            if (safeList.size() == 0) {
                List checkList = new ArrayList<>();
                pcbMap.forEach((k, v) -> {
                    checkList.add(v.isFinish);
                });
                //如果安全序列全部完成不进行撤销
                System.out.println("请求不安全 拒绝分配");
                availableSource = availableSource + pNum;
                pcbMap.get(pName).alreadyUsed -= pNum;
                //这种情况比较特殊这时候对最后一个进程完成分配
                if (!checkList.contains(false)) {
                    availableSource = availableSource - pNum;
                    pcbMap.get(pName).alreadyUsed += pNum;
                }

            }
            //继续尝试分配
            int temp = 0;
            for (String s : safeList) {
                //在已经添加到安全序列的进程中获取它们释放资源后的总和
                temp = pcbMap.get(s).maxUsed;
            }
            int finalTemp = temp;
            pcbMap.forEach((k, v) -> {
                //便利进程,如果可以资源+加已经进入安全序列释放的资源大于
                //仍需的资源就把进程添加到安全序列
                if (v.maxUsed - v.alreadyUsed < availableSource + finalTemp) {
                    if (!safeList.contains(k)) {
                        safeList.add(k);
                    }
                }
            });
            if (safeList.size() == 4) {
                System.out.println("进程名         " + "最大需求量            " + "占有量             " + "    仍需           " + "         完成");
                pcbMap.forEach((k, v) -> {
                    System.out.println(v);
                });
                System.out.println("安全序列:" + safeList);
                System.out.println("剩余资源量:" + availableSource);
            }
        }
        //清空安全序列防止干扰分配
        safeList.clear();
    }


    public static void main(String[] args) {
        //初始化
        BankAlg.init();
        //请求资源
        do {
            Scanner in = new Scanner(System.in);
            System.out.println("资源申请 请输入进程名:");
            String pName = in.next();
            System.out.println("请输入申请的资源量:");
            int pSum = in.nextInt();
            BankAlg.safe(pName, pSum);
        } while (availableSource < 10);
        System.out.println("分配结束");

    }

}

银行家算法运行截图:

文字描述

实验二:可变分区主存空间的分配与回收仿真 实现方式

使用最佳适应算法实现

具体代码

Free类

package com.xu.demo.ytu.bf;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Free {
    private int no;
    private String processName;
    private int begin;
    private int end;
    private Boolean isUsed;

    @Override
    public String toString() {
        return
                "t" + no +"t"+
                        "               t" + processName +"t"+
                        "               t" + begin +"t"+
                        "               t" + end +"t"+
                        "               t" + (end-begin+1) +
                        "               t" + isUsed ;

    }
}

Used类

package com.xu.demo.ytu.bf;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Used {
    private int no;
    private String processName;
    private int begin;
    private int end;
    private Boolean isUsed;

    @Override
    public String toString()  {
        return
                "t" + no +"t"+
                        "               t" + processName +
                        "               t" + begin +"t"+
                        "              t" + end +"t"+
                        "               t" + (end-begin+1) +
                        "                   t" + isUsed ;
    }
}

BestFit

package com.xu.demo.ytu.bf;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class BestFit {
    //起始地址
   private static final int cacheBegin=0;
   //终止地址
   private static final int cacheEnd=400;
   //内存使用表
   private static List usedList=new ArrayList<>();
   //空闲表
    private static List frees=new ArrayList<>();
    //用于存放起始地址和终止地址以便于计算空闲表
    private static List addrNum=new ArrayList<>();
    //初始操作
   public static void init(){
       System.out.println("初始化");
       usedList.add(new Used(0,"OS",0,90,false));
       usedList.add(new Used(0,"A",91,151,false));
       usedList.add(new Used(0,"B",156,166,false));
       usedList.add(new Used(0,"C",170,200,false));
       usedList.add(new Used(0,"D",260,320,false));
       BestFit.used();
       BestFit.free();
   }

   //添加进程
    public static void addProcess(String pName,int pSize){
        Used pUsed = new Used();
        pUsed.setProcessName(pName);
        //如果空闲表为空,无法添加
        if(frees.size()==0){
            System.out.println("内存已满,无法执行此操作");
            return;
        }
        if(pSize==0){
            System.out.println("输入有错误!!!");
            return;
        }
        for (Used used : usedList) {
            if (used.getProcessName().equals(pName)) {
                System.out.println("此进程已经存在,操作失败!!!");
                return;
            }
        }

        //空闲表根据长度排序
        frees.sort(new Comparator() {
            @Override
            public int compare(Free p1, Free p2) {
                return (p1.getEnd()-p1.getBegin())-(p2.getEnd()-p2.getBegin());
            }
        });
        //如果进程大小大于最大空闲区长度无法添加
        if (pSize>frees.get(frees.size()-1).getEnd()-frees.get(frees.size()-1).getBegin()+1){
            System.out.println("内存空间不足 进程无法添加!!!");
            return;
        }
        //以最佳适应的方式操作进行信息
        for (Free free : frees) {
            if (free.getEnd()-free.getBegin()+1>=pSize){
                pUsed.setBegin(free.getBegin());
                pUsed.setEnd(free.getBegin()+pSize-1);
                pUsed.setIsUsed(false);
                usedList.add(pUsed);
                return;
            }
        }
        //结果显示
        for (Free free : frees) {
            System.out.println(free);
        }
    }
    //回收进程
    public static void recycleProcess(String pName){
        for (Used used : usedList) {
            if(used.getProcessName().equals(pName)){
                usedList.remove(used);
                return;
            }
        }
        System.out.println("此进程不存在,无法回收!!!");
        return;
    }
    //已使用的分区表
    public static void used(){
       //根据起始地址排序
       usedList.sort(new Comparator() {
           @Override
           public int compare(Used p1, Used p2) {
               return p1.getBegin()-p2.getBegin();
           }
       });
         //首地址处理
        if(usedList.size()==0){
            addrNum.add(cacheBegin);
            addrNum.add(cacheBegin-1);
            addrNum.add(cacheEnd+1);
            addrNum.add(cacheEnd+1);
            return;
        }
        //处理首地址
        if(usedList.get(0).getBegin()!=0){
            addrNum.add(cacheBegin);
            addrNum.add(cacheBegin);
            System.out.println(usedList.get(0).getBegin()-1);

        }
       int no=1;
        for (Used used : usedList) {
            used.setNo(no);
            addrNum.add(used.getBegin());
            addrNum.add(used.getEnd());
            no++;
        }

        //处理尾地址
        if(usedList.get(usedList.size()-1).getEnd()!=400){
            addrNum.add(cacheEnd+1);
            addrNum.add(cacheEnd+1);
        }
        System.out.println("-----------------------------------已使用分区表-------------------------------------");
        System.out.println("    No       t"+"进行名       t"+"起始地址       t"+"结束地址       t"+"   长度       t"+"        空闲");
        for (Used used : usedList) {
            System.out.println(used+"t");
        }
    }
   //计算空闲表
   public static void free(){
       frees.clear();
       int no=1;
       for(int i=1;i<=addrNum.size();i++){
           if(2*i+1
               if(addrNum.get(2*i-1)-addrNum.get(2*i)!=-1){
                   frees.add(new Free(no,"---",addrNum.get(2*i-1)+1,addrNum.get(2*i)-1,true));
                   no++;
               }
           }
       }

       System.out.println("-------------------------------------空闲分区表--------------------------------------");
       System.out.println("    No       t"+"进行名       t"+"起始地址       t"+"结束地址       t"+"   长度       t"+"        空闲");
       for (Free free : frees) {
           System.out.println(free+"t");
       }
       addrNum.clear();
   }

    public static void main(String[] args) {
        BestFit.init();
        do {
            System.out.println();
            System.out.println("------------------------------请选择要进行的操作-----------------------------------");
            System.out.println("0:退出系统       1:查看内存使用情况       2:添加进程到内存       3:回收进程");
            System.out.print("请选择:");
            int n = new Scanner(System.in).nextInt();
            switch (n){
                case 1:
                    BestFit.used
                             ();
                    BestFit.free();
                    break;
                case 2:
                    System.out.print("请输入进程名:");
                    String name = new Scanner(System.in).next();
                    System.out.print("请输入进程大小:");
                    int size = new Scanner(System.in).nextInt();
                    BestFit.addProcess(name,size);
                    break;
                case 3:
                    System.out.print("进程回收 输入进程名:");
                    String pName = new Scanner(System.in).next();
                    BestFit.recycleProcess(pName);
                    break;
                case 0:
                    return;
            }
        }while (true);
    }

}
文字描述

运行截图:

实验二:文件系统仿真

实体类
File类

package com.xu.demo.ytu.filesystem;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class File {
    private String fileName;
    private int protect;
    private int size;
    private ArrayList address;
    private boolean state;
    private boolean read;
    private boolean write;

    public File(String fileName, int protect, int size, ArrayList address) {
        this.fileName = fileName;
        this.protect = protect;
        this.size = size;
        this.address = address;
    }

    @Override
    public String toString() {
        return
                "       " + fileName +"t"+
                "          " + protect+"t"+
                "           " + size+"t"+
                "           " + address +"t";
    }
}

MFD类

package com.xu.demo.ytu.filesystem;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class File {
    private String fileName;
    private int protect;
    private int size;
    private ArrayList address;
    private boolean state;
    private boolean read;
    private boolean write;

    public File(String fileName, int protect, int size, ArrayList address) {
        this.fileName = fileName;
        this.protect = protect;
        this.size = size;
        this.address = address;
    }

    @Override
    public String toString() {
        return
                "       " + fileName +"t"+
                "          " + protect+"t"+
                "           " + size+"t"+
                "           " + address +"t";
    }
}

UFD类

package com.xu.demo.ytu.filesystem;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UFD {
      private String address;
      private List fileList;
      private List uofList;
}

UOF类

package com.xu.demo.ytu.filesystem;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class UOF {
    //文件名
    private String fileName;
    //保护程度
    private int protect;
    //是否打开
    private Boolean state;
    //读指针
    private Boolean read;
    //写指针
    private Boolean write;

    @Override
    public String toString() {
        return
                "       " + fileName +"t"+
                "          " + protect +"t"+
                "          " + state +"t"+
                "          " + read +"t"+
                "          " + write +"t";
    }
}

具体实现
FileSystem

package com.xu.demo.ytu.filesystem;

import java.util.*;


public class FileSystem {
    ;
    //一级目录
    public static List mfdList = new ArrayList<>(4);
    //定义存储容量
    public static int[] capacity = new int[100];
    //初始化
    public static void init() {
        //基本操作信息
        System.out.println("---------------------------------文件系统基本操作----------------------------------------------------");
        System.out.print("create:创建文件t");
        System.out.print("   open: 打开文件t");
        System.out.print("  close: 关闭文件t");
        System.out.print("   read: 读操作t");
        System.out.println("  write: 写操作t");
        System.out.print("delete: 删除文件t");
        System.out.print("      cd: 返回根目录t");
        System.out.print("    exit: 退出系统t");
        System.out.print("    保护: 1: 可读 2: 可写 3:可读可写t");
        System.out.println();
        //初始化一级目录
        mfdList.add(new MFD("xu-01", "001", new UFD("001", new ArrayList<>(), new ArrayList<>())));
        mfdList.add(new MFD("xu-02", "002", new UFD()));
        mfdList.add(new MFD("xu-03", "003", new UFD()));
        mfdList.add(new MFD("xu-04", "004", new UFD()));
        System.out.println("一级目录");
        System.out.println("      文件夹名" + "   t文件地址");
        for (MFD mfd : mfdList) {
            System.out.println(mfd);

        }
        //初始化二级目录 只是将2个文件写入xu-01里
        for (MFD mfd : mfdList) {
            if (mfd.getAddress().equals("001")) {
                mfd.getUfd().setAddress(mfd.getAddress());
                List fileList = new ArrayList<>();
                ArrayList address01 = new ArrayList<>();
                address01.add(0);
                address01.add(1);
                address01.add(2);
                ArrayList address02 = new ArrayList<>();
                address02.add(3);
                address02.add(4);
                fileList.add(new File("file01", 1, 3, address01));
                fileList.add(new File("file02", 2, 2, address02));
                mfd.getUfd().setFileList(fileList);
                //10表示这个存储地址没有被使用 1表示已经被使用
                for (int i = 0; i < 100; i++) {
                    if (i < 5) {
                        capacity[i] = 1;
                    } else {
                        capacity[i] = 10;
                    }

                }
                return;
            }
        }
    }

    //显示方法
    public static void show(MFD mfd) {
        System.out.println("-------------------------------文件列表----------------------------------------");
        System.out.println("       文件名" + "      保护程度" + "     文件大小" + "     文件地址");
        for (File file : mfd.getUfd().getFileList()) {
            mfd.getUfd().getUofList().add(new UOF(file.getFileName(), file.getProtect(), file.isState(), file.isRead(), file.isWrite()));
            System.out.println(file);
        }
        System.out.println("---------------------------------UOF表-----------------------------------------");
        System.out.println("       文件名" + "      保护程度" + "     是否打开" + "        读指针" + "         写指针");
        for (UOF uof : mfd.getUfd().getUofList()) {
            System.out.println(uof);
        }
        mfd.getUfd().getUofList().clear();
    }

    //使用连续分配的方式寻找可以空间(连续分配算法)
    public static List findAddress(int fileSize) {
        List temList = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            //空闲区首次出现
            if (capacity[i] == 10) {
                //判断连续分区是否符合要求
                for (int j = i; j < fileSize + i; j++) {
                    //判断内存大小是否符合要求
                    if (j >= 100) {
                        return null;
                    }
                    temList.add(capacity[j]);
                }
                //这个集合包含1就不符合清空集合继续操作
                if (temList.contains(1)) {
                    temList.clear();
                } else {
                    temList.clear();
                    int realAddress = i;
                    for (int n = 0; n < fileSize; n++) {
                        temList.add(realAddress);
                        capacity[realAddress] = 1;
                        realAddress++;

                    }
                    return temList;
                }
            }
        }
        return temList;
    }

    //清除地址信息记录
    public static void clearAddress(int startAddress, int fileSize) {
        for (int i = startAddress; i <= startAddress+fileSize; i++) {
            capacity[i] = 10;
        }
    }

    //创建文件 分配方式:连续分配
    public static void create(MFD mfd, String fileName, int fileProtect, int fileSize) {
        //处理同名问题,文件同名无法写入
        for (File file : mfd.getUfd().getFileList()) {
            if (file.getFileName().equals(fileName)) {
                System.out.println("该文件已经存在!!!无法创建!!!");
                return;
            }
        }

        File file = new File(fileName, fileProtect, fileSize, new ArrayList<>());
        //寻找可以空间
        List address = FileSystem.findAddress(fileSize);
        //空间不足
        if (address == null||address.size()==0) {
            System.out.println("存储空间不足!!操作执行失败!!!");
            return;
        }
        file.setAddress((ArrayList) address);
        mfd.getUfd().getFileList().add(file);
    }
    //写操作
    public static void write(MFD mfd, String fileName, int fileProtect, int fileSize) {
        for (File file : mfd.getUfd().getFileList()) {
            if (file.getFileName().equals(fileName)) {
                //文件如果未打开 无法进行写操作
                if (file.getProtect() == 1) {
                    System.out.println("该文件是只是可读文件!!无法进行写操作!!!");
                    return;
                }
                if (file.isState()) {
                    //首先清除原有的地址记录
                    FileSystem.clearAddress(file.getAddress().get(0), file.getSize());
                    //寻找新的地址
                    file.setProtect(fileProtect);
                    List address = FileSystem.findAddress(fileSize);
                    //空间不足
                    if (address == null||address.size()==0) {
                        System.out.println("存储空间不足!!操作执行失败!!!");
                        return;
                    }
                    file.setAddress((ArrayList) address);
                    file.setWrite(true);
                } else {
                    System.out.println("文件未打开,无法操作!!!");
                }
                return;
            }
        }
        System.out.println("文件不存在无法执行写操作!!!");
    }

    //打开文件操作
    public static void open(MFD mfd, String fileName) {
        for (File file : mfd.getUfd().getFileList()) {
            if (file.getFileName().equals(fileName)) {
                file.setState(true);
                return;
            }
        }
        System.out.println("该文件不存在!!无法打开!!!");
    }
   //关闭操作
    public static void close(MFD mfd, String fileName) {
        for (File file : mfd.getUfd().getFileList()) {
            if (file.getFileName().equals(fileName)) {
                if (!file.isState()) {
                    System.out.println("文件未打开!!不用关闭!!!");
                    return;
                }
                file.setState(false);
                file.setRead(false);
                file.setWrite(false);
                return;
            }
        }
        System.out.println("该文件不存在!!无法关闭!!!");
    }
   //读操作
    public static void read(MFD mfd, String fileName) {
        for (File file : mfd.getUfd().getFileList()) {
            if (file.getProtect() == 2) {
                System.out.println("该文件是只是可写的!!无法进行读操作!!!");
                return;
            }
            if (file.getFileName().equals(fileName)) {
                if (!file.isState()) {
                    System.out.println("文件未打开!!无法进行读操作!!!");
                    return;
                }
                file.setRead(true);
                return;
            }
        }
        System.out.println("该文件不存在!!无法进行读操作!!!");
    }
    //删除操作
    public static void delete(MFD mfd, String fileName) {
        for (File file : mfd.getUfd().getFileList()) {
            if (file.getFileName().equals(fileName)) {
                //清除内存
                FileSystem.clearAddress(file.getAddress().get(0), file.getSize());
                //删除
                mfd.getUfd().getFileList().remove(file);
                return;
            }
        }
        System.out.println("该文件不存在!!无法删除!!!");
    }

    //操作
    public static void operation(String instruct, MFD mfd) {
        String[] ins = instruct.split(" ");
        String n = ins[0];
        switch (n) {
            case "create":
                FileSystem.create(mfd, ins[1], Integer.parseInt(ins[2]), Integer.parseInt(ins[3]));
                FileSystem.show(mfd);
                break;
            case "write":
                FileSystem.write(mfd, ins[1], Integer.parseInt(ins[2]), Integer.parseInt(ins[3]));
                FileSystem.show(mfd);
                break;
            case "open":
                FileSystem.open(mfd, ins[1]);
                FileSystem.show(mfd);
                break;
            case "close":
                FileSystem.close(mfd, ins[1]);
                FileSystem.show(mfd);
                break;
            case "read":
                FileSystem.read(mfd, ins[1]);
                FileSystem.show(mfd);
                break;
            case "delete":
                FileSystem.delete(mfd, ins[1]);
                FileSystem.show(mfd);
                break;
            case "cd":
                FileSystem.enterFolder();
                break;
        }

    }

    //进入指定目录
    public static String enterFolder() {
        System.out.print("请选择你要进入的目录:");
        String folderName = new Scanner(System.in).next();
        for (MFD mfd : mfdList) {
            //进入目录
            if (mfd.getUserName().equals(folderName)) {
                //判断目录下是否有文件
                if (mfd.getUfd().getFileList() != null) {
                    //展示文件和UOF表
                    FileSystem.show(mfd);
                    //操作
                    do {
                        System.out.print("filesystem:/" + mfd.getUserName() + "/:");
                        String in = new Scanner(System.in).nextLine();
                        if (in.equals("exit")) return "文件系统运行结束";
                        FileSystem.operation(in, mfd);
                    } while (true);

                } else {
                    //目录下没有文件
                    System.out.println("该目录没有文件请操作");
                    mfd.getUfd().setAddress(mfd.getAddress());
                    mfd.getUfd().setUofList(new ArrayList<>());
                    mfd.getUfd().setFileList(new ArrayList<>());
                    //操作
                    do {
                        System.out.print("filesystem:/" + mfd.getUserName() + "/:");
                        String in = new Scanner(System.in).nextLine();
                        if (in.equals("exit")) return "文件系统运行结束";
                        FileSystem.operation(in, mfd);
                    } while (true);
                }

            }

        }
        if (folderName.equals("exit")) return "文件系统运行结束";
        System.out.println("目录不存在!!!");
        FileSystem.enterFolder();
        return "目录不存在";
    }

    public static void main(String[] args) {

        FileSystem.init();
        System.out.println(FileSystem.enterFolder());
    }
}

文字描述

运行截图

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号