使用Java语言编写和调试一个进程调度程序，实现基于优先权的进程调度算法和基于时间片轮转调度算法。

以下是一个基于优先权的进程调度程序的Java代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

class Process {
    private int pid;
    private int priority;
    private int burstTime;
    private int arrivalTime;
    private int waitingTime;
    private int turnaroundTime;

    public Process(int pid, int priority, int burstTime, int arrivalTime) {
        this.pid = pid;
        this.priority = priority;
        this.burstTime = burstTime;
        this.arrivalTime = arrivalTime;
        waitingTime = 0;
        turnaroundTime = 0;
    }

    public int getPid() {
        return pid;
    }

    public int getPriority() {
        return priority;
    }

    public int getBurstTime() {
        return burstTime;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public int getWaitingTime() {
        return waitingTime;
    }

    public void setWaitingTime(int waitingTime) {
        this.waitingTime = waitingTime;
    }

    public int getTurnaroundTime() {
        return turnaroundTime;
    }

    public void setTurnaroundTime(int turnaroundTime) {
        this.turnaroundTime = turnaroundTime;
    }
}

class ProcessComparator implements Comparator<Process> {
    @Override
    public int compare(Process p1, Process p2) {
        return p2.getPriority() - p1.getPriority();
    }
}

public class PriorityScheduling {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter the number of processes: ");
        int n = sc.nextInt();
        ArrayList<Process> processes = new ArrayList<>();

        for (int i = 1; i <= n; i++) {
            System.out.print("Enter the priority, burst time and arrival time of process " + i + ": ");
            int priority = sc.nextInt();
            int burstTime = sc.nextInt();
            int arrivalTime = sc.nextInt();
            processes.add(new Process(i, priority, burstTime, arrivalTime));
        }

        Collections.sort(processes, new ProcessComparator());

        int currentTime = 0;
        int totalWaitingTime = 0;
        int totalTurnaroundTime = 0;

        System.out.println("Gantt Chart:");
        System.out.print("|");

        while (!processes.isEmpty()) {
            Process p = processes.get(0);

            if (p.getArrivalTime() > currentTime) {
                currentTime++;
                System.out.print("-");
                continue;
            }

            processes.remove(0);
            p.setWaitingTime(currentTime - p.getArrivalTime());
            totalWaitingTime += p.getWaitingTime();
            p.setTurnaroundTime(p.getWaitingTime() + p.getBurstTime());
            totalTurnaroundTime += p.getTurnaroundTime();
            currentTime += p.getBurstTime();

            System.out.print(" P" + p.getPid() + " |");
        }

        System.out.println("\n\nProcess\tPriority\tBurst Time\tArrival Time\tWaiting Time\tTurnaround Time");

        for (Process p : processes) {
            System.out.printf("P%d\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", p.getPid(), p.getPriority(),
                    p.getBurstTime(), p.getArrivalTime(), p.getWaitingTime(), p.getTurnaroundTime());
        }

        System.out.println("\nAverage waiting time: " + (double) totalWaitingTime / n);
        System.out.println("Average turnaround time: " + (double) totalTurnaroundTime / n);
    }
}

以下是一个基于时间片轮转调度算法的Java代码：

import java.util.ArrayList;
import java.util.Scanner;

class Process {
    private int pid;
    private int burstTime;
    private int arrivalTime;
    private int remainingTime;

    public Process(int pid, int burstTime, int arrivalTime) {
        this.pid = pid;
        this.burstTime = burstTime;
        this.arrivalTime = arrivalTime;
        remainingTime = burstTime;
    }

    public int getPid() {
        return pid;
    }

    public int getBurstTime() {
        return burstTime;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public int getRemainingTime() {
        return remainingTime;
    }

    public void setRemainingTime(int remainingTime) {
        this.remainingTime = remainingTime;
    }
}

public class RoundRobinScheduling {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter the time quantum: ");
        int quantum = sc.nextInt();
        System.out.print("Enter the number of processes: ");
        int n = sc.nextInt();
        ArrayList<Process> processes = new ArrayList<>();

        for (int i = 1; i <= n; i++) {
            System.out.print("Enter the burst time and arrival time of process " + i + ": ");
            int burstTime = sc.nextInt();
            int arrivalTime = sc.nextInt();
            processes.add(new Process(i, burstTime, arrivalTime));
        }

        int currentTime = 0;
        int totalWaitingTime = 0;
        int totalTurnaroundTime = 0;

        System.out.println("Gantt Chart:");
        System.out.print("|");

        while (!processes.isEmpty()) {
            Process p = processes.get(0);

            if (p.getArrivalTime() > currentTime) {
                currentTime++;
                System.out.print("-");
                continue;
            }

            processes.remove(0);

            if (p.getRemainingTime() <= quantum) {
                currentTime += p.getRemainingTime();
                System.out.print(" P" + p.getPid() + " |");
                p.setRemainingTime(0);
                totalWaitingTime += currentTime - p.getBurstTime() - p.getArrivalTime();
                totalTurnaroundTime += currentTime - p.getArrivalTime();
            } else {
                currentTime += quantum;
                System.out.print(" P" + p.getPid() + " |");
                p.setRemainingTime(p.getRemainingTime() - quantum);
                processes.add(p);
            }
        }

        System.out.println("\n\nProcess\tBurst Time\tArrival Time\tWaiting Time\tTurnaround Time");

        for (Process p : processes) {
            System.out.printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", p.getPid(), p.getBurstTime(),
                    p.getArrivalTime(), currentTime - p.getBurstTime() - p.getArrivalTime(),
                    currentTime - p.getArrivalTime());
        }

        System.out.println("\nAverage waiting time: " + (double) totalWaitingTime / n);
        System.out.println("Average turnaround time: " + (double) totalTurnaroundTime / n);
    }
}