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

以下是用Java语言实现时间片轮转调度算法的示例代码：

import java.util.*;

public class RoundRobinScheduling {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入进程数：");
        int n = sc.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]; // 等待时间

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

        System.out.print("请输入时间片大小：");
        int timeSlice = sc.nextInt();

        int[] remainingTime = new int[n]; // 剩余服务时间
        int currentTime = 0; // 当前时间
        Queue<Integer> queue = new LinkedList<>(); // 存放就绪队列

        for (int i = 0; i < n; i++) {
            remainingTime[i] = serviceTime[i];
        }

        while (true) {
            boolean done = true;
            for (int i = 0; i < n; i++) {
                if (remainingTime[i] > 0 && arrivalTime[i] <= currentTime) {
                    queue.add(i);
                }
                if (remainingTime[i] > 0) {
                    done = false;
                }
            }
            if (done) {
                break;
            }
            int process = queue.poll();
            if (remainingTime[process] == serviceTime[process]) {
                startTime[process] = Math.max(currentTime, arrivalTime[process]);
            }
            if (remainingTime[process] <= timeSlice) {
                currentTime += remainingTime[process];
                finishTime[process] = currentTime;
                turnAroundTime[process] = finishTime[process] - arrivalTime[process];
                waitingTime[process] = turnAroundTime[process] - serviceTime[process];
                remainingTime[process] = 0;
            } else {
                currentTime += timeSlice;
                remainingTime[process] -= timeSlice;
                queue.add(process);
            }
        }

        double totalTurnAroundTime = 0.0;
        double totalWaitingTime = 0.0;
        double totalResponseTime = 0.0;
        System.out.println("进程\t到达时间\t服务时间\t开始时间\t完成时间\t周转时间\t等待时间\t响应时间");
        for (int i = 0; i < n; i++) {
            totalTurnAroundTime += turnAroundTime[i];
            totalWaitingTime += waitingTime[i];
            totalResponseTime += startTime[i] - arrivalTime[i];
            System.out.println((i + 1) + "\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"
                    + (startTime[i] - arrivalTime[i]));
        }
        double avgTurnAroundTime = totalTurnAroundTime / n;
        double avgWaitingTime = totalWaitingTime / n;
        double avgResponseTime = totalResponseTime / n;
        System.out.println("平均周转时间：" + avgTurnAroundTime);
        System.out.println("平均等待时间：" + avgWaitingTime);
        System.out.println("平均响应时间：" + avgResponseTime);
    }
}

该代码实现了时间片轮转调度算法，通过输入进程数、每个进程的到达时间和服务时间，以及时间片大小，计算出每个进程的开始时间、结束时间、周转时间、等待时间和响应时间，以及整体的平均周转时间、平均等待时间和平均响应时间。