Как определить компаратор в Java, который сравнивает на основе двух переменных

Question

Я хочу создать компаратор для работы таким образом, чтобы процесс с меньшим временем поступления отображался первым при сортировке, и если два процесса имеют одинаковое время поступления, то процесс с меньшим идентификатором процесса будет первым в сортировке. Я попробовал следующий код, но, похоже, он не работает. Кто-нибудь видит в этом изъян?

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 = 1 arrival time = 30
pid = 2 arrival time = 15
pid = 3 arrival time = 15
pid = 4 arrival time = 66

В конце я получаю следующий заказ

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

Answer 1

Я не могу найти ничего плохого в вашем компараторе.Вот мой тестовый пример:

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]

Answer 2

Я предполагаю, что вы сравниваете вещи 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;
        }
    }
}

РЕДАКТИРОВАТЬ: я проверил вышеуказанный код, и он выводит правильный порядок. Я могу только предположить, что у вас есть ошибка где-то еще в вашем коде.

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

Полный код теста:

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;
        }
    }
}

Answer 3

Я полагаю, вы хотите это:

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;
    }
}

Answer 4

Самое простое:

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())));
    }
}