输入各进程的进程名、最大需求数目、已分配数目、仍需数目，如何通过银行家算法计算出安全序列，并输出安全序列，用java实现

银行家算法是一种避免死锁的算法，它可以判断系统是否处于安全状态，如果是，就可以分配资源，否则应该等待。下面是Java实现银行家算法的代码：

import java.util.Scanner;

public class BankerAlgorithm {
    private int processNum; // 进程数
    private int resourceNum; // 资源数
    private int[] available; // 各类资源可用数
    private int[][] max; // 各进程最大需求量
    private int[][] allocation; // 各进程已分配量
    private int[][] need; // 各进程还需量

    public BankerAlgorithm() {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入进程数：");
        processNum = sc.nextInt();
        System.out.print("请输入资源数：");
        resourceNum = sc.nextInt();

        available = new int[resourceNum];
        max = new int[processNum][resourceNum];
        allocation = new int[processNum][resourceNum];
        need = new int[processNum][resourceNum];

        System.out.println("请依次输入各类资源可用数：");
        for (int i = 0; i < resourceNum; i++) {
            available[i] = sc.nextInt();
        }

        System.out.println("请依次输入各进程的最大需求数目：");
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < resourceNum; j++) {
                max[i][j] = sc.nextInt();
            }
        }

        System.out.println("请依次输入各进程的已分配数目：");
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < resourceNum; j++) {
                allocation[i][j] = sc.nextInt();
                need[i][j] = max[i][j] - allocation[i][j];
            }
        }
    }

    public boolean isSafe() {
        int[] work = new int[resourceNum];
        boolean[] finish = new boolean[processNum];
        int count = 0;

        for (int i = 0; i < resourceNum; i++) {
            work[i] = available[i];
        }

        while (count < processNum) {
            boolean flag = false;

            for (int i = 0; i < processNum; i++) {
                if (!finish[i] && check(need[i], work)) {
                    for (int j = 0; j < resourceNum; j++) {
                        work[j] += allocation[i][j];
                    }
                    finish[i] = true;
                    count++;
                    flag = true;
                }
            }

            if (!flag) {
                return false;
            }
        }

        return true;
    }

    public boolean check(int[] need, int[] work) {
        for (int i = 0; i < resourceNum; i++) {
            if (need[i] > work[i]) {
                return false;
            }
        }
        return true;
    }

    public void run() {
        if (isSafe()) {
            System.out.println("系统安全，存在安全序列");
        } else {
            System.out.println("系统不安全，不存在安全序列");
        }
    }

    public static void main(String[] args) {
        BankerAlgorithm banker = new BankerAlgorithm();
        banker.run();
    }
}

在上述代码中，我们首先定义了一个BankerAlgorithm类，并在构造方法中读入各进程的进程名、最大需求数目、已分配数目、仍需数目。然后，我们定义了isSafe()方法来判断系统是否处于安全状态，如果是，就可以分配资源，否则应该等待。在isSafe()方法中，我们定义了work数组来保存各类资源可用数，finish数组来保存各进程的状态，count变量来保存已经完成的进程数。接下来，我们使用while循环来检查每个进程的状态，如果它的状态是未完成并且它的需求量小于等于可用资源量，那么就可以分配资源。如果所有进程都已完成，那么就认为系统处于安全状态。最后，在main()方法中，我们创建了一个BankerAlgorithm对象并运行它的run()方法。

当你运行上述代码时，它会要求你输入进程数、资源数、各类资源可用数、各进程的最大需求数目和已分配数目。然后，它会输出系统是否处于安全状态。如果是，就可以分配资源，否则应该等待。