如何在Java中定义基于两个变量进行比较的比较器

我想创建一个比较器，这样一个到达时间较短的进程将首先出现在排序中，如果两个进程具有相同的到达时间，则具有较低进程id的进程将首先出现在排序中。我尝试了以下代码，但似乎不起作用。有人看到它有缺陷吗

public class FCFSComparator implements Comparator<Process>
{
    public int compare(Process o1, Process o2)
    {
        int result = o1.getArrivalTime() - o2.getArrivalTime();

        if(result == 0)
        {
            return (o1.getPid() < o2.getPid()) ? -1 : 1;
        }
        else
        {
            return result;
        }
//        return (result != 0 ? result : o1.getPid() - o2.getPid());
    }
}

最后，我得到了以下订单

Pid = 0 arrival time = 10
Pid = 2 arrival time = 15
Pid = 1 arrival time = 30
Pid = 4 arrival time = 66
Pid = 3 arrival time = 15

---

我相信你想要这个：

public class FCFSComparator implements Comparator<Process> {
    public int compare(Process o1, Process o2) {
        if (o1.getArrivalTime() == o2.getArrivalTime()) {
            return (o1.getPid() < o2.getPid()) ? -1 : 1;
        }
        return (o1.getArrivalTime() < o2.getArrivalTime()) ? -1 : 1;
    }
}

公共类FCFSComparator实现Comparator{
公共整数比较（过程o1、过程o2）{
如果（o1.getArrivalTime（）==o2.getArrivalTime（））{
返回值（o1.getPid（）

我假设您正在比较的东西是

int

。在两个变量相等的情况下，仍然从内部比较返回1。类似这样的事情应该会有所帮助：

public class FCFSComparator implements Comparator<Process>
{
    public int compare(Process o1, Process o2)
    {
        int result = o1.getArrivalTime() - o2.getArrivalTime();
        if (result == 0)
        {
            return o1.getPid() - o2.getPid();
        }
        else
        {
            return result;
        }
    }
}

完整测试代码为：

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

public class Main
{
    public static void main(String[] args)
    {
        List<Process> processes = new ArrayList<Process>();
        processes.add(new Process(10, 0));
        processes.add(new Process(30, 1));
        processes.add(new Process(15, 2));
        processes.add(new Process(15, 3));
        processes.add(new Process(66, 4));

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

        for (Process process : processes)
            System.out.println("Pid = " + process.getPid() + " arrival time = " + process.getArrivalTime());
    }

    static class FCFSComparator implements Comparator<Process>
    {
        public int compare(Process o1, Process o2)
        {
            int result = o1.getArrivalTime() - o2.getArrivalTime();
            if (result == 0)
            {
                return o1.getPid() - o2.getPid();
            }
            else
            {
                return result;
            }
        }
    }

    static class Process
    {
        private int arrivalTime;
        private int pid;

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

        public int getArrivalTime()
        {
            return arrivalTime;
        }

        public int getPid()
        {
            return pid;
        }
    }
}

import java.util.Comparator；
导入java.util.List；
导入java.util.ArrayList；
导入java.util.Collections；
公共班机
{
公共静态void main（字符串[]args）
{
列表进程=新的ArrayList（）；
流程。添加（新流程（10,0））；
添加（新工艺（30,1））；
添加（新工艺（15,2））；
添加（新工艺（15,3））；
添加（新工艺（66,4））；
排序（进程，新的FCFSComparator（））；
用于（流程：流程）
System.out.println（“Pid=“+process.getPid（）+”到达时间=“+process.getArrivalTime（））；
}
静态类FCFSComparator实现Comparator
{
公共整数比较（过程o1、过程o2）
{
int result=o1.getArrivalTime（）-o2.getArrivalTime（）；
如果（结果==0）
{
返回o1.getPid（）-o2.getPid（）；
}
其他的
{
返回结果；
}
}
}
静态类进程
{
私人入境时间；
私有int-pid；
进程（int到达时间、int pid）
{
this.arrivalTime=到达时间；
this.pid=pid；
}
public int getArrivalTime（）
{
返回时间；
}
公共int getPid（）
{
返回pid；
}
}
}

我找不到您的比较器有什么问题。以下是我的测试用例：

public class TestComparator {

    static class Process {
        int pid;
        int arrivalTime;

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

        @Override
        public String toString() {
            return "Process [pid=" + pid + ", arrivalTime=" + arrivalTime + "]";
        }
    }

    static class FCFSComparator implements Comparator<Process> {
        public int compare(Process o1, Process o2) {
            int result = o1.arrivalTime - o2.arrivalTime;

            if (result == 0) {
                return (o1.pid < o2.pid) ? -1 : 1;
            } else {
                return result;
            }
        }
    }

    public static void main(String[] args) {
        List<Process> processes = Arrays.asList(
                new Process(0, 10),
                new Process(1, 30),
                new Process(2, 15),
                new Process(3, 15),
                new Process(4, 66));

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

        for (Process process : processes) {
            System.out.println(process);
        }

    }
}

最简单的是：

public class FCFSComparator implements Comparator<Process>
{
    public int compare(Process o1, Process o2)
    {
        int timeCmp = Integer.valueOf(o1.getArrivalTime()).compareTo(Integer.valueOf(o2.getArrivalTime()));
        return (timeCmp != 0 ? timeCmp : Integer.valueOf(o1.getPid()).compareTo(Integer.valueOf(o2.getPid())));
    }
}

公共类FCFSComparator实现Comparator
{
公共整数比较（过程o1、过程o2）
{
int-timeCmp=Integer.valueOf（o1.getArrivalTime（））.compareTo（Integer.valueOf（o2.getArrivalTime（））；
return（timeCmp！=0？timeCmp:Integer.valueOf（o1.getPid（））.compareTo（Integer.valueOf（o2.getPid（）））；
}
}

请比“似乎不起作用”更具体一些。你拿这个干什么？你希望会发生什么？到底发生了什么？错误到底是什么？排序错误？你能举个例子说明它在哪里不起作用，以及你预期会发生什么吗？布鲁诺·康德帮我弄明白了。结果显示的比较器不是问题所在，而是显示值的函数。吸取的教训是不要使用foreach循环来显示优先级列表的值。@Varun Madiath我要说的教训是不要对优先级列表排序。这似乎不起作用。我的代码也有同样的问题。pid和到达时间的数据类型是什么？@Varun Madiath您试图调试或打印getArrivalTime（）的值吗？实现对我来说似乎很好，但结果似乎总是0。我已经调试了一段时间了。所有的值似乎都与我声明的值一致。另一点是，如果数字是非常大的负数，非常大的正数，则使用减法生成比较结果会失败，因为它会悄悄地溢出一个int。我尝试将此作为替换，我得到了与上面代码相同的输出。哦，是的，我注意到这实际上是一样的。我尝试了您的数据集，它对我来说适用于任何一种实现。您可能希望尝试包括

进程

类，至少包括

getPid（）

和

getArrivalTime（）

方法。这些都是简单的访问器方法。这个问题已经解决了，现在我正努力防止自己因为太愚蠢而把头撞在桌子上。呵呵，别担心：）至少帮你意识到了这个问题。你是对的。我使用PriorityList来测试代码，并使用通用foreach循环来测试值的输出，而不是poll函数。

public class TestComparator {

    static class Process {
        int pid;
        int arrivalTime;

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

        @Override
        public String toString() {
            return "Process [pid=" + pid + ", arrivalTime=" + arrivalTime + "]";
        }
    }

    static class FCFSComparator implements Comparator<Process> {
        public int compare(Process o1, Process o2) {
            int result = o1.arrivalTime - o2.arrivalTime;

            if (result == 0) {
                return (o1.pid < o2.pid) ? -1 : 1;
            } else {
                return result;
            }
        }
    }

    public static void main(String[] args) {
        List<Process> processes = Arrays.asList(
                new Process(0, 10),
                new Process(1, 30),
                new Process(2, 15),
                new Process(3, 15),
                new Process(4, 66));

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

        for (Process process : processes) {
            System.out.println(process);
        }

    }
}

Process [pid=0, arrivalTime=10]
Process [pid=2, arrivalTime=15]
Process [pid=3, arrivalTime=15]
Process [pid=1, arrivalTime=30]
Process [pid=4, arrivalTime=66]

public class FCFSComparator implements Comparator<Process>
{
    public int compare(Process o1, Process o2)
    {
        int timeCmp = Integer.valueOf(o1.getArrivalTime()).compareTo(Integer.valueOf(o2.getArrivalTime()));
        return (timeCmp != 0 ? timeCmp : Integer.valueOf(o1.getPid()).compareTo(Integer.valueOf(o2.getPid())));
    }
}