请用JAVA语言编写和调试一个时间片轮转的进程调度算法进程调度程序,假设时间片大小为1分钟, 输入n个进程, 每个进程的到达时间和服务时间（运行时间），输出每个进程的开始时间，结束时间，周转时间等，统计系统整体的平均周转时间，平均等待时间，平均响应时间。

以下是用JAVA语言编写的时间片轮转的进程调度算法进程调度程序，假设时间片大小为1分钟，输入n个进程，每个进程的到达时间和服务时间（运行时间），输出每个进程的开始时间，结束时间，周转时间等，统计系统整体的平均周转时间，平均等待时间，平均响应时间。

import java.util.Scanner;

public class RoundRobin {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入进程数：");
        int n = scanner.nextInt();
        int[] arrivalTime = new int[n]; // 到达时间
        int[] serviceTime = new int[n]; // 服务时间
        int[] startTime = new int[n]; // 开始时间
        int[] finishTime = new int[n]; // 结束时间
        int[] turnaroundTime = new int[n]; // 周转时间
        int[] waitingTime = new int[n]; // 等待时间
        int[] responseTime = new int[n]; // 响应时间
        int[] remainTime = new int[n]; // 剩余服务时间
        int[] queue = new int[n]; // 进程队列
        int head = 0, tail = 0, currentTime = 0; // 头指针，尾指针，当前时间
        double avgTurnaroundTime, avgWaitingTime, avgResponseTime; // 平均周转时间，平均等待时间，平均响应时间
        System.out.println("请输入每个进程的到达时间和服务时间：");
        for (int i = 0; i < n; i++) {
            arrivalTime[i] = scanner.nextInt();
            serviceTime[i] = scanner.nextInt();
            remainTime[i] = serviceTime[i];
        }
        while (true) {
            boolean flag = true;
            for (int i = 0; i < n; i++) {
                if (remainTime[i] > 0 && arrivalTime[i] <= currentTime) {
                    flag = false;
                    queue[tail++] = i; // 加入进程队列
                }
            }
            if (flag) {
                break;
            }
            int index = queue[head++];
            if (remainTime[index] == serviceTime[index]) { // 开始时间
                startTime[index] = currentTime;
            }
            remainTime[index]--;
            if (remainTime[index] == 0) { // 结束时间
                finishTime[index] = currentTime + 1;
                turnaroundTime[index] = finishTime[index] - arrivalTime[index];
                waitingTime[index] = turnaroundTime[index] - serviceTime[index];
                responseTime[index] = startTime[index] - arrivalTime[index];
            }
            currentTime++;
            if (tail == head) { // 队列为空
                currentTime = arrivalTime[queue[head]];
            }
            if (currentTime % 1 == 0 || remainTime[index] == 0) { // 时间片用完或进程结束
                queue[tail++] = index;
                head++;
            }
        }
        avgTurnaroundTime = avgWaitingTime = avgResponseTime = 0;
        System.out.println("进程\t到达时间\t服务时间\t开始时间\t结束时间\t周转时间\t等待时间\t响应时间");
        for (int i = 0; i < n; i++) {
            avgTurnaroundTime += turnaroundTime[i];
            avgWaitingTime += waitingTime[i];
            avgResponseTime += responseTime[i];
            System.out.println((i + 1) + "\t\t" + arrivalTime[i] + "\t\t" + serviceTime[i] + "\t\t" + startTime[i] + "\t\t" + finishTime[i] + "\t\t" + turnaroundTime[i] + "\t\t" + waitingTime[i] + "\t\t" + responseTime[i]);
        }
        avgTurnaroundTime /= n;
        avgWaitingTime /= n;
        avgResponseTime /= n;
        System.out.println("平均周转时间：" + avgTurnaroundTime);
        System.out.println("平均等待时间：" + avgWaitingTime);
        System.out.println("平均响应时间：" + avgResponseTime);
    }
}

该程序通过输入进程数、每个进程的到达时间和服务时间，计算出每个进程的开始时间、结束时间、周转时间、等待时间和响应时间，并统计系统整体的平均周转时间、平均等待时间和平均响应时间。其中，进程队列采用循环队列实现，时间片大小为1分钟，当时间片用完或进程结束时，将进程加入队列的尾部，将队列头指针指向下一个进程。