用Java语言写一个完整可运行的程序，短进程优先算法 程序要求： 能正常运行，输入进程名称，到达时间，和运行时间，输出平均周转时间，输出调度顺序

短进程优先 (Shortest Job First, SJF) 算法是一种基于就绪队列中进程剩余运行时间的调度策略。下面是一个简单的 Java 程序示例，它实现了这个算法：

import java.util.*;

class Process {
    String name;
    int arrivalTime;
    int burstTime;

    public Process(String name, int arrivalTime, int burstTime) {
        this.name = name;
        this.arrivalTime = arrivalTime;
        this.burstTime = burstTime;
    }

    @Override
    public String toString() {
        return "Process{" +
                "name='" + name + '\'' +
                ", arrivalTime=" + arrivalTime +
                ", burstTime=" + burstTime +
                '}';
    }
}

public class SJFScheduler {

    private PriorityQueue<Process> queue = new PriorityQueue<>((p1, p2) -> p2.burstTime - p1.burstTime);

    public void scheduleProcesses(List<Process> processes) {
        for (Process process : processes) {
            queue.offer(process);
        }

        while (!queue.isEmpty()) {
            Process currentProcess = queue.poll();
            System.out.println("Processing: " + currentProcess + ", Turnaround Time: " + (System.currentTimeMillis() - currentProcess.arrivalTime));
            if (currentProcess.burstTime > 0) {
                // 更新剩余运行时间并重新插入队列
                queue.offer(new Process(currentProcess.name, currentProcess.arrivalTime + currentProcess.burstTime, currentProcess.burstTime - 1));
            }
        }

        double averageTurnaroundTime = calculateAverageTurnaroundTime(queue);
        System.out.println("Average Turnaround Time: " + averageTurnaroundTime);
    }

    private double calculateAverageTurnaroundTime(PriorityQueue<Process> queue) {
        double totalTurnaroundTime = 0;
        int count = 0;
        while (!queue.isEmpty()) {
            totalTurnaroundTime += queue.peek().arrivalTime + queue.peek().burstTime;
            queue.poll();
            count++;
        }
        return totalTurnaroundTime / count;
    }

    public static void main(String[] args) {
        List<Process> processes = Arrays.asList(
                new Process("P1", 1, 4),
                new Process("P2", 2, 6),
                new Process("P3", 3, 3)
        );

        SJFScheduler scheduler = new SJFScheduler();
        scheduler.scheduleProcesses(processes);
    }
}

在这个程序中，我们首先创建了一个 `Process` 类，包含了进程名、到达时间和运行时间信息。然后在 `SJFScheduler` 类中，我们维护了一个最小堆（PriorityQueue），其中元素按照剩余运行时间排序。我们遍历所有进程，将它们添加到队列中，然后按顺序处理每个进程，直到队列为空。

在 `scheduleProcesses` 方法中，我们计算了平均周转时间，并在 `main` 函数中提供了一个例子来展示如何使用这个调度器。

运行此程序，你会看到调度顺序以及对应的平均周转时间。