Fila de tamanho limitado que contém os últimos N elementos em Java

Uma pergunta muito simples e rápida nas bibliotecas Java: existe uma classe pronta que implementa uma Queuecom um tamanho máximo fixo - isto é, sempre permite a adição de elementos, mas remove silenciosamente os elementos principais para acomodar espaço para os elementos adicionados recentemente.

Obviamente, é trivial implementá-lo manualmente:

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

Até onde eu vejo, não há implementação padrão no stdlibs Java, mas pode haver no Apache Commons ou algo assim?

O Apache commons collections 4 possui um CircularFifoQueue <> que é o que você está procurando. Citando o javadoc:

CircularFifoQueue é uma fila primeiro a entrar, primeiro a sair, com um tamanho fixo que substitui o elemento mais antigo se estiver cheio.

    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]

Se você estiver usando uma versão mais antiga das coleções comuns do Apache (3.x), poderá usar o CircularFifoBuffer, que é basicamente a mesma coisa sem genéricos.

Atualização : resposta atualizada após o lançamento do commons collections versão 4 que suporta genéricos.

O Goiaba agora tem um EvictingQueue , uma fila sem bloqueio que remove automaticamente os elementos do início da fila ao tentar adicionar novos elementos à fila e ela está cheia.

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]

Eu gosto da solução @FractalizeR. Além disso, eu manteria e retornaria o valor de 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;
    }
}

Use composição not extends (sim, quero dizer extends, como em uma referência à palavra-chave extends em java e sim, isso é herança). A composição é mais alta porque protege completamente sua implementação, permitindo alterar a implementação sem afetar os usuários de sua classe.

Eu recomendo tentar algo assim (estou digitando diretamente nesta janela, portanto, o comprador deve ficar atento aos erros de sintaxe):

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

Uma opção melhor (com base na resposta de Asaf) pode ser agrupar o CircularFifoBuffer do Apache Collections com uma classe genérica. Por exemplo:

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
}

A única coisa que sei que tem espaço limitado é a interface BlockingQueue (que é implementada pela classe ArrayBlockingQueue) - mas eles não removem o primeiro elemento se forem preenchidos, mas bloqueiam a operação de colocação até que o espaço esteja livre (removido por outro encadeamento )

Que eu saiba, sua implementação trivial é a maneira mais fácil de obter esse comportamento.

Você pode usar um MinMaxPriorityQueue do Google Guava , no javadoc:

Uma fila de prioridade min-max pode ser configurada com um tamanho máximo. Nesse caso, sempre que o tamanho da fila exceder esse valor, a fila remove automaticamente seu maior elemento de acordo com seu comparador (que pode ser o elemento que acabou de ser adicionado). Isso é diferente das filas limitadas convencionais, que bloqueiam ou rejeitam novos elementos quando cheios.

Um LRUMap é outra possibilidade, também do 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;
    }
}