一、java中Queue,Deque,LinkedList的关系

Java中，LinkedList实现了Deque接口，Deque接口继承了Queue接口，因为LinkedList的插入，删除操作效率高；

二、Queue的主要方法

queue是单端队列
主要方法有：
offer（）：将元素添加到队列尾部
peek（）：返回队头元素但是不删除
pool （）：返回队头元素并删除
力扣225

public class QueueTest {

    public static void main(String[] args) {

        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(2);
        System.out.println(queue.peek());
        System.out.println(queue.peek());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

    }

}

1
1
1
2

三、Deque的主要方法

dueue是双向队列,该队列两端的元素既能入队，也能出队，如果将Deque限制为只能从一端入队和出队，可以实现栈的数据结构。
主要方法有：
push（）：入栈
pop（）：出栈
力扣232

public class DequeTest {

    public static void main(String[] args) {

        Deque<Integer> deque = new LinkedList<>();
        deque.push(1);
        deque.push(2);
        System.out.println(deque.pop());
        System.out.println(deque.pop());

    }

}

2
1

四、多态的思想

这里边也体现了多态的思想
多态：
1.父类引用 指向 子类对象
Animal a = new Cat();
2.编译看左边：想要实现的功能（调用的方法），必须是父类提供的；如果父类没有提供，编译会报错
3.运行看右边：多指发生方法重写后，实际调用的是子类的方法体。
4.多态的好处：是用来统一调用的标准，标准就是父类，如果父类没提供就不能用（比如说push()方法）

public class QueueTest {

    public static void main(String[] args) {

        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(2);
        
        //这里会显示“cannot resolve method 'push'”,因为queue里根本没有提供push()方法
        queue.push();
        
        System.out.println(queue.peek());
        System.out.println(queue.peek());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

    }

}

五、ArrayDeque

ArrayDeque和LinkedList都实现了Deque，但是有些时候ArrayDeque似乎更高效
力扣1047

如果需要添加和删除两端，ArrayDeque 明显优于LinkedList。
stackoverflow上对此问题的答案

六、PriorityQueue

1.大根堆和小跟堆

大根堆： 如果根节点存在左右子节点，那么根节点的值大于或等于左右子节点的值。
小根堆： 如果根节点存在左右子节点，那么根节点的值小于或等于左右子节点的值。

大根堆就是根节点比左右孩子都要大或者等于的二叉树，小根堆就是根节点比左右孩子都要小或者等于的二叉树。

总结关于大根堆和小根堆的结论：
（1）堆是一棵完全二叉树
（2）小根堆的根节点是堆中最小值，大根堆的根节点是堆中最大值

2.优先队列

PriorityQueue是优先队列，根据元素的优先级决定元素的出队次序。
PriorityQueue其实就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。

PriorityQueue默认是越小优先级越高，默认实现小顶堆

public static void main(String[] args) {

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

        minHeap.add(12);
        minHeap.add(2);
        minHeap.add(34);

        System.out.println(minHeap.poll());
        System.out.println(minHeap.poll());
        System.out.println(minHeap.poll());

    }

结果为：2 12 34

可以通过PriorityQueue的构造器修改比较规则，实现大顶堆

public static void main(String[] args) {

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

        minHeap.add(12);
        minHeap.add(2);
        minHeap.add(34);

        System.out.println(minHeap.poll());
        System.out.println(minHeap.poll());
        System.out.println(minHeap.poll());

    }

结果为：34 12 2