Queue用于模拟队列这种数据结构，队列通常是“先进先出”（FIFO）的容器。队列的头部保存在队列中存放时间最长的元素，尾部保存存放时间最短的元素。 java 数据类型：集合接口Collection之队列Queue:PriorityQueue ;Dequeue接口和ArrayDeque实现类：
什么是Queue集合：
PriorityQueue实现类：
Deque接口和ArrayDeque实现类：
LinkedList:

java 数据类型：集合接口Collection之队列Queue:PriorityQueue ;Dequeue接口和ArrayDeque实现类：
什么是Queue集合：
PriorityQueue实现类：
Deque接口和ArrayDeque实现类：
LinkedList:

Queue接口定义了如下几个方法：

void add(Object e):将制定的元素加入队列的尾部
Object element(): 获取队列的头部元素，但不要删除改元素
boolean offer(Object e): 将制定元素加入此队列的尾部。当使用有容量限制的队列的时候，该方法比add方法更好
Object peek() : 获取队列头部的元素，但是不删除，如果队列为空，那么返回null
Object remove(): 获取队列头部的元素，并删除该元素
Object poll(): 获取并删除元素的头部的元素，如果队列为空，返回null

PriorityQueue实现类：

PriorityQueue是一个比较标准的队列实现类。为什么我们说它是比较标准的实现类，而不是绝对标准的呢？因为PriorityQueue队列的存放顺序，不是按照我们添加的顺序存放的，而是按照队列的元素大小重新排序的。所以说，我们调用peek()或者poll()方法区取出我们队列中的元素的时候，并不是取出最先加入的，而是取出最小的值。从这个意义上来看，PriorityQueue违反了队列的先进先出（FIFO）基本规则。

如何排序(同TreeSet)：

自然排序：每个队列存放的元素都必须实现Comparable这个接口
定制排序，初始化PriorityQueue的时候，必须传入一个Comapator对象

示例：

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

/**
 * @ClassName PriorityQueueExample
 * @projectName: object1
 * @author: Zhangmingda
 * @description： PriorityQueue 是Queue接口的实现类，队列内的元素会有优先级之分，并不是先进先出
 * date: 2021/4/10.
 */
public class PriorityQueueExample {
    public static void main(String[] args) {
        Queue queue = new PriorityQueue();
        queue.add(3);
        queue.add(33);
        queue.add(32);
        queue.add(-1);
        queue.add(-9);
        System.out.println(queue); //[-9, -1, 32, 33, 3]
        Queue queue1 = new PriorityQueue((o, t1) -> (int) t1 - (int)o);
        queue1.add(3);
        queue1.add(33);
        queue1.add(32);
        queue1.add(-1);
        queue1.add(-9);
        System.out.println(queue1); //[33, 3, 32, -1, -9]
    }
}

对象定制排序

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

/**
 * @ClassName PriorityQueueExample
 * @projectName: object1
 * @author: Zhangmingda
 * @description： PriorityQueue 是Queue接口的实现类，队列内的元素会有优先级之分，并不是先进先出
 * date: 2021/4/10.
 */
public class PriorityQueueExample {
    public static void main(String[] args) {
        class User implements Comparable{
            int age;

            public User(int age) {
                this.age = age;
            }

            @Override
            public int compareTo(Object o) {

                return this.age - ((User)o).age;
            }

            @Override
            public String toString() {
                return "User{" +
                        "age=" + age +
                        '}';
            }
        }

        Queue queue2 = new PriorityQueue();
        queue2.offer(new User(32));
        queue2.offer(new User(12));
        queue2.offer(new User(48));
        queue2.offer(new User(8));
        System.out.println(queue2); //[User{age=8}, User{age=12}, User{age=48}, User{age=32}]
    }
}

Deque接口和ArrayDeque实现类：

Deque接口是Queue接口的子接口，它代表一个双端队列：

特点：

添加元素可以选择从前或后都可

Deque接口里定义了一些双端队列的方法：

void addFirst(Object o)：将指定的元素插入到双端队列的开头
void addLast(Object o)：将指定的元素插入该双端队列的末尾
boolan offerFirst(Object e): 将指定元素插入该双端队列的开头
boolan offerLast(Object e): 将指定元素插入到双端队列的末尾
Iterator descendingIterator()：返回该双端队列对应的迭代器，该迭代器将以逆向顺序来迭代代码中的元素。
Object getFirst(): 获取但不删除双端队列的第一个元素
Object getLast(): 获取但不删除双端对垒的最后一个元素
Object peekFirst(): 获取但不删除该双端队列的第一个元素，如果此双端队列为空，那么返回null
Object peekLast(): 获取但不删除该双端队列的最后一个元素，如果此双端队列为空，那么返回null
Object pollFirst(): 获取并删除该双端队列的第一个元素，如果双端队列为空，那么返回null
Object pollLast():获取并删除该双端队列的最后一个元素，如果此双端队列为空，那么返回null

不仅可以当成双端队列使用，而且还可以被当做栈来使用，因为该类里面还包含了pop(出栈)、push(入栈)两个方法。

栈方式增删(先进后出)：

void push(Object e): 将一个元素push进该双端队列所表示的栈的栈顶。相当于addFirst()
Object pop() 栈方法： pop出双端队列所表示的栈的栈顶的元素。相当于removeFirst();

从上面方法中可以看出，Deque

什么是栈：

栈方式的使用方法：先进后出

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * @ClassName ArrayQueueExample
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/4/10.
 */
public class ArrayQueueExample {
    public static void main(String[] args) {
        ArrayDeque stack = new ArrayDeque();
        stack.push("张三");
        stack.push("李四");
        stack.push("老刘");
        System.out.println(stack);
        System.out.println(stack.size());
        int count = stack.size(); //注意：为什么不直接放到for循环里面？size()是变化的：因为for循环过程中pop后size()的值就变小了，
        for(int i=0; i<count; i++){
            String s = (String)stack.pop();
            System.out.println(s);
        }
        /**
         * 老刘
         * 李四
         * 张三
         */
    }
}

ArrayQueue队列的使用方法：先进先出

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * @ClassName ArrayQueueExample
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/4/10.
 */
public class ArrayQueueExample {
    public static void main(String[] args) {
        Queue queue = new ArrayDeque();
        queue.offer("张三");
        queue.offer("老李");
        queue.offer("老王");
        int counts = queue.size();
        for(int i=0; i<counts; i++){
            String s = (String)queue.poll();
            System.out.println(s);
        }
        /** 队列先进先出，后进后出
         * 张三
         * 老李
         * 老王
         */
    }
}

descendingIterator()： ArrayDeque特有逆向迭代器，逆向取对象

        ArrayDeque queue2 = new ArrayDeque();
        queue2.offer("张三");
        queue2.offer("老李");
        queue2.offer("老王");
        Iterator iterator = queue2.descendingIterator(); //ArrayDeque特有逆向迭代器
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        /** ArrayDeque特有逆向迭代器，逆向取对象
         * 老王
         * 老李
         * 张三
         */

LinkedList:

特点：

LinkedList是同时实现List接口和Deque接口的实现类，因此LinkedList可以被当做栈和队列来使用。
底层数据结构是双向链表，访问慢、添加删除效率高

代码如上只不过实现类不一样。

java 数据类型：集合接口Collection之队列Queue:PriorityQueue ;Dequeue接口和ArrayDeque实现类： 什么是Queue集合： PriorityQueue实现类： Deque接口和ArrayDeque实现类： LinkedList: