Java 如何使用PriorityQueue？

我如何让a根据我希望它排序的内容排序

---

另外，和方法之间是否有差异？

使用构造函数重载，它只需传递一个适合以下对象的

比较器：

PriorityQueue（int initialCapacity，Comparator没有区别，正如javadoc中声明的：

public boolean add(E e) {
    return offer(e);
}

发件人：

如果可能，offer方法会插入元素，否则返回false。这与Collection.add方法不同，Collection.add方法仅通过引发未检查的异常才能添加元素。offer方法设计用于在正常情况下而非异常情况下使用，例如，在固定容量（或“有界”）下排队

我也对打印顺序感到疑惑。考虑这个例子，例如：

对于优先级队列：

PriorityQueue<String> pq3 = new PriorityQueue<String>();

打印方式可能不同于：

String[] sa = {"a", "A"}; 
for(String s : sa)   
   pq3.offer(s);

我在一次讨论中找到了答案，其中一位用户说，“offer（）/add（）方法只会将元素插入队列。如果你想要一个可预测的顺序，你应该使用peek/poll返回队列的头部。”
只是为了回答
add（）
vs
offer（）
问题（因为另一个问题在国际海事组织得到了完美的回答，而这可能不是）：

根据“offer方法在可能的情况下插入元素，否则返回false。这与Collection.add方法不同，Collection.add方法只能通过引发未检查的异常而无法添加元素。offer方法设计用于在正常而非异常情况下使用，例如，在固定容量（或）“有界”队列。“

这意味着如果您可以添加元素（在PriorityQueue中应该始终是这种情况），它们的工作原理完全相同。但是如果您不能添加元素，
offer（）
将给您一个漂亮的
false
返回，而
add（）返回
抛出一个您不希望出现在代码中的严重未检查异常。如果添加失败意味着代码按预期工作和/或您将正常检查，请使用
offer（）
。如果添加失败意味着某些内容已损坏，请使用
add（）
并根据处理引发的异常

它们都是通过这种方式实现的，以在队列接口上填充契约，该队列接口指定
offer（）
通过返回
false
（）而失败，并且还在该队列接口上维护契约

无论如何，希望这至少澄清了问题的这一部分。
Java8解决方案
我们可以使用Java 8中引入的
lambda表达式
或
方法引用
。如果优先级队列中存储了一些字符串值（容量为5），我们可以提供内联比较器（基于字符串长度）：

使用lambda表达式

PriorityQueue<String> pq=
                    new PriorityQueue<String>(5,(a,b) -> a.length() - b.length());

要反转顺序（将其更改为最大优先级队列），只需在内联比较器中更改顺序或使用
reversed
如下所示：

PriorityQueue<String> pq = new PriorityQueue<String>(5, 
                             Comparator.comparing(String::length).reversed());

因此，我们可以看到
集合。reverseOrder
被重载，以获取比较器，该比较器对自定义对象非常有用。
reversed
实际上使用
集合。reverseOrder
：

PriorityQueue<Integer> pqInt = new PriorityQueue<>(10, Collections.reverseOrder());
PriorityQueue<String> pq = new PriorityQueue<String>(5, 
                Collections.reverseOrder(Comparator.comparing(String::length))

default Comparator<T> reversed() {
    return Collections.reverseOrder(this);
}

默认比较器反转（）{
返回集合。反向订单（此）；
}

offer（）与add（）的比较
按照

如果可能，offer方法插入一个元素，否则返回
false。这与Collection.add方法不同，后者可能无法
仅通过引发未经检查的异常来添加元素
该方法设计用于当故障为正常故障时使用，而不是
异常情况，例如，在固定容量（或“有界”）
排队

当使用容量受限队列时，offer（）通常比add（）更可取，它只能通过抛出异常才能插入元素。它是一个基于优先级堆的无限优先级队列。
优先级队列为每个元素分配了一些优先级，具有最高优先级的元素显示在队列的顶部。现在，这取决于您希望如何为每个元素分配优先级。如果您不希望t、 Java将以默认方式完成此操作。具有最小值的元素被分配最高优先级，因此首先从队列中删除。如果有多个具有相同最高优先级的元素，则会任意中断连接。您还可以使用构造函数
PriorityQueue中的Comparator指定顺序（初始容量，比较器）

示例代码：

PriorityQueue<String> queue1 = new PriorityQueue<>();
queue1.offer("Oklahoma");
queue1.offer("Indiana");
queue1.offer("Georgia");
queue1.offer("Texas");
System.out.println("Priority queue using Comparable:");
while (queue1.size() > 0) {
    System.out.print(queue1.remove() + " ");
}
PriorityQueue<String> queue2 = new PriorityQueue(4, Collections.reverseOrder());
queue2.offer("Oklahoma");
queue2.offer("Indiana");
queue2.offer("Georgia");
queue2.offer("Texas");
System.out.println("\nPriority queue using Comparator:");
while (queue2.size() > 0) {
    System.out.print(queue2.remove() + " ");
}

Priority queue using Comparable:
Georgia Indiana Oklahoma Texas 
Priority queue using Comparator:
Texas Oklahoma Indiana Georgia 

   india                                               
   pakistan                                         
   bangladesh

否则，您还可以定义自定义比较器：

import java.util.Comparator;

public class StringLengthComparator implements Comparator<String>
{
    @Override
    public int compare(String x, String y)
    {
        //Your Own Logic
    }
}

import java.util.Comparator；
公共类StringLengthComparator实现Comparator
{
@凌驾
公共整数比较（字符串x、字符串y）
{
//你自己的逻辑
}
}
在这里，我们可以定义用户定义的比较器：

PriorityQueue<String> queue1 = new PriorityQueue<>();
queue1.offer("Oklahoma");
queue1.offer("Indiana");
queue1.offer("Georgia");
queue1.offer("Texas");
System.out.println("Priority queue using Comparable:");
while (queue1.size() > 0) {
    System.out.print(queue1.remove() + " ");
}
PriorityQueue<String> queue2 = new PriorityQueue(4, Collections.reverseOrder());
queue2.offer("Oklahoma");
queue2.offer("Indiana");
queue2.offer("Georgia");
queue2.offer("Texas");
System.out.println("\nPriority queue using Comparator:");
while (queue2.size() > 0) {
    System.out.print(queue2.remove() + " ");
}

Priority queue using Comparable:
Georgia Indiana Oklahoma Texas 
Priority queue using Comparator:
Texas Oklahoma Indiana Georgia 

   india                                               
   pakistan                                         
   bangladesh

以下代码：

提供和添加方法之间的区别：
以下是一个简单的示例，可用于初步学习：

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;

public class PQExample {

    public static void main(String[] args) {
        //PriorityQueue with Comparator
        Queue<Customer> cpq = new PriorityQueue<>(7, idComp);
        addToQueue(cpq);
        pollFromQueue(cpq);
    }

    public static Comparator<Customer> idComp = new Comparator<Customer>(){

        @Override
        public int compare(Customer o1, Customer o2) {
            return (int) (o1.getId() - o2.getId());
        }

    };

    //utility method to add random data to Queue
    private static void addToQueue(Queue<Customer> cq){
        Random rand = new Random();
        for(int i=0;i<7;i++){
            int id = rand.nextInt(100);
            cq.add(new Customer(id, "KV"+id));
        }
    }


    private static void pollFromQueue(Queue<Customer> cq){
        while(true){
            Customer c = cq.poll();
            if(c == null) break;
            System.out.println("Customer Polled : "+c.getId() + " "+ c.getName());
        }
    }

}

import java.util.Comparator；
导入java.util.PriorityQueue；
导入java.util.Queue；
导入java.util.Random；
公共类示例{
公共静态void main（字符串[]args）{
//带比较器的优先队列
队列cpq=新的优先级队列（7，idComp）；
addToQueue（cpq）；
轮询队列（cpq）；
}
公共静态比较器idComp=新比较器（）{
@凌驾
公共整数比较（客户o1、客户o2）{
return（int）（o1.getId（）-o2.getId（））；
}
};
//向队列添加随机数据的实用方法
专用静态void addToQueue（队列cq）{
Random rand=新的Random（）；
对于（int i=0；i作为使用的替代方法，您还可以在您的
PriorityQueue
中使用类来实现（并相应地覆盖
compareTo
方法）

请注意，如果排序正确，通常最好只使用
Comparable
而不是
Comparator
import java.util.Comparator;

public class StringLengthComparator implements Comparator<String>
{
    @Override
    public int compare(String x, String y)
    {
        //Your Own Logic
    }
}

 import java.util.*;
 import java.util.Collections;
 import java.util.Comparator; 


 class Checker implements Comparator<String>
 {
    public int compare(String str1, String str2)
    {
        if (str1.length() < str2.length()) return -1;
        else                               return 1;
    }
 }


class Main
{  
   public static void main(String args[])
    {  
      PriorityQueue<String> queue=new PriorityQueue<String>(5, new Checker());  
      queue.add("india");  
      queue.add("bangladesh");  
      queue.add("pakistan");  
 
      while (queue.size() != 0)
      {
         System.out.printf("%s\n",queue.remove());
      }
   }  
}  

   india                                               
   pakistan                                         
   bangladesh

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;

public class PQExample {

    public static void main(String[] args) {
        //PriorityQueue with Comparator
        Queue<Customer> cpq = new PriorityQueue<>(7, idComp);
        addToQueue(cpq);
        pollFromQueue(cpq);
    }

    public static Comparator<Customer> idComp = new Comparator<Customer>(){

        @Override
        public int compare(Customer o1, Customer o2) {
            return (int) (o1.getId() - o2.getId());
        }

    };

    //utility method to add random data to Queue
    private static void addToQueue(Queue<Customer> cq){
        Random rand = new Random();
        for(int i=0;i<7;i++){
            int id = rand.nextInt(100);
            cq.add(new Customer(id, "KV"+id));
        }
    }


    private static void pollFromQueue(Queue<Customer> cq){
        while(true){
            Customer c = cq.poll();
            if(c == null) break;
            System.out.println("Customer Polled : "+c.getId() + " "+ c.getName());
        }
    }

}

import java.lang.Comparable;
import java.util.PriorityQueue;

class Test
{
    public static void main(String[] args)
    {
        PriorityQueue<MyClass> queue = new PriorityQueue<MyClass>();
        queue.add(new MyClass(2, "short"));
        queue.add(new MyClass(2, "very long indeed"));
        queue.add(new MyClass(1, "medium"));
        queue.add(new MyClass(1, "very long indeed"));
        queue.add(new MyClass(2, "medium"));
        queue.add(new MyClass(1, "short"));
        while (queue.size() != 0)
            System.out.println(queue.remove());
    }
}

class MyClass implements Comparable<MyClass>
{
    int sortFirst;
    String sortByLength;

    public MyClass(int sortFirst, String sortByLength)
    {
        this.sortFirst = sortFirst;
        this.sortByLength = sortByLength;
    }

    @Override
    public int compareTo(MyClass other)
    {
        if (sortFirst != other.sortFirst)
            return Integer.compare(sortFirst, other.sortFirst);
        else
            return Integer.compare(sortByLength.length(), other.sortByLength.length());
    }

    public String toString()
    {
        return sortFirst + ", " + sortByLength;
    }
}

int initialCapacity = 10;
PriorityQueue<T> pq = new PriorityQueue<>(initialCapacity, (e1, e2) -> { return e1.compareTo(e2); });

int initialCapacity = 10;
PriorityQueue<T> pq = new PriorityQueue<>(initialCapacity, new Comparator<T> () {

    @Override
    public int compare(T e1, T e2) {
        return e1.compareTo(e2);
    }

});