Java'da son N öğeyi barındıran boyut sınırlı kuyruk

Java kitaplıkları hakkında çok basit ve hızlı bir soru: Queuesabit bir maksimum boyutta bir uygulayan hazır bir sınıf var mı?

Elbette, manuel olarak uygulanması önemsizdir:

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

Gördüğüm kadarıyla, Java stdlibs'te standart bir uygulama yok, ancak Apache Commons'ta bir tane veya böyle bir şey olabilir mi?

Apache ortak koleksiyonları 4, aradığınız şey olan bir CircularFifoQueue <> değerine sahiptir . Javadoc'tan alıntı:

CircularFifoQueue, doluysa en eski öğesini değiştiren sabit boyutlu ilk giren ilk çıkar kuyruğudur.

    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 ortak koleksiyonlarının (3.x) daha eski bir sürümünü kullanıyorsanız , temel olarak jenerik olmayan aynı şey olan CircularFifoBuffer'ı kullanabilirsiniz .

Güncelleme : müşterek koleksiyonları jenerikleri destekleyen sürüm 4'ün yayınlanmasının ardından güncellenen cevap.

Guava'nın artık kuyruğa yeni öğeler eklemeye çalışırken öğeleri otomatik olarak kuyruğun başından tahliye eden , engellenmeyen bir kuyruk olan bir EvictingQueue var ve dolu.

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]

@FraktalizeR çözümünü seviyorum. Ama ek olarak tutmak ve super.add (o) değerini iade ediyorum!

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

Genişlemeyen kompozisyon kullanın (evet, java'daki extends anahtar kelimesine yapılan bir başvuruda olduğu gibi, extends demekti ve evet bu kalıtımdır). Kompozisyon daha üst düzeydir, çünkü uygulamanızı tamamen korur ve sınıfınızın kullanıcılarını etkilemeden uygulamayı değiştirmenize izin verir.

Böyle bir şey denemenizi öneririz (doğrudan bu pencereye yazıyorum, bu yüzden alıcı sözdizimi hatalarına dikkat edin):

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

Daha iyi bir seçenek (Asaf'ın cevabına göre) Apache Collections CircularFifoBuffer'ı genel bir sınıfla sarmak olabilir . Örneğin:

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
}

Sınırlı alanı olduğunu bildiğim tek şey BlockingQueue arabirimi (örneğin ArrayBlockingQueue sınıfı tarafından uygulanır) - ancak doldurulduklarında ilk öğeyi kaldırmazlar, ancak boşluk boş olana kadar put işlemini engellerler (diğer iş parçacıkları tarafından kaldırılırlar) ).

Bildiğim kadarıyla, önemsiz uygulamanız böyle bir davranışa ulaşmanın en kolay yoludur.

Google Guava'dan , javadoc'tan bir MinMaxPriorityQueue kullanabilirsiniz :

Bir min-maks öncelik sırası maksimum boyutta yapılandırılabilir. Öyleyse, sıranın boyutu bu değeri her aştığında, kuyruk karşılaştırıcısına göre (en yeni eklenen öğe olabilir) en büyük öğesini otomatik olarak kaldırır. Bu, dolduğunda yeni öğeleri engelleyen veya reddeden geleneksel sınırlı kuyruklardan farklıdır.

Bir LRUMap, Apache Commons'tan da başka bir olasılık.

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