写一个Java程序实现RR算法

好的，以下是一个简单的Java程序实现Round Robin（RR）算法：

import java.util.*;

public class RoundRobin {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入进程数：");
        int n = scanner.nextInt();
        int[] arrivalTime = new int[n]; // 到达时间
        int[] serviceTime = new int[n]; // 服务时间
        int[] remainTime = new int[n]; // 剩余服务时间
        int[] responseTime = new int[n]; // 响应时间
        int[] turnaroundTime = new int[n]; // 周转时间
        int[] waitingTime = new int[n]; // 等待时间
        int[] queue = new int[n]; // 队列
        int front = 0, rear = -1; // 队列指针
        int timeQuantum; // 时间片
        int currentTime = 0; // 当前时间
        int completed = 0; // 完成的进程数
        float avgResponseTime, avgTurnaroundTime, avgWaitingTime; // 平均响应时间、平均周转时间、平均等待时间

        // 输入进程信息
        for (int i = 0; i < n; i++) {
            System.out.print("请输入第" + (i + 1) + "个进程的到达时间和服务时间：");
            arrivalTime[i] = scanner.nextInt();
            serviceTime[i] = scanner.nextInt();
            remainTime[i] = serviceTime[i];
        }

        // 输入时间片
        System.out.print("请输入时间片：");
        timeQuantum = scanner.nextInt();

        // 执行RR算法
        while (completed < n) {
            // 将到达时间小于等于当前时间的进程加入队列
            for (int i = 0; i < n; i++) {
                if (arrivalTime[i] <= currentTime && remainTime[i] > 0) {
                    queue[++rear] = i;
                }
            }
            if (rear < front) { // 队列为空
                currentTime++;
                continue;
            }
            int currentProcess = queue[front++]; // 取出队首进程
            if (responseTime[currentProcess] == 0) {
                responseTime[currentProcess] = currentTime - arrivalTime[currentProcess]; // 计算响应时间
            }
            if (remainTime[currentProcess] <= timeQuantum) { // 进程执行完毕
                currentTime += remainTime[currentProcess];
                remainTime[currentProcess] = 0;
                completed++;
                turnaroundTime[currentProcess] = currentTime - arrivalTime[currentProcess]; // 计算周转时间
                waitingTime[currentProcess] = turnaroundTime[currentProcess] - serviceTime[currentProcess]; // 计算等待时间
            } else { // 进程未执行完毕
                currentTime += timeQuantum;
                remainTime[currentProcess] -= timeQuantum;
                // 将未执行完毕的进程加入队列
                for (int i = 0; i < n; i++) {
                    if (arrivalTime[i] <= currentTime && remainTime[i] > 0 && i != currentProcess) {
                        queue[++rear] = i;
                    }
                }
                queue[++rear] = currentProcess;
            }
        }

        // 输出结果
        System.out.println("进程\t到达时间\t服务时间\t响应时间\t周转时间\t等待时间");
        for (int i = 0; i < n; i++) {
            System.out.println((i + 1) + "\t" + arrivalTime[i] + "\t\t" + serviceTime[i] + "\t\t" + responseTime[i] + "\t\t" + turnaroundTime[i] + "\t\t" + waitingTime[i]);
        }
        avgResponseTime = (float) Arrays.stream(responseTime).average().orElse(Double.NaN);
        avgTurnaroundTime = (float) Arrays.stream(turnaroundTime).average().orElse(Double.NaN);
        avgWaitingTime = (float) Arrays.stream(waitingTime).average().orElse(Double.NaN);
        System.out.println("平均响应时间：" + avgResponseTime);
        System.out.println("平均周转时间：" + avgTurnaroundTime);
        System.out.println("平均等待时间：" + avgWaitingTime);
    }
}

注意：上述代码中使用了数组来存储进程信息，输入时需要按照进程的到达时间和服务时间的顺序依次输入。另外，为了方便起见，上述代码中没有进行输入检查，请确保输入的数据合法。