1.创建二维数组等数据结构用来表示进程对资源的使用情况，相关数据包括进程名称、进程数目、资源数目、最大需求数目、已分配数目、仍需数目及当前状态下可利用数目等。 2.在用户输入所有初始化信息后，首先对信息以矩阵形式输出，再输入一组可用资源数目，此时系统判断是否存在安全序列，若有则输出一个安全序列；若无，则表示初始化不正确，请重新输入。 3.在已经处于安全状态的前提下，某进程提出新的资源申情，包括进程名称、申请资源数目等，先对用户提出的请求进行合法性检查，若请求合法，则进行试分配。最后对试分配后的状态，调用安全性检查算法进行是否存在安全序列的判断。若安全，给出分配后资源使用情况，并输出一个安全序列。否则，拒绝申请并打印出相应的拒绝原因。用Java实现

好的，这是一个比较复杂的问题，需要用到多个类和方法来实现。我会尽力为您解答。以下是一个简单的 Java 实现，您可以参考一下：

首先，我们需要创建一个用来表示进程对资源的使用情况的类，命名为 Process：

class Process {
    String name;            // 进程名称
    int processNum;         // 进程数目
    int resourceNum;        // 资源数目
    int[][] max;            // 最大需求数目
    int[][] allocated;      // 已分配数目
    int[][] need;           // 仍需数目
    boolean finished;       // 是否已完成

    public Process(String name, int processNum, int resourceNum, int[][] max, int[][] allocated) {
        this.name = name;
        this.processNum = processNum;
        this.resourceNum = resourceNum;
        this.max = max;
        this.allocated = allocated;
        this.finished = false;

        // 初始化仍需数目
        need = new int[processNum][resourceNum];
        for (int i = 0; i < processNum; i++) {
            for (int j = 0; j < resourceNum; j++) {
                need[i][j] = max[i][j] - allocated[i][j];
            }
        }
    }
}

接下来，我们需要创建一个用来进行资源分配和安全性检查的类，命名为 Banker：

import java.util.*;

class Banker {
    int resourceNum;            // 资源数目
    int[] available;            // 当前可用资源数目
    List<Process> processes;    // 进程列表

    public Banker(int resourceNum) {
        this.resourceNum = resourceNum;
        available = new int[resourceNum];
        processes = new ArrayList<>();
    }

    // 添加进程
    public void addProcess(Process process) {
        processes.add(process);
    }

    // 设置当前可用资源数目
    public void setAvailable(int[] available) {
        this.available = available;
    }

    // 显示当前进程和资源的分配情况
    public void display() {
        System.out.println("进程\t最大需求数目\t已分配数目\t仍需数目");
        for (Process process : processes) {
            System.out.print(process.name + "\t");
            for (int i = 0; i < resourceNum; i++) {
                System.out.print(process.max[process.processNum - 1][i] + "\t");
            }
            for (int i = 0; i < resourceNum; i++) {
                System.out.print(process.allocated[process.processNum - 1][i] + "\t");
            }
            for (int i = 0; i < resourceNum; i++) {
                System.out.print(process.need[process.processNum - 1][i] + "\t");
            }
            System.out.println();
        }
        System.out.println("当前可用资源数目：" + Arrays.toString(available));
    }

    // 判断是否存在安全序列
    public boolean isSafeSequence() {
        int[] work = Arrays.copyOf(available, available.length);    // 可用资源数目的副本
        boolean[] finish = new boolean[processes.size()];           // 进程是否已完成的标记数组
        int count = 0;                                              // 已完成进程数目的计数器
        List<Integer> sequence = new ArrayList<>();                 // 安全序列

        // 初始化所有进程未完成
        for (int i = 0; i < processes.size(); i++) {
            finish[i] = false;
        }

        // 查找满足条件的进程
        while (count < processes.size()) {
            boolean found = false;  // 是否找到满足条件的进程的标记
            for (int i = 0; i < processes.size(); i++) {
                if (!finish[i]) {
                    boolean enough = true;  // 是否有足够的资源分配给进程的标记
                    for (int j = 0; j < resourceNum; j++) {
                        if (processes.get(i).need[processes.get(i).processNum - 1][j] > work[j]) {
                            enough = false;
                            break;
                        }
                    }
                    if (enough) {
                        for (int j = 0; j < resourceNum; j++) {
                            work[j] += processes.get(i).allocated[processes.get(i).processNum - 1][j];
                        }
                        finish[i] = true;
                        count++;
                        sequence.add(i);
                        found = true;
                    }
                }
            }
            if (!found) {
                break;
            }
        }

        // 判断是否存在安全序列
        if (count < processes.size()) {
            return false;
        } else {
            System.out.print("安全序列：");
            for (int i : sequence) {
                System.out.print(processes.get(i).name + " ");
            }
            System.out.println();
            return true;
        }
    }

    // 分配资源
    public boolean allocate(String processName, int[] request) {
        // 查找进程
        Process process = null;
        for (Process p : processes) {
            if (p.name.equals(processName)) {
                process = p;
                break;
            }
        }
        if (process == null) {
            System.out.println("进程不存在");
            return false;
        }

        // 检查请求是否合法
        for (int i = 0; i < resourceNum; i++) {
            if (request[i] > process.need[process.processNum - 1][i]) {
                System.out.println("请求资源数目超过进程的最大需求数目");
                return false;
            }
            if (request[i] > available[i]) {
                System.out.println("没有足够的资源可分配");
                return false;
            }
        }

        // 试分配资源
        for (int i = 0; i < resourceNum; i++) {
            available[i] -= request[i];
            process.allocated[process.processNum - 1][i] += request[i];
            process.need[process.processNum - 1][i] -= request[i];
        }

        // 检查是否存在安全序列
        if (isSafeSequence()) {
            System.out.println("分配资源成功");
            display();
            return true;
        } else {
            // 回滚分配
            for (int i = 0; i < resourceNum; i++) {
                available[i] += request[i];
                process.allocated[process.processNum - 1][i] -= request[i];
                process.need[process.processNum - 1][i] += request[i];
            }
            System.out.println("分配资源失败");
            return false;
        }
    }
}

最后，我们需要创建一个用来测试的类，命名为 Test：

import java.util.*;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入进程和资源的数目
        System.out.print("请输入进程数目：");
        int processNum = scanner.nextInt();
        System.out.print("请输入资源数目：");
        int resourceNum = scanner.nextInt();

        // 输入进程的最大需求数目和已分配数目
        int[][] max = new int[processNum][resourceNum];
        int[][] allocated = new int[processNum][resourceNum];
        for (int i = 0; i < processNum; i++) {
            System.out.print("请输入进程" + (i + 1) + "的最大需求数目：");
            for (int j = 0; j < resourceNum; j++) {
                max[i][j] = scanner.nextInt();
            }
            System.out.print("请输入进程" + (i + 1) + "的已分配数目：");
            for (int j = 0; j < resourceNum; j++) {
                allocated[i][j] = scanner.nextInt();
            }
        }

        // 创建进程
        Banker banker = new Banker(resourceNum);
        for (int i = 0; i < processNum; i++) {
            banker.addProcess(new Process("P" + (i + 1), processNum, resourceNum, max, allocated));
        }

        // 显示当前进程和资源的分配情况
        banker.display();

        // 输入当前可用资源数目
        System.out.print("请输入当前可用资源数目：");
        int[] available = new int[resourceNum];
        for (int i = 0; i < resourceNum; i++) {
            available[i] = scanner.nextInt();
        }
        banker.setAvailable(available);

        // 判断是否存在安全序列
        if (!banker.isSafeSequence()) {
            System.out.println("初始化不正确，请重新输入");
            return;
        }

        // 分配资源
        while (true) {
            System.out.print("请输入要申请资源的进程名称（输入exit退出）：");
            String processName = scanner.next();
            if (processName.equals("exit")) {
                break;
            }
            System.out.print("请输入要申请的资源数目：");
            int[] request = new int[resourceNum];
            for (int i = 0; i < resourceNum; i++) {
                request[i] = scanner.nextInt();
            }
            banker.allocate(processName, request);
        }
    }
}

以上就是一个简单的 Java 实现，可以通过输入进程和资源的数目、每个进程的最大需求数目和已分配数目、当前可用资源数目以及每个进程申请的资源数目来进行测试。