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

好的，这是一个关于进程和资源管理的问题，需要用到Java进行实现。我可以帮你解答这个问题，并提供一些实现的思路。

首先，我们需要创建一个二维数组来表示进程对资源的使用情况。数组的行数为进程数目，列数为资源数目。具体来说，可以定义一个名为allocation的二维数组，它的元素allocation[i][j]表示第i个进程已分配第j个资源的数量。

同时，我们还需要定义一个二维数组max，它的元素max[i][j]表示第i个进程最大需要第j个资源的数量。再定义一个一维数组available，它的元素available[j]表示当前系统中第j个资源的可用数量。

接下来，我们需要实现一个安全性检查算法来判断是否存在安全序列。安全性算法的实现可以参考银行家算法。其基本思路是：从当前状态出发，尝试分配资源，直到找到一个安全序列或者无法继续分配。在实现过程中，可以使用一个work数组来保存当前可用的资源数目，以及一个finish数组来保存每个进程是否已经完成。具体实现细节可以参考下面的代码：

public boolean isSafe(int[] available, int[][] max, int[][] allocation) {
    int n = available.length; // 资源数目
    int m = allocation.length; // 进程数目
    int[] work = Arrays.copyOf(available, n);
    boolean[] finish = new boolean[m];
    Arrays.fill(finish, false);

    // 尝试分配资源，直到找到一个安全序列或者无法继续分配
    int count = 0;
    while (count < m) {
        boolean found = false;
        for (int i = 0; i < m; i++) {
            if (!finish[i]) {
                boolean canAllocate = true;
                for (int j = 0; j < n; j++) {
                    if (max[i][j] - allocation[i][j] > work[j]) {
                        canAllocate = false;
                        break;
                    }
                }
                if (canAllocate) {
                    for (int j = 0; j < n; j++) {
                        work[j] += allocation[i][j];
                    }
                    finish[i] = true;
                    found = true;
                    count++;
                }
            }
        }
        if (!found) {
            break;
        }
    }

    return count == m; // 如果所有进程都已经完成，则存在安全序列
}

有了安全性检查算法，我们就可以实现进程申请资源的功能了。具体实现思路是：首先对用户提出的请求进行合法性检查，判断请求资源数目是否超过了进程最大需求数目和系统中的可用资源数目。如果请求合法，则进行试分配，即尝试将资源分配给进程，并更新allocation和available数组。最后，再调用安全性检查算法，判断是否存在安全序列即可。具体实现细节可以参考下面的代码：

public boolean requestResources(int processId, int[] request, int[][] max, int[][] allocation, int[] available) {
    int n = request.length; // 资源数目
    int m = allocation.length; // 进程数目

    // 检查请求是否合法
    for (int i = 0; i < n; i++) {
        if (request[i] > max[processId][i] - allocation[processId][i]) {
            return false; // 请求资源数目超过了进程最大需求数目
        }
        if (request[i] > available[i]) {
            return false; // 请求资源数目超过了系统中的可用资源数目
        }
    }

    // 尝试分配资源
    int[] newAllocation = Arrays.copyOf(allocation[processId], n);
    int[] newAvailable = Arrays.copyOf(available, n);
    for (int i = 0; i < n; i++) {
        newAllocation[i] += request[i];
        newAvailable[i] -= request[i];
    }

    // 判断是否存在安全序列
    if (isSafe(newAvailable, max, newAllocation)) {
        // 分配资源
        for (int i = 0; i < n; i++) {
            allocation[processId][i] += request[i];
            available[i] -= request[i];
        }
        return true;
    } else {
        return false; // 不存在安全序列，拒绝申请
    }
}

最后，我们需要实现一个方法来输出进程和资源的使用情况。具体实现思路是：遍历allocation和max数组，以矩阵的形式输出每个进程已分配和最大需求的资源数量。同时，还需要输出当前系统中可用的资源数量。具体实现细节可以参考下面的代码：

public void printStatus(int[][] max, int[][] allocation, int[] available) {
    int n = available.length; // 资源数目
    int m = allocation.length; // 进程数目

    // 输出每个进程已分配和最大需求的资源数量
    System.out.println("Max Allocation");
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            System.out.print(max[i][j] + " ");
        }
        System.out.print("\t");
        for (int j = 0; j < n; j++) {
            System.out.print(allocation[i][j] + " ");
        }
        System.out.println();
    }

    // 输出当前系统中可用的资源数量
    System.out.println("Available");
    for (int i = 0; i < n; i++) {
        System.out.print(available[i] + " ");
    }
    System.out.println();
}

综上，我们可以将上述代码组合起来，形成一个完整的程序，用来模拟进程和资源的管理。当用户输入所有初始化信息后，程序会首先输出进程和资源的使用情况。然后，用户需要输入一组可用资源数目，程序会判断是否存在安全序列，如果有则输出一个安全序列；如果无，则表示初始化不正确，请重新输入。在已经处于安全状态的前提下，用户可以提出新的资源申请，程序会判断请求是否合法，如果合法则进行试分配，并输出分配后的资源使用情况。否则，程序会拒绝申请并打印出相应的拒绝原因。