精华内容
下载资源
问答
  • java编写操作系统

    2012-09-23 23:02:15
    java编写操作系统,很好的。功能基本实现了操作系统功能,并且代码设计的很美观。
  • java 编写操作系统课程设计 比较不错的例子 有图形页面 包括文件管理 设备管理 存储管理 进程管理和cpu单元
  • 针对操作系统的一个模拟系统,内含硬盘管理,内存管理,虚拟显示器,进程管理,作业管理等等功能实现。以及外加完整的模拟操作系统设计报告,使用说明书和操作系统设计方案,程序分析报告。...纯JAVA编写
  • java编写购书系统

    千次阅读 2019-12-18 15:03:33
    开发基于控制台的购书系统 输出所有图书的信息:包括每本图书的图书编号、图书名称、图书单价和库存数量。 顾客购买图书; 购书完毕后输出顾客的订单信息:包括订单号、订单明细、订单总额和订单。 系统功能: 管理...

    开发基于控制台的购书系统

    输出所有图书的信息:包括每本图书的图书编号、图书名称、图书单价和库存数量。
    顾客购买图书;
    购书完毕后输出顾客的订单信息:包括订单号、订单明细、订单总额和订单。

    系统功能:

    1. 管理员可通过系统创建图书、查看图书。
    2. 顾客可通过系统购买图书,并自动生成订单。

    管理员权限操作如下:
    权限选择界面
    进入管理员权限操作如下:
    进入管理员界面
    管理员可以通过编号1来创建图书,创建好的图书会提示自动更新到书库中,也可以通过编号2来查询书库中已创建过得图书,操作如下:在这里插入图片描述
    创建时如果图书编号相同,数量则会被累计到已创建的图书里:操作如下:创建同样的数,数量累计图
    如果第一次运行,图书尚未创建图书时,则提示“书库中没有书,请创建图书”,操作如下:没有创建图书时,查看图书的结果
    顾客权限操作如下:进入顾客权限
    顾客权限中可以同过编号1来查看已经创建的图书,如果在书库中没有书的情况下则提示“书库中没有书,请联系管理员更新书库”操作如下:查看图书集
    提示书库中没有图书
    顾客可以通过编号2来进行对图书的购买,购买时需要输入购买书的编号以及数量,添加成功则提示“购买图书添加成功”,如果输入的编号不存在或者数量小于0或大于库存则提示重新添加,操作如下:图书购买成功
    顾客通过编号3结束购买,此时系统会自动生成订单并打印出来,重复的书则不重复打印,购买完成则退出到选择权限界面,如要购买请重新选择顾客:操作如下:
    打印订单并退出

    原码地址://download.csdn.net/download/qq_37468222/12038064

    展开全文
  • 操作系统实验 多线程同步与互斥 java编写 可动态创建
  • 操作系统实验 内存管理 java编写 利用链表管理内存
  • 计算机操作系统实验一:进程调度 **[目的要求]  用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.  [准备知识]  一、基本概念  1、进程的概念;  2、进程的状态和进程控制块;...

    计算机操作系统实验一:进程调度

    [目的要求]
      用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.
      [准备知识]
       一、基本概念
       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);
        }
    }
    
    

    运行结果
    在这里插入图片描述

    展开全文
  • Java编写的图书馆管理系统,使用MySQL数据库,C/S模式。 能够通过书籍基本信息(包括:书号、书名、出版社、出版日期、作者、内容摘要)单个或以AND方式组合多个条件查询书籍信息; 对于每一种书籍,除可查看其基本...
  • 如何用Java编写判断当前操作系统是32位还是64位 注意:不是JDK
  • java语言实现操作系统中的文件管理系统

    万次阅读 多人点赞 2017-12-08 11:50:27
    java语言模拟操作系统中的文件管理系统,文件模拟磁盘,数组模拟缓冲区,其中: 1. 支持多级目录结构,支持文件的绝对读路径; 2. 文件的逻辑结构采用流式结构,物理结构采用链接结构中的显式链接方式; 3. ...

    123.jpg

    Basic Framework

    屏幕快照 2017-12-08 11.38.25.png

    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

    屏幕快照 2017-12-08 11.35.56.png
    屏幕快照 2017-12-08 11.36.09.png
    屏幕快照 2017-12-08 11.36.30.png
    屏幕快照 2017-12-08 11.36.40.png

    Source Download

    Please click the address->File System Structure

    Summarize

    用java语言模拟操作系统中的文件管理系统,文件模拟磁盘,数组模拟缓冲区,其中:

    1. 支持多级目录结构,支持文件的绝对读路径;
    2. 文件的逻辑结构采用流式结构,物理结构采用链接结构中的显式链接方式;
    3. 采用文件分配表FAT;
    4. 实现的命令包括建立目录、列目录、删除空目录、建立文件、删除文件、显示
      文件内容、打开文件、读文件、写文件、关闭文件、改变文件属性。可以采用
      命令行界面执行这些命令,也可以采用“右击快捷菜单选择”方式执行命令。
    5. 后编写主函数对所作工作进行测试。

    原文地址:www.iooy.com

    展开全文
  • JAVA编写一个银行信息管理系统

    万次阅读 多人点赞 2019-01-01 16:43:03
    2、能对银行用户信息进行增删改等操作 3、有欢迎界面 4、有银行信息管理界面 JAVA代码: 1.欢迎界面 思路:首先要有一个进入系统的主界面,要先计算好窗口的大小,然后在窗口中添加一些按钮、图标、带合适大小...

    项目目标:

    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();
    
    	}
    
    }
    

    运行结果:

    展开全文
  • JAVA编写的ATM柜员机模拟程序系统(连接数据库)

    万次阅读 多人点赞 2019-10-21 17:49:02
    一、 设计任务与目的 1、查询余额:初始余额为10000元 2、ATM取款:每次取款金额为100的倍数,总额不超过5000元,支取金额不允许透支...二、系统设计 用户功能模块设计 连接数据库 加载驱动类,执行该类中的初始代码...
  • 通过JAVA编写一个简单的雇员管理系统小项目

    千次阅读 多人点赞 2017-10-21 21:35:08
     * 项目:公司职员薪水管理系统  * 作者:zyj0813  * 项目需求:  * 1、添加新员工  * 2、根据员工号显示该员工信息  * 3、显示所有员工信息  * 4、删除员工信息  * 5、统计公司的平均薪水  * 6、...
  • java编写的一个多线程程序,模拟银行排队.-prepared in a multithreaded process that simulates the bank queue.
  • Java多线程和操作系统多线程关系

    千次阅读 2017-03-29 15:07:26
    这篇文章要讨论的是Java编程中的多线程和操作系统中的多线程的区别问题。 线程状态。首先两者的线程状态是一样的。(创建、就绪、执行、阻塞、终止),其实这五个状态也是进程的状态。 那么Java中的多线程 和 OS...
  • 基于java编写的网上书店管理系统

    热门讨论 2011-09-25 11:32:51
    网上书店java管理系统,功能全面我设计的是一个网上书店的系统,网上书店是电子商务的一种。电子商务是可以提供网上交易和管理等全过程的服务,具有广告宣传咨询洽谈、网上订购、网上支付、电子账户、服务传递、意见...
  • Java编写的仿windows自带计算器程序的源代码,可用任何文本编辑器打开。 从界面到功能80%与windows计算器程序一致,适合GUI编程初学者学习。 技术特点:OOP思想,MVC,内部类。
  • 编写Java程序_连锁超市购物结算系统

    万次阅读 2020-03-18 14:14:47
    连锁超市购物结算系统主要功能包括:显示商品信息,购物清单,结算功能。 总体用例图: 一、Use Case1 显示商品信息列表: 显示商品信息,供收银员参考查询。 二、Use Case 2输入购买商品编号 顾客在购物...
  • 非连续式分配就是把要执行的程序按照一定规则进行拆分,显然这样更有效率,现在的操作系统通常也都是采用这种方式分配内存 关于内存的原理部分本文只讲到这里,本文主要关注动态分区分配算法 三. 动态分区分配 ...
  • 进程调度java编写含界面

    热门讨论 2013-01-13 10:46:34
    java编写的模拟操作系统进程调度程序,使用了swing组件,具有十分友好的调度界面,含三种调度算法分别是:先进先出、基于优先度优先和最短执行时间调度算法
  • 数据库用的是MySQL,但Java操作方面的不知道怎么入手,求大神指点啊,有实例参考就更好了,谢谢
  • 每一个刚开始写java程序的时候,都会写helloworld相关的程序,其实这个程序还是很简单的,那么几年我们就来给大家讲解一下这方面的内容。一.创建Java应用程序源文件1)打开文本编辑器NotePad(记事本)【开始】→【程序...
  • Java图书管理系统

    万次阅读 多人点赞 2018-05-31 07:58:44
    学习要学以致用,于是写了一个粗糙的java图书管理系统,实现了图书的增删改查的基本操作,在写的过程中遇到了很多问题,不过也都通过暴力解决了。大晚上的脑仁不够用了, 直接上图吧。主界面:增加图书:查找图书:...
  • java+MySQL用户管理系统

    热门讨论 2013-04-25 16:32:35
    此代码主要是用JDBC和MySQL数据库完成一个简单的用户管理系统系统的设计模式采用工场模 式和代 理模式,此代码很适合初学Java者。 运行方法: 1.运行需要启动MySQL数据库 2.创建数据库名为zhaochao和表名为...
  • java电影院售票系统

    热门讨论 2014-11-09 22:10:32
    有简单界面的电影院售票系统,功能有用XML存储电影资源,把已售的电影票信息保存到txt文件中,再以电影票的形式打印到txt文件中。
  • java实现简单超市管理系统

    千次阅读 2021-02-12 16:34:32
    本文实例为大家分享了java实现超市管理系统的具体代码,供大家参考,具体内容如下一、使用技术javaSE二、实现功能超市管理系统具体要求如下:使用选择结构,循环结构,数组的知识实现一个超市管理系统三、运行效果图...
  • 初学java,试着写了一个小程序,可能有很多不足,希望大家多多见谅。 import java.util.Scanner; public class Demo04 { public static void main(String[]... System.out.println("请输入要操作的选项:1 加法 2 减法
  • 如果CPU在DMA初始化设置和启动硬盘操作等方面用了1000个时钟周期,并且在DMA传送完成后的中断处理需要500个时钟,则在硬盘100%处于工作状态的情况下, CPU用于硬盘I/O操作的时间百分比大约是多少?案例分析二:请求...
  • JAVA+MySQL学生成绩管理系统

    热门讨论 2017-12-08 11:29:35
    程序是使用java编写的,实现学生成绩的录入,查询,修改以及删除等功能,通过连接数据库对数据的存储,采用Java中Swing图形用户界面平台进行操作实现简单的数据操作
  • Java编写一个最简单的桌面程序

    万次阅读 多人点赞 2018-03-03 13:42:30
    使用这个包可以编写简单的Java桌面应用程序.Java的javax.swing包提供了许多用来设计GUI的组件类,在学习GUI编程时,需要掌握两个概念:容器类(Container)和组件类(Component),以下是GUI编程中经常提到的基本知识点.&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 542,562
精华内容 217,024
关键字:

java编写的操作系统

java 订阅