Java 排序优先队列

我对PriorityQueues有一个问题，因为我相信它是按优先级排序的，但是我不确定优先级是什么（我指的是值是什么以及它来自哪里）。可以在构造函数中使用比较器创建priorityQueue，我已经尝试过了，但它不起作用

队列类别：

public JavaPriorityFlightQueue() {
    super();
    flights = new PriorityQueue(5, new SortQueueViaPriority());
}

比较国：

import java.util.Comparator;

public class SortQueueViaPriority implements Comparator {

    public int compare(Object o1, Object o2){
        Flight f1 = (Flight) o1; 
        Flight f2 = (Flight) o2;

        if( f1 == null || f2 == null ){
            if( f1 == f2 ) return 0;
            else if( f2 == null) return +1;
                else return -1;
        }

    Integer i1 = (Integer) f1.getPriority();
    Integer i2 = (Integer) f2.getPriority();
    return i2.compareTo(i1);
    }
}

优先级是一个int值，它是飞行等级的一部分。我测试这个

JavaPriorityFlightQueue flightQueue = new JavaPriorityFlightQueue();

Flight flight1 = new Flight("0001",9);
Flight flight2 = new Flight("0002",7);
Flight flight3 = new Flight("0003",1);
Flight flight4 = new Flight("0004",2);
Flight flight5 = new Flight("0005",1);

---

但是PriorityQueue没有排序，当我检查它时，值9从未与任何东西进行比较，结果是没有排序。compare类SortQueviaPriority是从另一个类复制和粘贴的，该类在该类中进行了完美排序。

我建议您尝试以下示例。如果使用PriorityQueue作为队列，则会按顺序删除条目

import java.util.Comparator;
import java.util.PriorityQueue;

public class Main {
    public static void main(String... args) {
        PriorityQueue<Flight> flights = new PriorityQueue<Flight>(5, new SortQueueViaPriority());
        flights.add(new Flight("0001", 9));
        flights.add(new Flight("0002", 7));
        flights.add(new Flight("0003", 1));
        flights.add(new Flight("0004", 2));
        flights.add(new Flight("0005", 1));

        while (!flights.isEmpty())
            System.out.println(flights.remove());
    }
}

class SortQueueViaPriority implements Comparator<Flight> {
    @Override
    public int compare(Flight f1, Flight f2) {
        return Integer.compare(f2.getPriority(), f1.getPriority());
    }
}

class Flight {
    private final String name;
    private final int priority;

    Flight(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Flight{" +
                "name='" + name + '\'' +
                ", priority=" + priority +
                '}';
    }
}

---

注意：PriorityQueue对条目进行排序，以便只有第一个元素是最小的。如果您在队列上迭代，您将看到所有元素，但它们可能是有序的，也可能不是有序的。

问题是

Iterator

。如中所述

import java.util.Comparator;
import java.util.PriorityQueue;

public class Main {
    public static void main(String... args) {
        PriorityQueue<Flight> flights = new PriorityQueue<Flight>(5, new SortQueueViaPriority());
        flights.add(new Flight("0001", 9));
        flights.add(new Flight("0002", 7));
        flights.add(new Flight("0003", 1));
        flights.add(new Flight("0004", 2));
        flights.add(new Flight("0005", 1));

        while (!flights.isEmpty())
            System.out.println(flights.remove());
    }
}

class SortQueueViaPriority implements Comparator<Flight> {
    @Override
    public int compare(Flight f1, Flight f2) {
        return Integer.compare(f2.getPriority(), f1.getPriority());
    }
}

class Flight {
    private final String name;
    private final int priority;

    Flight(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Flight{" +
                "name='" + name + '\'' +
                ", priority=" + priority +
                '}';
    }
}

返回此队列中元素的迭代器。迭代器不会以任何特定顺序返回元素

由于

toString

使用迭代器，因此不会按顺序打印。或者，如果您使用基于迭代器的循环，那么它也将是有序的

import java.util.Comparator;
import java.util.PriorityQueue;

public class Main {
    public static void main(String... args) {
        PriorityQueue<Flight> flights = new PriorityQueue<Flight>(5, new SortQueueViaPriority());
        flights.add(new Flight("0001", 9));
        flights.add(new Flight("0002", 7));
        flights.add(new Flight("0003", 1));
        flights.add(new Flight("0004", 2));
        flights.add(new Flight("0005", 1));

        while (!flights.isEmpty())
            System.out.println(flights.remove());
    }
}

class SortQueueViaPriority implements Comparator<Flight> {
    @Override
    public int compare(Flight f1, Flight f2) {
        return Integer.compare(f2.getPriority(), f1.getPriority());
    }
}

class Flight {
    private final String name;
    private final int priority;

    Flight(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Flight{" +
                "name='" + name + '\'' +
                ", priority=" + priority +
                '}';
    }
}

在

队列检索操作轮询、移除、查看和元素访问队列头部的元素

---

要按顺序获得结果，您必须使用其中一种方法。

而不是

比较器

只需使用

可比

界面即可

您的飞行类应该实现类似的接口。然后需要重写

compareTo（）

方法。在该方法中，您可以根据需要的属性添加自己的排序逻辑

就这样,

@Override
public int compareTo(Object obj) {
    // TODO Auto-generated method stub
    Flight f = (Flight)obj;
    if(this.a <f.a){
    return 1;
    }else{
        return -1;
    }
}

@覆盖
公共整数比较（对象对象对象）{
//TODO自动生成的方法存根
航班f=（航班）obj；
如果（这个.a@dacwe是正确的，那么OP在任何情况下都是这样实现的。正如我在最后指出的，flightID=0003，priority=1）Flight[flightID=0005，priority=1]Flight[flightID=0002，priority=7]Flight[flightID=0001，priority=9]Flight[flightID=0004，priority=2]这是意料之中的。请看这个答案：