Javaで最後のN個の要素を保持するサイズ制限のキュー

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などに実装されている可能性がありますか？

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コモンズコレクション（3.x）を使用している場合は、 ジェネリックなしで基本的に同じもので CircularFifoBufferを。

更新：ジェネリックをサポートするcommonsコレクションバージョン4のリリース後に回答を更新しました。

グアバは、今持っている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;
    }
}

extendsではなく、compositionを使用します（つまり、Javaのextendsキーワードへの参照のように、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クラスによって実装されている）です。 ）。

私の知る限り、あなたの簡単な実装は、そのような動作を実現する最も簡単な方法です。

あなたは使用することができますMinMaxPriorityQueueからGoogleのグアバを javadocツールから、：

min-maxプライオリティキューは、最大サイズで設定できます。その場合、キューのサイズがその値を超えるたびに、キューはそのコンパレーター（最大の要素は、追加されたばかりの要素である可能性があります）に従って自動的に削除します。これは、いっぱいになったときに新しい要素をブロックまたは拒否する従来の境界キューとは異なります。

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