10、补充基础：栈与队列模型
(1)Queue
PriorityQueue
PriorityQueue是Queue队列实现类，PriorityQueue保存队列元素的顺序不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序。当调用peek()或者poll()方法获取队列元素时，获取的是队列最小元素，而不是先入队列的元素。有点反先入先出规则。
public class DemoApplication {
public static void main(String[] args) {
PriorityQueue priorityQueue = new PriorityQueue();
priorityQueue.offer(5);
priorityQueue.offer(-1);
priorityQueue.offer(3);
priorityQueue.offer(7);
//查看入队顺序
System.out.println("队列输出：" + priorityQueue);
//peek方法获取队头元素但是不删除元素
System.out.println("peek()方法获取队头：" + priorityQueue.peek());
//查看第一个元素即为最小元素
System.out.println("第一个队列元素出队：" + priorityQueue.poll());
System.out.println("第二个队列元素出队：" + priorityQueue.poll());
System.out.println("第三个队列元素出队：" + priorityQueue.poll());
System.out.println("第四个队列元素出队：" + priorityQueue.poll());
System.out.println("null队列：" + priorityQueue.poll());
}
}
输出：
队列输出：[-1, 5, 3, 7]
peek()方法获取队头：-1
第一个队列元素出队：-1
第二个队列元素出队：3
第三个队列元素出队：5
第四个队列元素出队：7
null队列：null
(2)Deque
其中，offerFisrt内部是调用了addFirst
ArrayDeque
ArrayDeque概述
ArrayDeque底层实现类似于ArrayList，都是通过动态、可分配的Object[]数组来实现元素存储，当集合元素超过数组容量，会重新分配一个新的数组来存储集合元素。
public class DemoApplication {
public static void main(String[] args) {
//可以作为栈来使用，先进后出
ArrayDeque<String> arrayDeque = new ArrayDeque<>();
arrayDeque.push("book01");
arrayDeque.push("book03");
arrayDeque.push("book02");
arrayDeque.push("book04");
System.out.println("原栈：" + arrayDeque);
System.out.println("获取头部元素，但不删除该元素，peek(): " + arrayDeque.peek());
System.out.println("获取头部元素，且删除该元素，pop(): " +arrayDeque.pop());
System.out.println("获取第一个元素，但不删除：" + arrayDeque.getFirst());
System.out.println("获取最后一个元素，但不删除：" + arrayDeque.getLast());
System.out.println("在双端队列头部插入元素：" + arrayDeque.offerFirst("booknew01"));
System.out.println("在双端队列尾部插入元素：" + arrayDeque.offerLast("booknew02"));
System.out.println("新栈：" + arrayDeque);
}
}
输出：
原栈：[book04, book02, book03, book01]
获取头部元素，但不删除该元素: book04
获取头部元素，且删除该元素: book04
获取第一个元素，但不删除：book02
获取最后一个元素，但不删除：book01
true
true
新栈：[booknew01, book02, book03, book01, booknew02]
LinkedList
LinkedList概述
LinkedList实现List，同时也实现了Deque，可以当做双端队列来使用，可以当做“栈”或“队列”使用。
LinkedList与ArrayList、ArrayDeque不同之处在于底层实现，LinkedList底层是通过链表的形式存储元素，随机访问性能比较差，但是在插入、删除的时候性能比较好（只需要改变指针所指的地址就行）
LinkedList实现Deque的方法
void addFirst(Object e); //将指定元素插入该双向队列的开头。
void addLast(Object e); //将指定元素插入该双向队列的末尾。
Iterator descendingIterator(); //返回以该双向队列对应的迭代器，该迭代器将以逆向顺序来迭代队列中的元素。
Object getFirst(); //获取、但不删除双向队列的第一个元素。
Object getLast(); //获取、但不删除双向队列的最后一个元素。
boolean offerFirst(Object e);//将指定元素插入该双向队列的开头
boolean offerLast(Object e);//将指定元素插入该双向队列的结尾
Object peekFirst(); //获取、但不删除双向队列的第一个元素；如果此双端队列为空，则返回null。
Object peekLast(); //获取、但不删除该双向队列的最后一个元素；如果此双端队列为空，则返回null。
Object pollFirst(); //获取、并删除双向队列的第一个元素；如果此双端队列为空，则返回null。
Object pollLast(); //获取、并删除双向队列的最后一个元素，如果此双端队列为空，则返回null。
Object pop(); //pop出该双向队列所表示的栈中第一个元素。
void push(Object e); //将一个元素push进该双向队列所表示的栈中。
Object removeFirst(); //获取、并删除该双向队列的第一个元素。
Object removeFirstOccurrence(Object e); //删除该双向队列的第一次的出现元素e。
removeLast(); //获取、并删除该双向队列的最后一个元素。
removeLastOccurrence(Object e); //删除该双向队列的最后一次的出现元素e
① 使用ArrayList模拟队列
import java.util.LinkedList;
import java.util.Queue;
//用linkedList模拟队列，因为链表擅长插入和删除
public class Hi {
public static void main(String [] args) { //做剑指offer遇见过这个数结
Queue<String> queue = new LinkedList<String>();
//入队：追加元素:加到队尾部
queue.add("zero");
queue.offer("one");
queue.offer("two");
queue.offer("three");
queue.offer("four");
System.out.println(queue);//[zero, one, two, three, four]
//出队：从队首取出元素并删除
System.out.println(queue.poll());// zero
System.out.println(queue.remove());//one
System.out.println(queue);//[two, three, four]
//查看队首：从队首取出元素但是不删除
String peek = queue.peek();
System.out.println(peek); //two
//遍历队列，这里要注意，每次取完元素后都会删除，整个
//全部出队：队列会变短，所以只需要判断队列的大小即可
while(queue.size() > 0) {
System.out.println(queue.poll());
}//two three four
}
}
② 用linkedList模拟栈，因为链表擅长插入和删除
import java.util.Deque;
import java.util.LinkedList;
public class Hi {
public static void main(String[] args) {
/*模拟栈，这是从头开始进来的*/
Deque<String> deque = new LinkedList<String>();
/*Pushes an element onto the stack
*at the head of this dequeue */
deque.push("a");
deque.push("b");
deque.push("c");
System.out.println(deque); //[c, b, a]
//获取栈首元素后，元素不会出栈
System.out.println(deque.peek());//c
while(deque.size() > 0) {
//获取栈首元素后，元素将会出栈
System.out.println(deque.pop());//c b a
}
System.out.println(deque);//[]
/*模拟栈*/
deque.offerLast("a");
deque.offerLast("b");
deque.offerLast("c");// [a, b, c]
while(!deque.isEmpty())
System.out.println(deque.pollLast());
} // 先输出c再b最后a
}