实现一个固定长度的集合队列

在开发中，有时候我们会遇到这样的需求：

对一个集合操作，提前为集合指定最大大小，在我们不断向集合中添加数据的时候，当数据内容超过最大值的时候，自动将最先入队的元素移除队列。

实现方法很简单，代码如下

package com.test.limitqueue;

import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 实现一个固定长度的集合队列
 *
 * @author SHANHY(365384722@QQ.COM)
 * @date   2015年11月9日
 * @param <E>
 */
public class LimitQueue<E> implements Queue<E> {

	/**
	 * 队列长度，实例化类的时候指定 
	 */
    private int limit;  
      
    Queue<E> queue = new LinkedList<E>();  
      
    public LimitQueue(int limit){  
        this.limit = limit;  
    }  
      
    /**
     * 入队
     */
    @Override  
    public boolean offer(E e){  
        if(queue.size() >= limit){  
            //如果超出长度,入队时,先出队  
            queue.poll();  
        }
        return queue.offer(e);  
    }  
      
    /**
     * 出队 
     */
    @Override  
    public E poll() {  
        return queue.poll();  
    }  
      
    /**
     * 获取队列 
     * 
     * @return
     * @author SHANHY
     * @date   2015年11月9日
     */
    public Queue<E> getQueue(){  
        return queue;  
    }  
      
    /**
     * 获取限制大小
     * 
     * @return
     * @author SHANHY
     * @date   2015年11月9日
     */
    public int getLimit(){  
        return limit;  
    }  
  
    @Override  
    public boolean add(E e) {  
        return queue.add(e);  
    }  
  
    @Override  
    public E element() {  
        return queue.element();  
    }  
  
    @Override  
    public E peek() {  
        return queue.peek();  
    }  
  
    @Override  
    public boolean isEmpty() {  
        return queue.size() == 0 ? true : false;  
    }  
  
    @Override  
    public int size() {  
        return queue.size();  
    }  
  
    @Override  
    public E remove() {  
        return queue.remove();  
    }  
  
    @Override  
    public boolean addAll(Collection<? extends E> c) {  
        return queue.addAll(c);  
    }  
  
    @Override  
    public void clear() {  
        queue.clear();  
    }  
  
    @Override  
    public boolean contains(Object o) {  
        return queue.contains(o);  
    }  
  
    @Override  
    public boolean containsAll(Collection<?> c) {  
        return queue.containsAll(c);  
    }  
  
    @Override  
    public Iterator<E> iterator() {  
        return queue.iterator();  
    }  
  
    @Override  
    public boolean remove(Object o) {  
        return queue.remove(o);  
    }  
  
    @Override  
    public boolean removeAll(Collection<?> c) {  
        return queue.removeAll(c);  
    }  
  
    @Override  
    public boolean retainAll(Collection<?> c) {  
        return queue.retainAll(c);  
    }  
  
    @Override  
    public Object[] toArray() {  
        return queue.toArray();  
    }  
  
    @Override  
    public <T> T[] toArray(T[] a) {  
        return queue.toArray(a);  
    }  
}

package com.test.limitqueue;

/**
 * 测试
 *
 * @author SHANHY(365384722@QQ.COM)
 * @date   2015年11月9日
 */
public class TestQueue {

	public static void main(String[] args) {
		LimitQueue<String> list = new LimitQueue<String>(4);
		
		list.offer("SHANHY");
		System.out.println(list.size());
		list.offer("SHANHY");
		System.out.println(list.size());
		list.offer("SHANHY");
		System.out.println(list.size());
		list.offer("SHANHY");
		System.out.println(list.size());
		list.offer("SHANHY");
		System.out.println(list.size());
		list.offer("SHANHY");
		System.out.println(list.size());
		list.offer("SHANHY");
		System.out.println(list.size());
	}

}