如果你有更好的建议,感谢你能给我提出来吗?

package com.java.bankAlogrithm;
 import javax.swing.JOptionPane;
public class Bank {
  private final int MAXRESOURCE=200;//系统最大的资源数
  private int available[];//可利用的资源
  private int max[][];//最大需求矩阵
  private int allocation[][];//以分配的资源
  private int need[][];//需求的资源
  private boolean finish[];//true  表示完成       false  表示完成
  private int p[];//记录安全序列
  private int process;//进程数
  private int source;//资源数
  private String str;//方便全部显示到面板上
  
  //开始输入必要的数据;
  public Bank(){
   //首先要确定进程数目和资源种类  process=Integer.parseInt(JOptionPane.showInputDialog("请输入进程的数目"));
   source=Integer.parseInt(JOptionPane.showInputDialog("请输入资源种类"));
   
   
   //输入最大需求矩阵  JOptionPane.showMessageDialog(null, "请输入一个"+process+"行"+source+"列的最大需求矩阵");
   max=new int[process][source];
   for(int i=0;i<process;i++){
    for(int j=0;j<source;j++){
     String sle=JOptionPane.showInputDialog("请输入第"+i+"个进程"+"第"+j+"种最大需求资源");
     max[i][j]=Integer.parseInt(sle);
    }
   }
   //输入分配矩阵
  
   
   JOptionPane.showMessageDialog(null, "请输入一个"+process+"行"+source+"列的分配矩阵");
   allocation=new int[process][source];
   for(int i=0;i<process;i++){
    for(int j=0;j<source;j++){
     String sle=JOptionPane.showInputDialog("请输入第"+i+"个进程"+"第"+j+"种分配资源");
     allocation[i][j]=Integer.parseInt(sle);
    }
   }
   
   //输入可用资源  JOptionPane.showMessageDialog(null, "请输入可用资源");
   available=new int[MAXRESOURCE];
   for(int i=0;i<source;i++){
    String sle=JOptionPane.showInputDialog("请输入第"+i+"种可用资源");
    available[i]=Integer.parseInt(sle);
   }
   //计算尚需资源
   need=new int[process][source];
   for(int i=0;i<process;i++){
    for(int j=0;j<source;j++){
     need[i][j]=max[i][j]-allocation[i][j];
     if(need[i][j]<0){
      JOptionPane.showMessageDialog(null, "输入错误,需求资源不能是复数");
     }
    }
   }
   
   print();
  }
  
  //打印输入的序列
  public void print(){
   str+="进程     max/t/tallocation/t  need/t/tavailable/n";
   str+="P0  ";
   for (int i = 0; i <source; i++) {
    str+=max[0][i]+"   ";
   }
   str+="  ";
   for (int i = 0; i <source; i++) {
    str+=allocation[0][i]+"   ";
   }
   str+="  ";
   for (int i = 0; i <source; i++) {
    str+=need[0][i]+"   ";
   }
   str+="  ";
   for (int i = 0; i <source; i++) {
    str+=available[i]+"   ";
   }
   str+="/n";
   for (int i = 1; i < process; i++) {
    str+="P"+i+"  ";
    for (int j = 0; j < source; j++) {
     str+=max[i][j]+"   ";
    }
    str+="  ";
    for (int j = 0; j < source; j++) {
     str+=allocation[i][j]+"   ";
    }
    str+="  ";
    for (int j = 0; j < source; j++) {
     str+=need[i][j]+"   ";
    }
    str+="/n";
   }
  }
  
  //检测安全序列是否安全
  public void isSafe() {
  
   int[] work = new int[source];
   for (int i = 0; i < work.length; i++) {
    work[i] = available[i];
   }
   finish = new boolean[process];
   for (int i = 0; i < process; i++) {//开始把进程全部置未分配状态  都为false;
    finish[i] = false;
   }
   p = new int[process];
   
   int num = 0;//对每个进程都要把所有资源都进行比较
   int count = 0;//记录可以分配的序列
   int count1 = 0;//记录所有序列是否分配
   
    for(int i=0;i<process-1;i++){
    for (int j = 0; j < process; j++) {
     if (finish[j] == false) {
      for (int k = 0; k < source; k++) {
       if (need[j][k] <= work[k]) {//比较一个进程的各种资源是否满足条件
        num++;
       }
      }
      if (num == source) {//如果一个进程所有资源都满足条件need<work,则找到了一个进程满足
       for (int m = 0; m< source; m++) {
        work[m] = work[m] + allocation[j][m];
       }
       finish[j] = true;//找到一个进程满足
       p[count++] = j;//记录找到的是第几个进程
      }
     }
     num = 0;//必须把它清零,重新来找下个资源种类的每种是否都满足条件
    }
   }
   
   //记录有多少个序列;
   for (int i = 0; i < p.length; i++) {
    if (finish[i] == true) {
     count1++;
    }
   }
   if (count1 == process) {//如果序列里面总数等于总共有多少程序,就找到了安全的序列。并且输出。反之没有找到
    
    str+="/n/n";
     str+="存在一个安全序列,安全序列为:";
    for (int i = 0; i < p.length; i++) {
     str+="P" + p[i] + " ";
    }
    str+="/n/n";
   } else {
    str+="系统处于不安全状态!";
   }
   
   JOptionPane.showMessageDialog(null, str);
  }
  
  //判断是否请求资源还是直接退出
  public void identify(){
   
   boolean flag=true;
   while(flag){
   String sle=JOptionPane.showInputDialog("------------请求操作--------------/n"+
     "是否还要继续,yes:继续做请求资源情况   No:退出");
   
   switch(sle.toLowerCase().charAt(0)){
   case 'y':
    request();
    break;
   case 'n':
    JOptionPane.showMessageDialog(null,"谢谢使用!");
    flag=false;
    break;
    default:
     JOptionPane.showMessageDialog(null,"输入错误,请重新输入");
    }
   }
   
  }
  
  public void request(){
   int count2=0;
   String sle=JOptionPane.showInputDialog("请输入要申请的第几个进程,进程是从0开始的");
   int process1=Integer.parseInt(sle);
   
   
   JOptionPane.showMessageDialog(null,"输入要请求的资源的");
   int[] request=new int[source];
   for(int i=0;i<source;i++){
    String sle1=JOptionPane.showInputDialog("请输入第"+process1+"个进程第"+i+"种请求资源");
    request[i]=Integer.parseInt(sle1);
    str+="第"+i+"个请求资源为:";
    str+=Integer.parseInt(sle1)+","+"/n";
   }
   
   
   //判断是否可以分配
   for(int i=0;i<source;i++){
    if(request[i]<=need[process1][i]&&request[i]<=available[i]){
     count2++;
    }
   }
   
   if(count2==source){
    for(int j=0;j<source;j++){
     allocation[process1][j]+=request[j];
     need[process1][j]-=request[j];
     available[j]-=request[j];
    }
    
    str+="~~~~~~~~~~~试分配如下~~~~~~~~~~~~~~/n";
    print();
    isSafe();
   }else{
    JOptionPane.showMessageDialog(null,"不能进行试分配,也就找不到安全序列");
   }
  }
  
  
  public static void main(String[] args) {
   boolean flag=true;
   while(flag){
   String sle=JOptionPane.showInputDialog("~~~~~~~~~~银行家算法~~~~~~~~~~~"+"/n"+
        "1-进入程序      2-退出");
   int data=Integer.parseInt(sle);
   if(data==1){
    Bank bank=new Bank();
    bank.isSafe();
    bank.identify();
   }else if(data==2){
    flag=false;
   }else{
    JOptionPane.showMessageDialog(null, "输入有误,请重新输入");
   }
   }
  }
 }