priorityqueue自定义排序

### 回答1：
你可以自定义排序方式，通过实现 Comparator 接口，并将其作为参数传递给 PriorityQueue 的构造函数，从而在堆中实现自定义的排序。例如：

PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});

这样就实现了从大到小的自定义排序。

### 回答2：
PriorityQueue是一种基于优先级的队列，它保证在任何时刻删除元素时都是最高优先级的元素先被删除。默认情况下，PriorityQueue使用元素的自然顺序进行排序，但是我们也可以自定义排序规则。

在Java中自定义排序规则的方法有两种，分别是实现Comparator接口和Lambda表达式。

1. 实现Comparator接口

Comparator是一个函数接口，它有一个compare方法，该方法接收两个参数，并返回一个int值。如果返回值小于0，则认为第一个参数小于第二个参数；如果返回值等于0，则认为两个参数相等；如果返回值大于0，则认为第一个参数大于第二个参数。

使用Comparator接口实现自定义排序规则的方式如下：

PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        // 按照值的大小进行排序
        return o1 - o2;
    }
});

queue.offer(3);
queue.offer(1);
queue.offer(5);

while (!queue.isEmpty()) {
    System.out.println(queue.poll()); // 1 3 5
}

上面代码中，我们通过实现Comparator接口的compare方法，定义了按照值的大小进行排序的规则。

2. Lambda表达式

Java 8引入了Lambda表达式，它可以用一种更简洁的方式实现Comparator接口。我们可以使用Lambda表达式来替代匿名内部类的写法，只需要提供排序规则。

使用Lambda表达式实现自定义排序规则的方式如下：

PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2) -> o1 - o2);

queue.offer(3);
queue.offer(1);
queue.offer(5);

while (!queue.isEmpty()) {
    System.out.println(queue.poll()); // 1 3 5
}

上面代码中，我们使用Lambda表达式来实现按照值的大小进行排序的规则。

总的来说，自定义排序规则是PriorityQueue的一个重要功能，它能够满足不同的排序需求，提高程序的效率和灵活性。无论是使用Comparator接口还是Lambda表达式，都能够轻松地实现自定义排序规则。

### 回答3：
PriorityQueue是Java中一个非常有用的数据结构，它可以按照一定的顺序来维护元素的顺序，我们可以使用它来实现许多有意思的应用。其中，一个非常常见的应用就是在排序的过程中使用PriorityQueue，可以实现对数据的快速排序。

在PriorityQueue中，我们可以使用默认的排序规则，也可以自己实现一个自定义的排序规则。如果要使用自定义的比较规则，我们需要实现一个Comparator接口，并在创建PriorityQueue时将这个Comparator传入。

例如，我们可以创建一个自定义的Student类，并在其中实现排序规则：

class Student {
    String name;
    int score;
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
}

class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        return s1.score - s2.score; // 按照分数从小到大排序
    }
}

public class Test {
    public static void main(String[] args) {
        PriorityQueue<Student> queue = new PriorityQueue<>(new StudentComparator());
        queue.offer(new Student("Tom", 80));
        queue.offer(new Student("Jerry", 90));
        queue.offer(new Student("Alice", 70));
        while (!queue.isEmpty()) {
            Student s = queue.poll();
            System.out.println(s.name + " " + s.score);
        }
    }
}

运行上述代码，输出结果为：

Alice 70
Tom 80
Jerry 90

从输出结果可以看出，按照分数从小到大排序后输出了所有学生的信息。

除了实现自定义的Comparator接口，我们还可以使用Java 8中新增的lambda表达式来实现排序规则。例如：

public class Test {
    public static void main(String[] args) {
        PriorityQueue<Student> queue = new PriorityQueue<>(
                (s1, s2) -> s1.score - s2.score // 按照分数从小到大排序
        );
        queue.offer(new Student("Tom", 80));
        queue.offer(new Student("Jerry", 90));
        queue.offer(new Student("Alice", 70));
        while (!queue.isEmpty()) {
            Student s = queue.poll();
            System.out.println(s.name + " " + s.score);
        }
    }
}

运行结果与上面的代码相同。

总之，使用自定义的排序规则可以使我们更好地掌控PriorityQueue中元素的顺序，从而更好地完成我们的算法和业务逻辑。