129_容器_Queue与Deque_队列_模拟银行业务_自定义堆栈

• TestQueue.java

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();
}

• MyStack.java

package collection.others.Queue_Deque;

import java.util.ArrayDeque;
import java.util.Deque;
/**
 * 使用队列实现自定义堆栈
 * 1、弹
 * 2、压
 * 3、获取头
 */
public class MyStack<E> {
     /**
      * @param <E>
      */
    //容器
    private Deque<E> container =new ArrayDeque<E>();
    //容量
    private int cap;
    public MyStack(int cap) {
        super();
        this.cap = cap;
    }

    //压栈
    public boolean push(E e){
        if(container.size()+1>cap){
            return false;
        }
        return container.offerLast(e);
    }
    //弹栈
    public E pop(){
        return container.pollLast();
    }
    //获取
    public E peek(){
        return container.peekLast();
    }

    public int size(){
        return this.container.size();       
    }
}

• MyStackImpl.java

package collection.others.Queue_Deque;
/** Deque此接口扩展了 Queue接口
 * 在将双端队列用作队列时,将得到 FIFO(先进先出)行为。将元素添加到双端队列的末尾,从双端队列的开头移除元素。
 * 从 Queue接口继承的方法完全等效于 Deque方法，如下所示：
    Queue方法 等效 Deque方法
    add(e)      addLast(e)
    offer(e)    offerLast(e)
    remove()    removeFirst()
    poll()      pollFirst()
    element()   getFirst()
    peek()      peekFirst()
 * 双端队列也可用作 LIFO（后进先出）堆栈。应优先使用此接口而不是遗留 Stack 类。
 * 在将双端队列用作堆栈时,元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法完全等效于 Deque方法，如下所示：
    堆栈方法            等效 Deque 方法
    push(e)    addFirst(e)
    pop()      removeFirst()
    peek()     peekFirst()

    * boolean   add(E e) 
              将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
    * void addFirst(E e) 
              将指定元素插入此双端队列的开头（如果可以直接这样做而不违反容量限制）。
    * void addLast(E e) 
              将指定元素插入此双端队列的末尾（如果可以直接这样做而不违反容量限制）。
    * element() 
              获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
    * E getFirst() 
              获取，但不移除此双端队列的第一个元素。
    * E getLast() 
              获取，但不移除此双端队列的最后一个元素。
    * boolean   offer(E e) 
              将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用的空间，则返回 false。
    * boolean   offerFirst(E e) 
              在不违反容量限制的情况下，将指定的元素插入此双端队列的开头。
    * boolean   offerLast(E e) 
              在不违反容量限制的情况下，将指定的元素插入此双端队列的末尾。
    * E peek() 
              获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
    * E peekFirst() 
              获取，但不移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
    * E peekLast() 
              获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
    * E poll() 
              获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
    * E pollFirst() 
              获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
    * E pollLast() 
              获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
    * E pop() 
              从此双端队列所表示的堆栈中弹出一个元素。
    * void  push(E e) 
              将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
    * E remove() 
              获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
    * boolean   remove(Object o) 
              从此双端队列中移除第一次出现的指定元素。
    * E removeFirst() 
              获取并移除此双端队列第一个元素。
    * boolean   removeFirstOccurrence(Object o) 
              从此双端队列移除第一次出现的指定元素。
    * E removeLast() 
              获取并移除此双端队列的最后一个元素。
    * boolean   removeLastOccurrence(Object o) 
              从此双端队列移除最后一次出现的指定元素。
    * int   size() 
     返回此双端队列的元素数。
 */
public class MyStackImpl {
    //测试自定义堆栈
    public static void main(String[] args) {
        MyStack<String> backHistory =new MyStack<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());
        System.out.println("最后一个"+backHistory.peek());
        //遍历
        String item=null;
        while(null!=(item=backHistory.pop())){
            System.out.println(item);
        }
    }
}