开发基于控制台的购书系统
 
输出所有图书的信息：包括每本图书的图书编号、图书名称、图书单价和库存数量。
 顾客购买图书；
 购书完毕后输出顾客的订单信息：包括订单号、订单明细、订单总额和订单。
 
系统功能：
 
管理员可通过系统创建图书、查看图书。
顾客可通过系统购买图书，并自动生成订单。
 
管理员权限操作如下：
 
 进入管理员权限操作如下：
 
 管理员可以通过编号1来创建图书，创建好的图书会提示自动更新到书库中，也可以通过编号2来查询书库中已创建过得图书,操作如下：
 创建时如果图书编号相同，数量则会被累计到已创建的图书里：操作如下：
 如果第一次运行，图书尚未创建图书时，则提示“书库中没有书，请创建图书”,操作如下：
 顾客权限操作如下：
 顾客权限中可以同过编号1来查看已经创建的图书，如果在书库中没有书的情况下则提示“书库中没有书，请联系管理员更新书库”操作如下：
 
 顾客可以通过编号2来进行对图书的购买，购买时需要输入购买书的编号以及数量，添加成功则提示“购买图书添加成功”，如果输入的编号不存在或者数量小于0或大于库存则提示重新添加，操作如下：
 顾客通过编号3结束购买，此时系统会自动生成订单并打印出来，重复的书则不重复打印,购买完成则退出到选择权限界面，如要购买请重新选择顾客：操作如下：
 
 
原码地址：//download.csdn.net/download/qq_37468222/12038064

计算机操作系统实验一：进程调度
 
[目的要求]
 　　用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．
 　　[准备知识]
 　　 一、基本概念
 　　 1、进程的概念；
 　　 2、进程的状态和进程控制块；
 　　 3、进程调度算法；
 　　 二、进程调度
 　　 1、进程的状态
 
 
**
 2、进程的结构——PCB
 
进程都是由一系列操作(动作)所组成，通过这些操作来完成其任务。因此，不同的进程，其内部操作也不相同。在操作系统中，描述一个进程除了需要程序和私有数据之外，最主要的是需要一个与动态过程相联系的数据结构，该数据结构用来描述进程的外部特性(名字、状态等)以及与其它进程的联系(通信关系)等信息，该数据结构称为进程控制块(PCB，Process Control Block)。进程控制块PCB与进程一一对应，PCB中记录了系统所需的全部信息、用于描述进程情况所需的全部信息和控制进程运行所需的全部信息。因此，系统可以通过进程的PCB来对进程进行管理。[试验内容] 设计一个有 N个进程共行的进程调度程序。
 
进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名（给定值）、优先数（给定值或者随机数）、到达时间（给定值）、需要运行时间（给定值）、已用CPU时间（计算）、进程状态（判断）等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
 
进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
 
重复以上过程，直到所要进程都完成为止。调度算法的流程图如下 : **
 
 
package Process;

public class JCPro {
    String name;//进程名
    int arriveTime = 0;//到达时间（调入CPU时间）
    int serveTime;//服务时间（给定值，单位ms）
    int priority;//优先级数字
    int beginTime;//开始时间：为到达时间
    int finshTime;//结束时间
    int roundTime;//周转时间

    public String getName() {
        return name;
    }

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

    public int getArriveTime() {
        return arriveTime;
    }

    public void setArriveTime(int arriveTime) {
        this.arriveTime = arriveTime;
    }

    public int getServeTime() {
        return serveTime;
    }

    public void setServeTime(int serveTime) {
        this.serveTime = serveTime;
    }

    public int getPriority() {
        return priority;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public int getBeginTime() {
        return beginTime;
    }

    public void setBeginTime(int beginTime) {
        this.beginTime = beginTime;
    }

    public int getFinshTime() {
        return finshTime;
    }

    public void setFinshTime(int finshTime) {
        this.finshTime = finshTime;
    }

    public int getRoundTime() {
        return roundTime;
    }

    public void setRoundTime(int roundTime) {
        this.roundTime = roundTime;
    }
}

 
package Process;

import java.util.ArrayList;

public class Cpu {
	private int timeSlice = 20;//CPU一个时间片时长
	
	//processArriveTime 记录进程的进入时间，每当运行一个进程，该数字需要相应增加
	static int processArriveTime = 0;
	
	
    public JCPro Cpu(JCPro jcPro){
    	//设置进程进入CPU的时间
    	jcPro.setArriveTime(processArriveTime);
    	
    	//设置进程开始时间
    	jcPro.setBeginTime(processArriveTime);
    	
    	//取得该进程需要运行的时间
    	int serverTime = jcPro.getServeTime();
    	
    	//把该进程需要运行的时间和CPU时间片进行比较
    	//判断进程需要运行的时间和CPU时间片的大小
    	if (serverTime <= timeSlice) {
			//如果进程需要运行的时间小于等于CPU一个时间片的时间
    		//则该进程直接完成，记录进程的进入时间的变量增加
    		jcPro.setFinshTime(processArriveTime + serverTime);
    		processArriveTime += serverTime;
    		
    		//设置进程的周转时间roundTime，已经运行了多少时间
    		jcPro.setRoundTime(serverTime);
    		
    		//设置运行完了的进程对象的需要运行的时间为0
    		jcPro.setServeTime(0);
    		
    		System.out.println("【CPU时间片大小" + timeSlice + "】" + "; 进程名：" + jcPro.getName() +"; 进程进入CPU时间：" + jcPro.getArriveTime() + "; 进程需要运行的时间：" + 
    		serverTime + "; 进程结束时间：" + jcPro.getFinshTime());
		}else {
			//进程需要运行的时间，大于一个CPU时间片的时间
			//这里要进行把进程初始需要的运行时间，减去CPU单个时间片时间
			
			//该进程剩余运行时间
			int serverTimeResidue = serverTime - timeSlice;
			
			
			//设置运行完了的进程对象还有需要运行的时间
			jcPro.setServeTime(serverTimeResidue);
			//进程优先级减1
			jcPro.setPriority(jcPro.getPriority() - 1);
			
			//记录进程的进入时间的变量增加
			processArriveTime += timeSlice;
			System.out.println("【CPU时间片大小" + timeSlice + "】" + "; 进程名：" + jcPro.getName() +"; 进程进入CPU时间：" + jcPro.getArriveTime() + "; 进程还需要运行的时间：" + 
			serverTimeResidue + "; 进程优先级数减1");
		}
		return jcPro;
    }
}

 
package Process;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class ProcessSort {
	public ArrayList<JCPro> ProcessSort(ArrayList<JCPro> notSortProcessList) {
		//根据用户输入的进程优先级数对进程进行排序(根据数字降序排序，优先级数大的先运行)
		
		
		//Map集合，用于存储进程的优先级数和该进程在未排序集合中的位置index
		//第一个Integer是该进程在notSortProcessList中的index，第二个Integer是该进程的优先级数（不能重复）
		Map<Integer, Integer> notSortIndexAndPriority = new HashMap<Integer, Integer>();
		
		//排序后的进程集合
		ArrayList<JCPro> alreadySortProcessList = new ArrayList<JCPro>();
		for (int i = 0; i < notSortProcessList.size(); i++) {
			
			//取出未排序集合中进程的优先级数
			int priority = notSortProcessList.get(i).getPriority();
			notSortIndexAndPriority.put(i, priority);
		}
		
		//HashMap根据Value值进行排序
		List<Map.Entry<Integer, Integer>> list = new ArrayList<>(notSortIndexAndPriority.entrySet());
		Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {

			@Override
			public int compare(Entry<Integer, Integer> o1, Entry<Integer, Integer> o2) {
				// TODO Auto-generated method stub
				return o2.getValue().compareTo(o1.getValue());
			}
		});
		
		for (Map.Entry sEntry : list) {
			JCPro jcPro = notSortProcessList.get((int) sEntry.getKey());
			alreadySortProcessList.add(jcPro);
		}
		return alreadySortProcessList;
		// TODO Auto-generated constructor stub
	}
}

 
package Process;

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

public class ProcessL {
	public void arCPU(ArrayList<JCPro> jcProArrayList){
		//调用根据优先级数排序的函数
        ProcessSort processSort = new ProcessSort();
        
        //根据优先级数排序后的进程集合
        ArrayList<JCPro> sortProcessList = processSort.ProcessSort(jcProArrayList);
        //遍历排序后的进程集合
        System.out.println("-------------就绪进程----------");
        System.out.println("进程名       优先级        需要运行时间");
        for (int i = 0; i < sortProcessList.size(); i++) {
			String name = sortProcessList.get(i).getName();//进程名
			int priority = sortProcessList.get(i).getPriority();//优先级
			int serverTime = sortProcessList.get(i).getServeTime();//运行时间
			System.out.println(name + "       " + priority + "         " + serverTime);
		}
        System.out.println("-------------运行进程----------");
        
   	 Cpu cpu = new Cpu();
        for (JCPro jcPro : sortProcessList) {
			//进程第一次进入CPU
        	JCPro jcPro2 = cpu.Cpu(jcPro);
        	
        	//进程剩余运行时间
        	int serverTime = jcPro2.getServeTime();
        	sortProcessList.remove(jcPro2);
        	if (serverTime > 0) {
        		sortProcessList.add(jcPro2);
			}
        	
        	if (sortProcessList.size() > 0) {
        		
				arCPU(sortProcessList);
				
			}else {
				System.out.println("结束");
			}
		}
        System.out.println("---------------------------------------------");
   }

}

 
package Process;

import java.util.ArrayList;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
    	
        Scanner scanner1 = new Scanner(System.in);
        System.out.println("请输入进程总数：");

        //processNum为进程总数
        int processNum = scanner1.nextInt();
        
        Scanner scanner2 = new Scanner(System.in);
        System.out.println("请输入进程名字，每个名字用一个空格隔开：");
        String names = scanner2.nextLine();
        //存储进程名字分割后的数组
        String[] nameList = names.split(" ");
        
        //输入每个进程需要运行的时间，以空格分开
        //如10 20 10 30 50
        Scanner scanner3 = new Scanner(System.in);
        System.out.println("请输入每个进程的运行时间，并以空格分开，如（10 20 10 30 50）");
        String proRunTimeStr = scanner3.nextLine();
        //存储进程时间字符串分割后的数组
        String[] proRunTimeStrList = proRunTimeStr.split(" ");

        //进程运行时间的个数
        int proRunTimeLength = proRunTimeStrList.length;


        //int类型存储进程时间(每个进程需要运行的时间)的数组
        int[] proRunTimeNumList = new int[proRunTimeLength];

        //把字符串类型存储进程时间的元素，存储到int类型的数组中
        for (int i = 0; i < proRunTimeLength; i++){
            proRunTimeNumList[i] = Integer.parseInt(proRunTimeStrList[i]);
        }
        
        //输入每个进程的优先级数
        System.out.println("请输入每个进程的优先级数，每个数用空格隔开，不能重复：");
        Scanner scanner4 = new Scanner(System.in);
        String priorityString = scanner4.nextLine();
        //存储优先级数的数组
        String[] priorityStrList = priorityString.split(" ");
        
        //存储所有已就绪进程对象的集合
        ArrayList<JCPro> jcProArrayList = new ArrayList<JCPro>();
        
        //循环设置进程对象
        for (int i = 0; i < processNum; i++) {
        	//进程名字
			String name = nameList[i];
			int serverTime = proRunTimeNumList[i];
			int priority = Integer.parseInt(priorityStrList[i]);![在这里插入图片描述](https://img-blog.csdnimg.cn/20201011235512226.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ0NjUx,size_16,color_FFFFFF,t_70#pic_center)

			JCPro jcPro = new JCPro();
			jcPro.setName(name);
			jcPro.setServeTime(serverTime);
			jcPro.setPriority(priority);
			//把设置完毕的进程存入存储就绪进程的集合
			jcProArrayList.add(jcPro);
		}
        ProcessL processL = new ProcessL();
        processL.arCPU(jcProArrayList);
    }
}

 
运行结果
 

 
Basic Framework
 
 
fileModel.java
 
package File_System_Structure;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class fileModel {
//fileModel类用来记录文件或目录的相关属性

    public Map<String, fileModel> subMap = new HashMap<String, fileModel>();
    private String name; //文件名或目录名
    private String type; //文件类型
    private int attr; //用来识别是文件还是目录 
    private int startNum;   //在FAT表中起始位置
    private int size;   //文件的大小
    private fileModel father = null;    //该文件或目录的上级目录

    public fileModel( String name, String type, int startNum, int size ){
        this.name = name;
        this.type = type;
        this.attr = 2;
        this.startNum = startNum;
        this.size = size;       
    }

    public fileModel( String name, int startNum ) {
        this.name = name;
        this.attr = 3;
        this.startNum = startNum;
        this.type = "  ";
        this.size = 1;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public int getAttr() {
        return attr;
    }
    public void setAttr(int attr) {
        this.attr = attr;
    }
    public int getStartNum() {
        return startNum;
    }
    public void setStartNum(int startNum) {
        this.startNum = startNum;
    }
    public int getSize() {
        return size;
    }
    public void setSize(int size) {
        this.size = size;
    }

    public fileModel getFather() {
        return father;
    }

    public void setFather(fileModel father) {
        this.father = father;
    }

}
 
OSManager.java
 
package File_System_Structure;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class OSManager {
    //OSManager这个类实现对文件的各种操作

    public Map<String, fileModel> totalFiles = new HashMap<String, fileModel>();
    //定义FAT表
    private int[] fat = new int[128]; 
    //创建根目录 使用fat表的第一项
    private fileModel root = new fileModel("root", 1);
    private fileModel nowCatalog = root;

    public OSManager() {
        //将FAT表初始化全部为0，并将第一位设为根目录的空间
        for( int i = 0; i < fat.length ; i++ ) {
            fat[i] = 0;
        }
        fat[ 1 ] = 255; //255表示磁盘块已占用
        fat[ 0 ] = 126; //纪录磁盘剩余块数  
        root.setFather( root );
        totalFiles.put( "root", root );
    }

    public int setFat(int size) {
        int[] startNum = new int[128];
        int i = 2; //纪录fat循环定位
        for( int j = 0; j < size; i++ ) {
            if( fat[ i ] == 0 ) {
                startNum[ j ] = i; //纪录该文件所有磁盘块
                if( j > 0 ) {
                    fat[ startNum[ j-1 ] ] = i; //fat上一磁盘块指向下一磁盘块地址
                }
                j++;
            }
        }
        fat[ i-1 ] = 255;
        return startNum[ 0 ]; //返回该文件起始块盘号
    }


    /*
     * 
     * 该方法用于删除时释放FAT表的空间
     */
    public void deleteFAT( int startNum ) {
        int nextPoint = fat[ startNum ];
        int nowPoint = startNum;
        int count = 0;
        while( fat[nowPoint ] != 0 ) {
            nextPoint = fat[ nowPoint ];
            if( nextPoint == 255 ) {
                fat[ nowPoint ] =0;
                count++;
                break;
            } else {
                fat[ nowPoint ] = 0;
                count++;
                nowPoint = nextPoint;
            }
        }
        fat[0] += count;
    }


    /*
     * 
     * 以下为追加内容时修改fat表
     * 
     */
    public void AddFAT(int startNum, int addSize) {
        int nowPoint = startNum;
        int nextPoint = fat[startNum];
        while( fat[ nowPoint ] != 255 ) {
            nowPoint = nextPoint;
            nextPoint = fat[ nowPoint ];
        }//找到该文件终结盘块

        for( int i = 2, count = 0; count < addSize; i++ ) {
            if( fat[ i ] == 0 ) {
                fat[ nowPoint ] = i;
                nowPoint = i;
                count++;
                fat[ nowPoint ] = 255;//作为当前文件终结盘块
            }
        }
    }

    /*
     *  以下为创建文件和目录方法
     * 
     */
    public void createFile( String name, String type, int size ) {

        if( fat[ 0 ] >= size ) {    //判断磁盘剩余空间是否足够建立文件
            fileModel value = nowCatalog.subMap.get( name ); //该目录下是否寻找同名目录或文件
            if( value != null ) {  //判断该文件是否存在
                if( value.getAttr() == 3 ) {   //若存在同名目录 继续创建文件
                    int startNum = setFat( size ); 
                    fileModel file = new fileModel( name, type, startNum, size );
                    file.setFather( nowCatalog ); //纪录上一层目录
                    nowCatalog.subMap.put( name, file ); //在父目录添加该文件
                    totalFiles.put( file.getName(), file );
                    fat[ 0 ] -= size;
                    System.out.println( "File is successfully created!" );
                    showFile();
                } else if( value.getAttr() == 2 ) { //若同名文件已存在，创建失败
                    System.out.println("File fails to create because the file already exists"); 
                    showFile();
                }
            } else if( value == null ) { //若无同名文件或文件夹，继续创建文件
                int startNum = setFat( size ); 
                fileModel file = new fileModel( name, type, startNum, size );
                file.setFather( nowCatalog ); //纪录上一层目录
                nowCatalog.subMap.put( name, file ); //在父目录添加该文件
                totalFiles.put( file.getName(), file );
                fat[0] -= size;
                System.out.println( "File is successfully created!");
                showFile();
                }
        } else {
            System.out.println("File fails to create because insufficient disk space！");
        }

    }

    public void createCatolog( String name ) {

        if( fat[ 0 ] >= 1 ) { //判断磁盘空间是否足够创建文件夹

            fileModel value = nowCatalog.subMap.get( name ); //判断该目录下是否存在同名目录或文件
            if( value != null ) {
                if( value.getAttr() == 2 ) {
                    int startNum = setFat( 1 );
                    fileModel catalog = new fileModel( name, startNum );
                    catalog.setFather( nowCatalog ); //纪录上一层目录
                    nowCatalog.subMap.put( name, catalog );
                    fat[ 0 ]--;
                    totalFiles.put( catalog.getName(), catalog );
                    System.out.println( "Directory is successfully created!" );
                    showFile();
                } 
                else if(value.getAttr() == 3) {
                    System.out.println( "Directory fails to create because the directory already exists!" );
                    showFile();
                } 
            } 
            else if(value == null) {
                int startNum = setFat(1);
                fileModel catalog = new fileModel( name, startNum );
                catalog.setFather( nowCatalog ); //纪录上一层目录
                nowCatalog.subMap.put( name, catalog );
                fat[ 0 ]--;
                totalFiles.put( catalog.getName(), catalog );
                System.out.println( "Directory is successfully created!" );
                showFile();
            }           
        } 
        else {
            System.out.println("Directory fails to create because insufficient disk space！");
        }
    }


    /*
     * 
     * 以下为显示该目录下的所有文件信息
     * 
     */
    public void showFile() {
        System.out.println("***************** < " + nowCatalog.getName() + " > *****************");

        if( !nowCatalog.subMap.isEmpty() ) {
            for( fileModel value : nowCatalog.subMap.values() ) {
                if(value.getAttr() == 3) { //目录文件
                    System.out.println("File Name:" + value.getName());
                    System.out.println("Operation Type:" + "Folder");
                    System.out.println("Starting Disk Blocks:" + value.getStartNum());
                    System.out.println("Size: " + value.getSize());
                    System.out.println("<-------------------------------------->");
                }
                else if(value.getAttr() == 2) {
                    System.out.println("File Name:" + value.getName() + "." + value.getType());
                    System.out.println("Operation Type: " + "Readable & Writable File");
                    System.out.println("Starting Disk Blocks:" + value.getStartNum());
                    System.out.println("Size:" + value.getSize());
                    System.out.println("<-------------------------------------->");
                }
            }
        }
        for(int i =0; i<2; i++) 
        System.out.println();
        System.out.println("Disk Surplus Space:" + fat[ 0 ] + "            " + "Exit the system please enter:exit");
        System.out.println();
    }

    /*
     * 
     * 以下为删除该目录下某个文件
     * 
     */
    public void deleteFile(String name) {

        fileModel value = nowCatalog.subMap.get( name );
        if( value == null ) {
            System.out.println("Delete failed, No File or Folder!!");
        } 
        else if( !value.subMap.isEmpty() ){
            System.out.println("Delete failed because the folder contains files!");
        } 
        else {
            nowCatalog.subMap.remove(name);
            deleteFAT(value.getStartNum());
            if(value.getAttr() == 3) {
                System.out.println("Folder " + value.getName() + " Have been successfully deleted");
                showFile();
            } 
            else if(value.getAttr() == 2) {
                System.out.println("File " + value.getName() + "Have been successfully deleted");
                showFile();
            }
        }
    }

    /*
     * 
     * 以下为文件或文件夹重命名方法
     * 
     */
    public void reName(String name, String newName) {
        if( nowCatalog.subMap.containsKey(name) ) {
            if( nowCatalog.subMap.containsKey( newName ) ) {
                System.out.println("Rename failed because the same name file already exists!"); 
                showFile();
            } 
            else {
                fileModel value = nowCatalog.subMap.get( name );
                value.setName( newName );
                nowCatalog.subMap.remove( name );
                nowCatalog.subMap.put( newName, value );
                System.out.println( "Rename has succeed" );
                System.out.println();
                showFile();
            }
        } 
        else {
            System.out.println("Rename failed because there is no this file");
            showFile();
        }
    }

    /*
     * 
     * 以下为修改文件类型
     * 修改类型需要打开文件后才能操作
     */
    public void changeType( String name, String type ) {

        nowCatalog = nowCatalog.getFather();
        if( nowCatalog.subMap.containsKey( name ) ) {
            fileModel value = nowCatalog.subMap.get( name );
            if(value.getAttr() == 2){
                value.setType(type);
                nowCatalog.subMap.remove(name);
                nowCatalog.subMap.put(name, value);
                System.out.println("Modify type success!");
                showFile();
            } 
            else if(value.getAttr() == 3) {
                System.out.println("Change error because the folder can not modify type!！");
                openFile( value.getName() );
            }
        } 
        else {
            System.out.println("Modify error, please check whether the input file name is correct！");
        }
    }

    /*
     * 以下为打开文件或文件夹方法
     * 
     */
    public void openFile( String name ) {
        if( nowCatalog.subMap.containsKey( name ) ) {
            fileModel value = nowCatalog.subMap.get(name);
            if(value.getAttr() == 2) {
                nowCatalog = value;
                System.out.println("The file has been opened and the file size is: " + value.getSize() );               
            }
            else if(value.getAttr() == 3) {
                nowCatalog = value;
                System.out.println("The file has been opened!");
                showFile();
            }
        } 
        else{
            System.out.println("Open failed because the file does not exist!");
        }
    }


    /*
     * 
     * 以下为向文件追加内容方法
     * 追加内容需要打开文件后才能操作
     */
    public void reAdd(String name, int addSize){
        if( fat[0] >= addSize ) {
            nowCatalog = nowCatalog.getFather();
            if(nowCatalog.subMap.containsKey(name)) {
                fileModel value = nowCatalog.subMap.get(name);
                if(value.getAttr() == 2) {
                    value.setSize(value.getSize() + addSize);
                    AddFAT(value.getStartNum(), addSize);
                    System.out.println("Addition content is successful! The file is being reopened...");
                    openFile(name);
                } 
                else{
                    System.out.println("The appended content failed, please verify that the filename is entered correctly.");                   
                }
            }
        }
        else{
            System.out.println("Addition content is failed because insufficient memory space");
            }
        }


    /*
     * 
     * 以下为返回上一层目录
     * 
     */
    public void backFile() {
        if(nowCatalog.getFather() == null) {
            System.out.println("The document does not have a superior directory!");
        } else {
            nowCatalog = nowCatalog.getFather();
            showFile();
        }
    }

    /*
     * 以下根据绝对路径寻找文件
     * 
     */
    public void searchFile(String[] roadName) {

        fileModel theCatalog = nowCatalog; //设置断点纪录当前目录

        if( totalFiles.containsKey(roadName[roadName.length-1]) ) { //检查所有文件中有无该文件
            nowCatalog = root; //返回根目录
            if( nowCatalog.getName().equals( roadName[0]) ) {   //判断输入路径的首目录是否root
                System.out.println("yes");
                for( int i = 1; i < roadName.length; i++ ) {
                    if( nowCatalog.subMap.containsKey( roadName[ i ] ) ) {
                        nowCatalog = nowCatalog.subMap.get( roadName[ i ] ); //一级一级往下查

                    } 
                    else {
                        System.out.println("Can't find the file or directory under this path, please check whether the path is correct!");
                        nowCatalog = theCatalog;
                        showFile();
                        break;
                    }
                }
                if( roadName.length > 1 ){
                    nowCatalog = nowCatalog.getFather(); //返回文件上一级目录 
                    showFile();
                }
            } 
            else{
                nowCatalog = theCatalog;
                System.out.println("Please enter the correct absolute path！");
                showFile();
            }
        } 
        else{
            System.out.println("This file or directory does not exist, please enter the correct absolute path！");
            showFile();
        }
    }

    /*
     * 以下为打印FAT表内容
     * 
     */
    public void showFAT() {

        for(int j=0; j<125; j+=5) {
            System.out.println("第几项 | " + j + "        " + (j+1) + "        " + (j+2) + "        "
                    + (j+3) + "        " + (j+4));
            System.out.println("内容 | " + fat[j] + "        " + fat[j+1] + "        " + fat[j+2]
                     + "        " + fat[j+3] + "        " + fat[j+4]);
            System.out.println();
        }
        int j = 125;
        System.out.println("第几项 | " + j + "        " + (j+1) + "        " + (j+2));
        System.out.println("内容 | " + fat[j] + "        " + fat[j+1] + "        " + fat[j+2]);
        System.out.println();
        showFile();
    }
}
 
testFileSystem.java
 
package File_System_Structure;

import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class testFileSystem {
    public static void main(String[] args) {
        try{
            OSManager manager = new OSManager();
            meun(manager);
            }
        catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void meun(OSManager manager) {
        Scanner s = new Scanner(System.in);
        String str = null;
        System.out.println("***********" + "Welcome to use the file simulation operating system" + "***********");
        System.out.println();
        manager.showFile();

        System.out.println("Please enter command line（Enter help to view the command table）：");
        while ((str = s.nextLine()) != null) {
            if (str.equals("exit")) {
                System.out.println("Thank you！");
                break;
            }

            String[] strs = editStr(str);
            switch (strs[0]) {
            case "createFile":
                if (strs.length < 4) {
                    System.out.println("The command you have entered is incorrect. Please check it.");
                } 
                else {
                    manager.createFile(strs[1], strs[2],
                            Integer.parseInt(strs[3]));
                    }
                break;
            case "createCatalog":
                if (strs.length < 2) {
                    System.out.println("The command you have entered is incorrect. Please check it.");
                } 
                else {
                    manager.createCatolog(strs[1]);
                    }
                break;
            case "open":
                if (strs.length < 2) {
                    System.out.println("The command you have entered is incorrect. Please check it.");
                } 
                else {
                    manager.openFile(strs[1]);
                    }
                break;
            case "cd":
                if (strs.length < 2) {
                    System.out.println("The command you have entered is incorrect. Please check it.");
                } 
                else {
                    manager.openFile(strs[1]);
                    }
                break;
            case "cd..":
                manager.backFile();
                break;
            case "delete":
                if (strs.length < 2) {
                    System.out.println("The command you have entered is incorrect. Please check it.");
                } 
                else {
                    manager.deleteFile(strs[1]);
                    }
                break;
            case "rename":
                if (strs.length < 3) {
                    System.out.println("The command you have entered is incorrect. Please check it.");
                } 
                else {
                    manager.reName(strs[1], strs[2]);
                    }
                break;
            case "search": {
                if (strs.length < 2) {
                    System.out.println("The command you have entered is incorrect. Please check it.");
                } 
                else {
                    String[] roadName = strs[1].split("/");
                    manager.searchFile(roadName);
                    }
                break;
            }
            case "showFAT":
                manager.showFAT();
                break;
            case "addContents":
                if (strs.length < 3) {
                    System.out.println("The command you have entered is incorrect. Please check it.");
                } 
                else {
                    manager.reAdd(strs[1], Integer.parseInt(strs[2]));
                    }
                break;
            case "changeType":
                if (strs.length < 3) {
                    System.out.println("The command you have entered is incorrect. Please check it.");
                } else {
                    manager.changeType(strs[1], strs[2]);
                }
                break;
            case "help": {
                System.out.println("The commands are as follows（Space cannot be omitted）：");
                System.out
                        .println("createFile FileName fileType fileSize");
                System.out.println("<Create a file, for instance：createFile PUSU txt 5 >");
                System.out.println();
                System.out
                        .println("createCatalog FatalogName");
                System.out.println("<Create a directory, for instance：createCatalog myFile >");
                System.out.println();
                System.out
                        .println("open Name.FileTypt");
                System.out.println("<Open a file, for instance：open PUSU.txt >");
                System.out.println();
                System.out.println("cd CatalogName");
                System.out.println("<Open a directory, for instance： cd myFile >");
                System.out.println();
                System.out.println("cd..");
                System.out.println("<Return to the superior directory, for instance： cd..");
                System.out.println();
                System.out
                        .println("delete FileName/CatalogName");
                System.out.println("<Delete a files or a directory (the directory must be empty), for instance：delete PUSU >");
                System.out.println();
                System.out
                        .println("rename FileName/CatalogName NewName");
                System.out.println("<rename a file or a directory, for instance： rename myfile mycomputer >");
                System.out.println();
                System.out
                        .println("search FileAbsolutedRoad/CatalogAbsolutedRoad");
                System.out.println("<Finding a file or directory based on an absolute path, for instance： search root/marco >");
                System.out.println();
                System.out.println("showFAT");
                System.out.println("<Look at the FAT table, for instance： showFAT>");
                System.out.println();
                System.out.println();
                System.out.println("The following command needs to open the file before：");
                System.out
                        .println("addContents FileName ContentSize");
                System.out.println("<Add content to a file, for instance：ddContents PUSU 4 >");
                System.out.println();
                System.out
                        .println("changeType FileName newType");
                System.out.println("<Change file type, for instance： changeType PUSU doc>");
                System.out.println();
                break;
            }
            default:
                for(String st : strs)
                    System.out.println(st);
                System.out.println("The command you have entered is incorrect. Please check it.");
            }
            System.out.println("Please enter command line（Enter help to view the command table）：：");
        }
    }

    public static String[] editStr(String str) {
        Pattern pattern = Pattern.compile("([a-zA-Z0-9.\\\\/]*) *");// 根据空格分割输入命令
        Matcher m = pattern.matcher(str);
        ArrayList<String>  list = new ArrayList<String>();
        while(m.find()){
            list.add(m.group(1));
        }
        String[] strs = list.toArray(new String[list.size()]);

        for (int i = 1; i < strs.length; i++) { // 判断除命令以外每一个参数中是否含有 "."
            int j = strs[i].indexOf(".");
            if (j != -1) { // 若含有"." 将其切割 取前部分作为文件名
                String[] index = strs[i].split("\\."); // 使用转义字符"\\."
                strs[i] = index[0];
            }
        } 
        return strs;
    }

}
 
Running Effect
 
 
  
  
 
 
Source Download
 
Please click the address->File System Structure
 
Summarize
 
用java语言模拟操作系统中的文件管理系统，文件模拟磁盘，数组模拟缓冲区，其中： 
 
支持多级目录结构，支持文件的绝对读路径；
文件的逻辑结构采用流式结构，物理结构采用链接结构中的显式链接方式；
采用文件分配表FAT；
实现的命令包括建立目录、列目录、删除空目录、建立文件、删除文件、显示 
 文件内容、打开文件、读文件、写文件、关闭文件、改变文件属性。可以采用 
 命令行界面执行这些命令，也可以采用“右击快捷菜单选择”方式执行命令。
后编写主函数对所作工作进行测试。
 
原文地址：www.iooy.com

项目目标：
 
1、记录不同用户的基本信息：用户名、身份证、账户、开户行、存款余额等
 
2、能对银行用户信息进行增删改等操作
 
3、有欢迎界面
 
4、有银行信息管理界面
 
有需要Java代码的可以去我的GitHub上下载：Fated-2 GitHub
 
JAVA代码：
 
1.欢迎界面
 
思路：首先要有一个进入系统的主界面，要先计算好窗口的大小，然后在窗口中添加一些按钮、图标、带合适大小的图片背景的标签。
 
package BankSystem;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javafx.scene.image.Image;

/*
 * 银行信息管理系统
 * 1、记录不同用户的基本信息：用户名、身份证、账户、开户行、存款余额等
 * 2、能对银行用户信息进行增删查改等操作
 * 3、能实现存款、取款、登录、注册等功能。
 * 4、有欢迎界面
 * 5、有银行信息管理界面
 */
public class Main {
	

	public static void main(String[] args) {
		new WelcomeDemo();

	}

}


//书写进入界面
class WelcomeDemo extends JFrame{
	
	private JFrame window;
	private JButton enter,exit;
	private JLabel lb;
	private JPanel pEnter;
	
	public WelcomeDemo() {
		window=new JFrame("我家银行欢迎您");
		window.setSize(750, 540);//窗口大小
		window.setLocationRelativeTo(null);//居中显示
		window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//默认可关闭
		window.setLayout(null);//绝对布局
		window.setResizable(false);//窗口大小不可变
		window.setIconImage(new ImageIcon("4811FF28.png").getImage());//设置图标
		
		ImageIcon icon = new ImageIcon("450007f6f34d9d1e.jpg");
		icon.setImage(icon.getImage().getScaledInstance((int)(icon.getIconWidth()), 
				(int)(icon.getIconHeight()*0.95),0 ));
		lb=new JLabel(new ImageIcon("450007f6f34d9d1e.jpg"));
		lb.setBounds(0, 0, (int)(icon.getIconWidth()), (int)(icon.getIconHeight()*0.95));
		window.add(lb,BorderLayout.NORTH);//添加带图片的标签
		
		exit = new JButton("退出系统");
		enter=new JButton("进入系统");
		enter.setBounds(200,440,120,50);
		exit.setBounds(350, 440,120,50);
		window.add(enter);
		window.add(exit);
		
		addListened();
		window.setVisible(true);
		
	}
	
	//添加按钮监听事件
	public void addListened() {
		enter.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("按钮被按下");
				//进入银行信息管理界面
					new BankJPanel();
					window.dispose();//关闭窗口
				
			}
		});
		exit.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent arg0) {
				window.dispose();//关闭窗口
				
			}
		});
	}
	
	
}
 
运行结果：
 
 
2.实现银行信息管理系统的增、删、改功能
 
思路：要实现添加、删除、修改的操作就得增加监听事件，并且添加之前用flag判断是否有重复的用户，我用数组存的用户的相关信息，也可以用集合存储。
 
package BankSystem;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.table.DefaultTableModel;


/*
 * 实现银行管理系统的主要功能
 * 增加、删除、修改、查询
 */
public class BankJPanel {

	private JFrame Bank;//主面板
	private JPanel p1,p2;//两个界面
	private JLabel lbTitle;//列表标签
	private JTable table;//表格
	String[][] data=null;
	String[] cols = {"用户名","身份证","账户","开户行","存款余额"};
	
	private JLabel lbUser;//用户标签
	private JLabel lbIdentify;//身份证标签
	private JLabel lbAccount;//账户标签
	private JLabel lbDeposit;//开户行标签
	private JLabel lbRemain;//余额标签
	
	private JTextField tfUser;//用户文本框
	private JTextField tfIdentify;//身份证文本框
	private JTextField tfAccount;//账户文本框
	private JTextField tfDeposit;//开户行文本框
	private JTextField tfRemain;//余额文本框
	
	private JButton btAdd;//添加按钮
	private JButton btDelete;//删除按钮
	private JButton btUpdate;//修改按钮
	
	int index;//设置下标
	String[] name;
	String[] id;
	String[] ac;
	String[] de;
	String[] re;
	Listenered l;
	
	//构造器初始化 
	public BankJPanel() {
		
		l = new Listenered();
		index = 1;
		data = new String[1][5];
		name = new String[100];
		id = new String[100];
		ac = new String[100];
		de = new String[100];
		re = new String[100];
		
		//窗口初始化
		Bank=new JFrame("银行信息管理系统");
		Bank.setSize(600, 400);
		Bank.setLocationRelativeTo(null);//居中
		Bank.setResizable(false);
		Bank.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		Bank.setLayout(null);
		
		//表格标题
		lbTitle=new JLabel("用户的基本信息");
		lbTitle.setBounds(250, 20, 140, 25);
		Bank.add(lbTitle);
		
		//表格添加与设置
		table = new JTable();
		String[][] data = new String[1][5];
		data[0][0]=name[0]="小张";
		data[0][1]=id[0]="123456789";
		data[0][2]=ac[0]="123";
		data[0][3]=de[0]="456";
		data[0][4]=re[0]="789";
		table = new JTable(data,cols);
		table.getTableHeader().setReorderingAllowed(false);//不可改变列顺序
		table.getTableHeader().setResizingAllowed(false);//不可改变列宽
		table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);//只能选一行
		JScrollPane jp=new JScrollPane(table);//添加滚动效果
		jp.setBounds(50, 50, 500, 200);
		Bank.add(jp);
		
		//添加编辑区域的组件
		lbUser = new JLabel("用户名",JLabel.RIGHT);
		lbUser.setBounds(40, 265, 50, 25);
		Bank.add(lbUser);
		lbIdentify = new JLabel("身份证",JLabel.RIGHT);
		lbIdentify.setBounds(210, 265, 50, 25);
		Bank.add(lbIdentify);
		lbAccount = new JLabel("账户",JLabel.RIGHT);
		lbAccount.setBounds(370, 265, 50, 25);
		Bank.add(lbAccount);
		lbDeposit = new JLabel("开户行",JLabel.RIGHT);
		lbDeposit.setBounds(40, 295, 50, 25);
		Bank.add(lbDeposit);
		lbRemain = new JLabel("存款余额",JLabel.RIGHT);
		lbRemain.setBounds(200, 295, 70, 25);
		Bank.add(lbRemain);
		tfUser = new JTextField();
		tfUser.setBounds(90, 265, 120, 25);
		Bank.add(tfUser);
		tfIdentify = new JTextField();
		tfIdentify.setBounds(261, 265, 120, 25);
		Bank.add(tfIdentify);
		tfAccount = new JTextField();
		tfAccount.setBounds(421, 265, 120, 25);
		Bank.add(tfAccount);
		tfDeposit = new JTextField();
		tfDeposit.setBounds(90, 295, 120, 25);
		Bank.add(tfDeposit);
		tfRemain = new JTextField();
		tfRemain.setBounds(271, 295, 120, 25);
		Bank.add(tfRemain);
		
		//添加按钮
		btAdd = new JButton("添加信息");
		btAdd.setBounds(100, 330, 100, 25);
		Bank.add(btAdd);
		btUpdate = new JButton("修改信息");
		btUpdate.setBounds(250, 330, 100, 25);
		Bank.add(btUpdate);
		btDelete = new JButton("删除信息");
		btDelete.setBounds(400, 330, 100, 25);
		Bank.add(btDelete);
		
		//给按钮添加监听事件
		btAdd.addActionListener(l);
		btDelete.addActionListener(l);
		btUpdate.addActionListener(l);
		
		//鼠标表格监听
		addListened();
		Bank.setVisible(true);
		
	}
	
	//添加按钮监听事件
	public void addListened() {
		//表格的处理事件
		table.addMouseListener(new MouseAdapter() {
			
			@Override
			public void mouseClicked(MouseEvent arg0) {
				int row = table.getSelectedRow();//获取表格中被选中的行
				//设置文本框的内容
				tfUser.setText(data[row][0]);
				tfIdentify.setText(data[row][1]);
				tfAccount.setText(data[row][2]);
				tfDeposit.setText(data[row][3]);
				tfRemain.setText(data[row][4]);
			}
		});
	}

		
		//监听事件（java内部类）：实现监听接口
		class Listenered implements ActionListener{

			@Override
			public void actionPerformed(ActionEvent e) {
				//按钮被按下货点击时调用
				// ActionEvent e--指代的是按下的辣个按钮
				//e.getSource():获取按下的按钮
				
				if(e.getSource() == btAdd) {
					
					System.out.println("确认添加");
					int flag=0;//标记是否有重复，添加不同的用户信息
					if(!(tfUser.getText().equals(""))) {
						
						//获取用户输入的数据
						name[index] = tfUser.getText();
						id[index] = tfIdentify.getText();
						ac[index] = tfAccount.getText();
						de[index] = tfDeposit.getText();
						re[index] = tfRemain.getText();
						for (int i = 0; i < index; i++) {
							if(id[index].equals(id[i])) {
								flag=1;
							}
						}
						
						if(flag == 0) {
							
							index++;
							sortMess();
							JOptionPane .showMessageDialog(null, "添加成功","输入用户信息提示框",JOptionPane.INFORMATION_MESSAGE);
							clear();
						}else {
							
							/*
							 * 弹出提示框：用户重复  跳转界面 
							 */
							JOptionPane .showMessageDialog(null, "用户已存在","输入用户信息提示框",JOptionPane.INFORMATION_MESSAGE);
							clear();//清空文本框
							
						}
						
					}
					
					
				}
				
				if(e.getSource() == btUpdate) {
					
					System.out.println("确认修改");
					if(!(tfUser.getText().equals(""))) {
						
						//获取用户输入的数据
						String user = tfUser.getText();
						String identify = tfIdentify.getText();
						String account = tfAccount.getText();
						String deposit = tfDeposit.getText();
						String remain = tfRemain.getText();
						for (int i = 0; i < index; i++) {
							if(identify.equals(id[i])) {
								name[index] = user;
								id[index] = identify;
								ac[index] = account;
								de[index] = deposit;
								re[index] = remain;
							}
						}
						sortMess();
						JOptionPane .showMessageDialog(null, "修改成功","输入用户信息提示框",JOptionPane.INFORMATION_MESSAGE);
						clear();
					}
				}
				
				if(e.getSource() == btDelete) {
					System.out.println("确认删除");
					if(!(tfUser.getText().equals(""))) {
						
						//获取用户输入的数据
						String identify = tfIdentify.getText();
						for (int i = 0; i < index-1; i++) {
							if(identify.equals(id[i])) {
								name[index] = name[index+1];
								id[index] = id[index+1];
								ac[index] = ac[index+1];
								de[index] = de[index+1];
								re[index] = re[index+1];
							}
						}
						index = index-1;
						sortMess();
						JOptionPane .showMessageDialog(null, "删除成功","输入用户信息提示框",JOptionPane.INFORMATION_MESSAGE);
						clear();
					}
				}
				
				
			}
			
			
			//创建一个方法把新的数组元素添加到表格中
			public void sortMess() {
				data = new String[index][5];
				for (int i = 0; i < index; i++) {
					data[i][0] = name[i];
					data[i][1] = id[i];
					data[i][2] = ac[i];
					data[i][3] = de[i];
					data[i][4] = re[i];
				}
				DefaultTableModel tableModel = new DefaultTableModel(data, cols);
				table.setModel(tableModel);
			}
			
			//清空文本框
			public void clear() {
				tfUser.setText(null);//清空用户文本框
				tfIdentify.setText(null);//清空身份证文本框
				tfAccount.setText(null);
				tfDeposit.setText(null);
				tfRemain.setText(null);
			}
			
		}
	
	
	public static void main(String[] args) {
		new BankJPanel();

	}

}
 
运行结果：