Cola de tamaño limitado que contiene los últimos N elementos en Java

La guayaba ahora tiene un desahucio, una cola sin bloqueo que desaloja automáticamente elementos de la cabecera de la cola al intentar agregar nuevos elementos a la cola y está llena.

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]

Me gusta la solución @FractalizeR. Pero yo, además, mantener y devolver el 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 composition not extends (sí quiero decir extends, como en una referencia a la palabra clave extends en java y sí esto es herencia). La composición es superior porque protege completamente su implementación, lo que le permite cambiar la implementación sin afectar a los usuarios de su clase.

Recomiendo probar algo como esto (estoy escribiendo directamente en esta ventana, para que el comprador tenga cuidado con los errores de sintaxis):

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

Una mejor opción (basada en la respuesta de Asaf) podría ser envuelva las colecciones de Apache CircularFifoBuffer con una clase genérica. Por ejemplo:

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
}

Lo único que sé que tiene espacio limitado es la interfaz BlockingQueue (que por ejemplo está implementada por la clase ArrayBlockingQueue) - pero no eliminan el primer elemento si se llena, sino que bloquean la operación put hasta que el espacio esté libre (eliminado por otro hilo).

Que yo sepa, su implementación trivial es la forma más fácil de obtener tal comportamiento.

Un LRUMap es otra posibilidad, también desde Apache Commons.

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

Puedes usar un MinMaxPriorityQueue de Google Guava , del javadoc:

Se puede configurar una cola de prioridad min-max con un tamaño máximo. Si es así, cada vez que el tamaño de la cola excede ese valor, la cola elimina automáticamente su elemento más grande de acuerdo con su comparador (que podría ser el elemento que se acaba de agregar). Esto es diferente de las colas acotadas convencionales, que bloquean o rechazan nuevos elementos cuando están llenos.

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