Queue与Deque队列和自定义堆栈

Queue

Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

队列是一种数据结构．它有两个基本操作：在队列尾部加人一个元素，和从队列头部移除一个元素就是说，队列以一种先进先出(FIFO–>First In First Out)的方式管理数据，如果你试图向一个已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索，将导致线程阻塞。在多线程进行合作时，阻塞队列是很有用的工具。工作者线程可 以定期地把中间结果存到阻塞队列中而其他工作者线线程把中间结果取出并在将来修改它们。队列会自动平衡负载。如果第一个线程集运行得比第二个慢，则第二个线程集在等待结果时就会阻塞。如果第一个线程集运行得快，那么它将等待第二个线程集赶上来。

                                                            

add        增加一个元索              如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove     移除并返回队列头部的元素    如果队列为空，则抛出一个NoSuchElementException异常
element    返回队列头部的元素         如果队列为空，则抛出一个NoSuchElementException异常
offer      添加一个元素并返回true     如果队列已满，则返回false
poll       移除并返问队列头部的元素    如果队列为空，则返回null
peek       返回队列头部的元素         如果队列为空，则返回null
put        添加一个元素              如果队列满，则阻塞
take       移除并返回队列头部的元素    如果队列为空，则阻塞

Queue使用时要尽量避免Collection的add()和remove()方法，而是要使用offer()来加入元素，使用poll()来获取并移出元素。它们的优点是通过返回值可以判断成功与否，add()和remove()方法在失败的时候会抛出异常。 如果要使用前端而不移出该元素，使用element()或者peek()方法。

package collection.others.Queue_Deque;
/**Dqeue接口
 * 1. add(E e)  
       将指定的元素插入此队列(如果立即可行且不会违反容量限制),在成功时返回 true,如果当前没有可用的空间,则抛出 IllegalStateException。
 * 2. E element() 
         获取,但是不移除此队列的头。
 * 3. E remove() 
         获取并移除此队列的头。
 * 4. boolean   offer(E e) 
          将指定的元素插入此队列(如果立即可行且不会违反容量限制),当使用有容量限制的队列时,此方法通常要优于 add(E),后者可能无法插入元素,而只是抛出一个异常。
 * 5. E peek() 
          获取但不移除此队列的头;如果此队列为空,则返回 null.
 * 6. E poll() 
          获取并移除此队列的头,如果此队列为空,则返回 null.
 */
import java.util.ArrayDeque;
import java.util.Queue;

/**
 * 使用队列模拟银行存款业务
 * @author Administrator
 *
 */
public class TestQueue {
    public static void main(String[] args) {
        Queue<Request> que =new ArrayDeque<Request>();
        //模拟排队情况
        for(int i=0;i<10;i++){
            final int num =i;
            que.offer(new Request(){
                @Override
                public void depost() {
                    System.out.println("第"+num+"个人，办理存款业务，存款额度为:"+(Math.random()*10000));
                }
            });
        }
        dealWith(que);      
    }
    //处理业务
    public static void dealWith(Queue<Request> que){
        Request req =null;
        while(null!=(req=que.poll())){
            req.depost();
        }
    }
}
interface Request{
    //存款
    void depost();
}

Deque

一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。
接口定义在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。插入操作的后一种形式是专为使用有容量限制的 Deque 实现设计的；在大多数实现中，插入操作不能失败。

                                              

此接口扩展了 Queue 接口。在将双端队列用作队列时，将得到 FIFO（先进先出）行为。将元素添加到双端队列的末尾，从双端队列的开头移除元素。从 Queue 接口继承的方法完全等效于 Deque 方法，如下表所示：

                                                                      

//自定义堆栈
import java.util.ArrayDeque;
import java.util.Deque;

public class TestDeque<E> {

    private Deque<E> container= new ArrayDeque<E>();
    int cap;

    public TestDeque(int cap) {
        super();
        this.cap = cap;
    }

    public boolean push(E e){
        if(container.size()+1>cap){
            return false;
        }
        container.offerLast(e);
        return true;
    }

    public E pop(){
        return container.pollLast();
    }

    public E peek(){
        return container.peekLast();
    }

    public int size(){
        return cap;
    }

    public static void main(String[] args) {
        TestDeque<String> backHistory =new TestDeque<String>(3);
        backHistory.push("www.baidu.com");
        backHistory.push("www.google.com");
        backHistory.push("www.sina.com");
//      backHistory.push("www.bjsxt.cn");

        System.out.println("大小："+backHistory.size());
        //遍历
        String item=null;
        while(null!=(item=backHistory.pop())){
            System.out.println(item);
        }
    }
}

输出结果：大小：3
        www.sina.com
        www.google.com
        www.baidu.com