Черга з обмеженням розміру, яка містить останні N елементів на Java

Дуже просте та швидке запитання щодо бібліотек 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 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 commons (3.x), ви можете використовувати CircularFifoBuffer, який в основному те саме, без дженериків.

Оновлення : оновлена ​​відповідь після випуску колекцій спільноти версії 4, яка підтримує дженерики.

Тепер у Guava є 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 в java, і так, це спадкування). Склад є суперерним, оскільки він повністю захищає вашу реалізацію, дозволяючи змінювати реалізацію, не впливаючи на користувачів вашого класу.

Я рекомендую спробувати щось подібне (я набираю безпосередньо в це вікно, тому покупець остерігайтесь синтаксичних помилок):

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 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 Guava , з javadoc:

Мінімальна пріоритетна черга може бути налаштована з максимальним розміром. Якщо так, щоразу, коли розмір черги перевищує це значення, черга автоматично видаляє свій найбільший елемент відповідно до свого компаратора (який може бути елементом, який щойно додали). Це відрізняється від звичайних обмежених черг, які або блокують, або відхиляють нові елементи, коли вони заповнені.

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