关于Java库的一个非常简单和快速的问题:是否有一个现成的类实现了一个具有固定最大大小的Queue——即它总是允许添加元素，但它会无声地删除头部元素以容纳新添加的元素。
当然，手动实现它很简单:
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或类似的东西中可能有一个?
当前回答
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;
}
}
LRUMap是另一种可能，同样来自Apache Commons。
http://commons.apache.org/collections/apidocs/org/apache/commons/collections/map/LRUMap.html
好吧，我分享这个选项。这是一个非常高性能的选项——它在内部使用数组——并重用条目。它是线程安全的—并且您可以以List的形式检索内容。
static class FixedSizeCircularReference<T> {
T[] entries
FixedSizeCircularReference(int size) {
this.entries = new Object[size] as T[]
this.size = size
}
int cur = 0
int size
synchronized void add(T entry) {
entries[cur++] = entry
if (cur >= size) {
cur = 0
}
}
List<T> asList() {
int c = cur
int s = size
T[] e = entries.collect() as T[]
List<T> list = new ArrayList<>()
int oldest = (c == s - 1) ? 0 : c
for (int i = 0; i < e.length; i++) {
def entry = e[oldest + i < s ? oldest + i : oldest + i - s]
if (entry) list.add(entry)
}
return list
}
}
你可以使用MinMaxPriorityQueue从谷歌Guava，从javadoc:
最小-最大优先级队列可以配置最大大小。如果是这样，每当队列的大小超过该值时，队列将根据其比较器(可能是刚刚添加的元素)自动删除其最大的元素。这与传统的有界队列不同，后者在新元素满时阻塞或拒绝新元素。
Apache公共集合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公共集合(3.x)的旧版本，你可以使用CircularFifoBuffer，它基本上是相同的东西，没有泛型。
更新:支持泛型的公共集合版本4发布后的更新答案。
