用java实现先来先服务算法、短作业优先算法、时间片轮转算法、优先级算法，将他们整合到一起，并可以在键盘上输入1、2、3等控制选择这些算法。

好的，这是一个比较复杂的问题，需要详细讲解。首先，先来先服务算法（FCFS）、短作业优先算法（SJF）、时间片轮转算法（RR）和优先级算法（Priority）是常见的 CPU 调度算法，用于决定操作系统中多个进程的执行顺序。这些算法各有特点，可以根据具体情况选择使用。

下面，我来简单介绍一下这几种算法的原理：

1. 先来先服务算法（FCFS）：按照进程到达的先后顺序进行调度，即先到先服务。当一个进程进入就绪队列后，它将按照到达的顺序排在队列的末尾，等待 CPU 的分配。

2. 短作业优先算法（SJF）：按照进程的执行时间长短进行调度，即短作业优先。当一个进程进入就绪队列后，它将按照需要的 CPU 时间的大小排序，需要时间短的进程先执行。

3. 时间片轮转算法（RR）：按照时间片轮流分配 CPU 时间进行调度。当一个进程进入就绪队列后，它将获得一个时间片，如果在这个时间片内没有完成，就会被放回队列末尾等待下一次调度。

4. 优先级算法（Priority）：按照进程的优先级进行调度。每个进程都有一个优先级，优先级高的进程先执行。如果有多个进程优先级相同，则按照 FCFS 原则进行调度。

Java 语言可以实现这几种算法，我们可以通过编写一个调度器类来实现这些算法的功能，并在主程序中调用。下面是一个简单的示例代码：

// 定义进程类
class Process {
    private String name;  // 进程名称
    private int arriveTime;  // 到达时间
    private int executeTime;  // 执行时间
    private int priority;  // 优先级

    public Process(String name, int arriveTime, int executeTime, int priority) {
        this.name = name;
        this.arriveTime = arriveTime;
        this.executeTime = executeTime;
        this.priority = priority;
    }

    // 省略 getter 和 setter 方法
}

// 定义调度器类
class Scheduler {
    private List<Process> processes;  // 进程列表

    public Scheduler(List<Process> processes) {
        this.processes = processes;
    }

    // 先来先服务算法
    public void fcfs() {
        // 按照到达时间排序
        processes.sort(Comparator.comparing(Process::getArriveTime));
        // 按照顺序执行进程
        for (Process process : processes) {
            execute(process);
        }
    }

    // 短作业优先算法
    public void sjf() {
        // 按照执行时间排序
        processes.sort(Comparator.comparing(Process::getExecuteTime));
        // 按照顺序执行进程
        for (Process process : processes) {
            execute(process);
        }
    }

    // 时间片轮转算法
    public void rr(int timeSlice) {
        List<Process> queue = new ArrayList<>(processes);  // 就绪队列
        int index = 0;  // 当前执行的进程下标
        int currentTime = 0;  // 当前时间
        while (!queue.isEmpty()) {
            // 获取当前进程
            Process currentProcess = queue.get(index);
            // 执行该进程
            execute(currentProcess, timeSlice);
            // 更新当前时间
            currentTime += timeSlice;
            // 更新进程状态
            if (currentProcess.getExecuteTime() == 0) {
                queue.remove(currentProcess);
                index--;
            }
            // 更新下标
            index = (index + 1) % queue.size();
        }
    }

    // 优先级算法
    public void priority() {
        // 按照优先级排序
        processes.sort(Comparator.comparing(Process::getPriority));
        // 按照顺序执行进程
        for (Process process : processes) {
            execute(process);
        }
    }

    // 执行进程
    private void execute(Process process) {
        System.out.println("正在执行进程：" + process.getName());
        try {
            Thread.sleep(process.getExecuteTime());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 执行进程（时间片轮转算法）
    private void execute(Process process, int timeSlice) {
        System.out.println("正在执行进程：" + process.getName());
        try {
            Thread.sleep(Math.min(process.getExecuteTime(), timeSlice));
            process.setExecuteTime(process.getExecuteTime() - timeSlice);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 主程序
public class Main {
    public static void main(String[] args) {
        List<Process> processes = new ArrayList<>();
        processes.add(new Process("P1", 0, 500, 1));
        processes.add(new Process("P2", 0, 300, 2));
        processes.add(new Process("P3", 0, 400, 3));
        processes.add(new Process("P4", 0, 600, 4));
        Scheduler scheduler = new Scheduler(processes);
        Scanner scanner = new Scanner(System.in);
        System.out.println("请选择调度算法（1：先来先服务，2：短作业优先，3：时间片轮转，4：优先级）：");
        int choice = scanner.nextInt();
        switch (choice) {
            case 1:
                scheduler.fcfs();
                break;
            case 2:
                scheduler.sjf();
                break;
            case 3:
                System.out.println("请输入时间片大小：");
                int timeSlice = scanner.nextInt();
                scheduler.rr(timeSlice);
                break;
            case 4:
                scheduler.priority();
                break;
            default:
                System.out.println("无效选择！");
        }
    }
}

以上代码实现了进程类、调度器类和主程序的定义，可以在主程序中选择要使用的算法，并根据需要输入时间片大小等参数。