大小受限制的队列，其中包含Java中的最后N个元素

关于Java库的一个非常简单和快速的问题：是否有一个现成的类，该类Queue以固定的最大大小实现-即，它始终允许添加元素，但是它将静默删除head元素以容纳新添加元素的空间。

当然，手动实现它很简单：

import java.util.LinkedList;

public class LimitedQueue<E> extends LinkedList<E> {
    private int limit;

    public LimitedQueue(int limit) {
        this.limit = limit;
    }

    @Override
    public boolean add(E o) {
        super.add(o);
        while (size() > limit) { super.remove(); }
        return true;
    }
}

据我所知，Java stdlibs中没有标准实现，但是Apache Commons中可能有这种实现？

Apache Commons Collections 4具有您正在寻找的CircularFifoQueue <>。引用javadoc：

CircularFifoQueue是固定大小的先进先出队列，如果已满则替换其最早的元素。

    import java.util.Queue;
    import org.apache.commons.collections4.queue.CircularFifoQueue;

    Queue<Integer> fifo = new CircularFifoQueue<Integer>(2);
    fifo.add(1);
    fifo.add(2);
    fifo.add(3);
    System.out.println(fifo);

    // Observe the result: 
    // [2, 3]

如果您使用的是Apache Commons Collections（3.x）的较旧版本，则可以使用CircularFifoBuffer，这与没有泛型的情况基本相同。

更新：更新了支持通用的通用集合4版本之后的答案。

Guava现在具有EvictingQueue，这是一个非阻塞队列，当尝试向队列中添加新元素时，该队列会自动从队列的开头逐出元素，并且该队列已满。

import java.util.Queue;
import com.google.common.collect.EvictingQueue;

Queue<Integer> fifo = EvictingQueue.create(2); 
fifo.add(1); 
fifo.add(2); 
fifo.add(3); 
System.out.println(fifo); 

// Observe the result: 
// [2, 3]

我喜欢@FractalizeR解决方案。但是我还要保留并从super.add（o）返回值！

public class LimitedQueue<E> extends LinkedList<E> {

    private int limit;

    public LimitedQueue(int limit) {
        this.limit = limit;
    }

    @Override
    public boolean add(E o) {
        boolean added = super.add(o);
        while (added && size() > limit) {
           super.remove();
        }
        return added;
    }
}

使用合成不能扩展（是的，我的意思是扩展，就像在Java中对extends关键字的引用一样，是的，这是继承）。组成部分是更好的，因为它完全屏蔽了您的实现，使您可以在不影响类用户的情况下更改实现。

我建议您尝试类似的操作（我直接在此窗口中输入内容，因此买方请注意语法错误）：

public LimitedSizeQueue implements Queue
{
  private int maxSize;
  private LinkedList storageArea;

  public LimitedSizeQueue(final int maxSize)
  {
    this.maxSize = maxSize;
    storageArea = new LinkedList();
  }

  public boolean offer(ElementType element)
  {
    if (storageArea.size() < maxSize)
    {
      storageArea.addFirst(element);
    }
    else
    {
      ... remove last element;
      storageArea.addFirst(element);
    }
  }

  ... the rest of this class

更好的选择（基于Asaf的回答）可能是用通用类包装Apache Collections CircularFifoBuffer。例如：

public LimitedSizeQueue<ElementType> implements Queue<ElementType>
{
    private int maxSize;
    private CircularFifoBuffer storageArea;

    public LimitedSizeQueue(final int maxSize)
    {
        if (maxSize > 0)
        {
            this.maxSize = maxSize;
            storateArea = new CircularFifoBuffer(maxSize);
        }
        else
        {
            throw new IllegalArgumentException("blah blah blah");
        }
    }

    ... implement the Queue interface using the CircularFifoBuffer class
}

我唯一知道空间有限的是BlockingQueue接口（例如，由ArrayBlockingQueue类实现）-但它们不会在填充后删除第一个元素，而是会阻塞put操作，直到空间释放（由其他线程删除） ）。

据我所知，琐碎的实现是获得这种行为的最简单方法。

您可以通过javadoc 使用来自Google Guava的MinMaxPriorityQueue：

最小最大优先级队列可以配置为最大大小。如果是这样，则每次队列大小超过该值时，队列都会根据其比较器自动删除其最大元素（可能是刚刚添加的元素）。这与常规的有界队列不同，后者在满时阻塞或拒绝新元素。

LRUMap是另一种可能性，同样来自Apache Commons。

http://commons.apache.org/collections/apidocs/org/apache/commons/collections/map/LRUMap.html

    public class ArrayLimitedQueue<E> extends ArrayDeque<E> {

    private int limit;

    public ArrayLimitedQueue(int limit) {
        super(limit + 1);
        this.limit = limit;
    }

    @Override
    public boolean add(E o) {
        boolean added = super.add(o);
        while (added && size() > limit) {
            super.remove();
        }
        return added;
    }

    @Override
    public void addLast(E e) {
        super.addLast(e);
        while (size() > limit) {
            super.removeLast();
        }
    }

    @Override
    public boolean offerLast(E e) {
        boolean added = super.offerLast(e);
        while (added && size() > limit) {
            super.pollLast();
        }
        return added;
    }
}