java Collection之Queue

队列：像栈一样，队列（queue）也是表；

队列模型：队列的基本操作是enqueue（入队），它是在表的末端（叫做队尾（rear））插入一个元素，和dequeue（出队），它是删除（并返回）在表的开头（叫做对头（front））的元素。

特性：先进先出

队列模型：

Queue：

Java 集合中的 Queue 继承自 Collection 接口 ，Deque, LinkedList, PriorityQueue, BlockingQueue 等类都实现了它，Deque是双端队列，我们常用的LinkedList即是实现了Deque接口。

LinkedList类实现了Queue接口，因此，我们可以把LinkedList当成Queue使用；

Queue 中 element() 和 peek()都是用来返回队列的头元素，不删除。

element() 和 peek()的区别：在队列元素为空的情况下，element() 方法会抛出NoSuchElementException异常，peek() 方法只会返回 null。

 

队列分为阻塞队列和非阻塞队列：

非阻塞队列：LinkedList、PriorityQueue、ConcurrentLinkedQueue；

LinkedList是双向链表结构。

PriorityQueue维护了一个有序列表，存储到队列中的元素会按照自然顺序排列。

ConcurrentLinkedQueue是基于链接节点的并且线程安全的队列，在队列的尾部添加元素并从头部删除它们。

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

public class TestQueue {
    public static void main (String[] args){
        //LinkedList是双向链表结构
        Queue <String> queue = new LinkedList<String>();
        //通过add添加元素
        queue.add("添加");
        queue.add("元素");
        queue.add("成功");
        System.out.println(queue);
        //通过remove删除元素
        queue.remove("元素");
        System.out.println(queue);
        //通过offer添加元素
        queue.offer("了");
        System.out.println(queue);
        //通过element获取第一个元素
        String que = queue.element();
        System.out.println(que);
        //通过peek获取第一个元素
        String str1 = queue.peek();
        System.out.println(str1);
        //通过poll返回第一个元素并删除
        String str2 = queue.poll();
        System.out.println("poll返回第一个元素："+str2+"，并删除");
        System.out.println(queue);
        //size获取队列长度
        int num = queue.size();
        System.out.println("队列长度："+num);
        //contains
        if (queue.contains("成功")){
            System.out.println("contains()判断是否包含某元素，当前包含“成功”");
        }
        //判断队列是否为空
        if (queue.isEmpty()){
            System.out.println("isEmpty()判断队列是否为空，当前为空");
        }else {
            System.out.println("当前队列不为空");
        }

        Object[] ob = queue.toArray();
        System.out.println(ob.length);

        //PriorityQueue维护了一个有序列表，存储到队列中的元素会按照自然顺序排列。
        Queue queue2 = new PriorityQueue();
        queue2.offer("非");
        queue2.offer("阻塞");
        queue2.offer("队列");//[队列, 非, 阻塞]
        queue2.remove();//[阻塞, 非]
        System.out.println(queue2);

        //ConcurrentLinkedQueue是基于链接节点的并且线程安全的队列，在队列的尾部添加元素并从头部删除它们。
        Queue queue3 = new ConcurrentLinkedQueue();
        queue3.offer("非");
        queue3.offer("阻塞");
        queue3.offer("队列");//[非, 阻塞, 队列]
        queue3.remove();//[阻塞, 队列]
        System.out.println(queue3);
    }
}

阻塞队列：ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、DelayQueue、SynchronousQueue

ArrayBlockingQueue：内部由数组支持的有界队列。初始化时必须指定队列的容量，是基于数组的阻塞循环队列，此队列按 FIFO（先进先出）原则对元素进行排序。

LinkedBlockingQueue：内部由链接节点支持的可选有界队列。初始化时不需要指定队列的容量，默认是无限大容量。此队列按 FIFO（先进先出）排序元素 。

PriorityBlockingQueue：内部由优先级堆支持的无界优先级队列。PriorityBlockingQueue是对 PriorityQueue的再次包装，队列中的元素按优先级顺序被移除。

DelayQueue：内部由优先级堆支持的、基于时间的调度队列。队列中存放Delayed元素，只有在延迟期满后才能从队列中提取元素。当一个元素的getDelay()方法返回值小于等于0时才能从队列中poll中元素，否则poll()方法会返回null。

SynchronousQueue：利用 BlockingQueue 接口的简单聚集（rendezvous）机制。