Coda con dimensioni limitate che contiene gli ultimi N elementi in Java

Una domanda molto semplice e veloce sulle librerie Java: esiste una classe già pronta che implementa una Queuecon una dimensione massima fissa - cioè consente sempre l'aggiunta di elementi, ma rimuoverà silenziosamente gli elementi head per accogliere lo spazio per gli elementi appena aggiunti.

Certo, è banale implementarlo 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;
    }
}

Per quanto vedo, non esiste un'implementazione standard negli stdlibs Java, ma potrebbe essercene una in Apache Commons o qualcosa del genere?

Le raccolte 4 di Apache commons hanno un CircularFifoQueue <> che è quello che stai cercando. Citando il javadoc:

CircularFifoQueue è una coda first-in first-out con una dimensione fissa che sostituisce il suo elemento più vecchio se pieno.

    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 stai usando una versione precedente delle raccolte commons di Apache (3.x), puoi usare CircularFifoBuffer che è sostanzialmente la stessa cosa senza generici.

Aggiornamento : risposta aggiornata dopo il rilascio delle raccolte comuni versione 4 che supporta generici.

Guava ora ha una EvictingQueue , una coda non bloccante che elimina automaticamente gli elementi dall'intestazione della coda quando tenta di aggiungere nuovi elementi sulla coda ed è piena.

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]

Mi piace la soluzione @FractalizeR. Ma vorrei inoltre conservare e restituire il valore da 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;
    }
}

Usa la composizione non si estende (sì, intendo extends, come in un riferimento alla parola chiave extends in java e sì, questa è eredità). La composizione è superiore perché protegge completamente l'implementazione, consentendoti di modificarla senza influire sugli utenti della tua classe.

Consiglio di provare qualcosa del genere (sto digitando direttamente in questa finestra, quindi il compratore deve fare attenzione agli errori di sintassi):

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

Un'opzione migliore (basata sulla risposta di Asaf) potrebbe essere quella di avvolgere l' Apache Collections CircularFifoBuffer con una classe generica. Per esempio:

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
}

L'unica cosa che so che ha uno spazio limitato è l'interfaccia BlockingQueue (che è ad esempio implementata dalla classe ArrayBlockingQueue) - ma non rimuovono il primo elemento se riempito, ma bloccano invece l'operazione put fino a quando lo spazio è libero (rimosso da altri thread ).

Per quanto ne so, la tua banale implementazione è il modo più semplice per ottenere un simile comportamento.

Puoi utilizzare MinMaxPriorityQueue di Google Guava , dal javadoc:

Una coda con priorità min-max può essere configurata con una dimensione massima. In tal caso, ogni volta che la dimensione della coda supera quel valore, la coda rimuove automaticamente il suo elemento più grande in base al suo comparatore (che potrebbe essere l'elemento appena aggiunto). Ciò è diverso dalle code convenzionali limitate, che bloccano o rifiutano nuovi elementi quando sono pieni.

Un LRUMap è un'altra possibilità, anche di 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;
    }
}