Hàng đợi giới hạn kích thước chứa N phần tử cuối cùng trong Java

Một câu hỏi rất đơn giản và nhanh chóng trên các thư viện Java: có một lớp được tạo sẵn thực hiện a Queuevới kích thước tối đa cố định - tức là nó luôn cho phép thêm các phần tử, nhưng nó sẽ âm thầm loại bỏ các phần tử đầu để chứa không gian cho các phần tử mới được thêm vào.

Tất nhiên, thật tầm thường khi thực hiện nó một cách thủ công:

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

Theo như tôi thấy, không có triển khai tiêu chuẩn nào trong các stdlib Java, nhưng có thể có một trong Apache Commons hay đại loại như thế?

Bộ sưu tập Apache commons 4 có một tròn trònFifoQueue <> đó là những gì bạn đang tìm kiếm. Trích dẫn javadoc:

ThongFifoQueue là hàng đợi vào trước xuất trước với kích thước cố định thay thế phần tử cũ nhất của nó nếu đầy đủ.

    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]

Nếu bạn đang sử dụng một phiên bản cũ hơn của các bộ sưu tập commons Apache (3.x), bạn có thể sử dụng Thông tư tròn , về cơ bản là điều tương tự mà không có chung chung.

Cập nhật : cập nhật câu trả lời sau khi phát hành bộ sưu tập commons phiên bản 4 có hỗ trợ chung.

Giờ đây, ổi có EvictingQueue , hàng đợi không chặn tự động lấy ra các phần tử từ đầu hàng đợi khi cố gắng thêm các phần tử mới vào hàng đợi và nó đã đầy.

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]

Tôi thích giải pháp @FractalizeR. Nhưng tôi cũng sẽ giữ và trả lại giá trị từ 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;
    }
}

Sử dụng thành phần không mở rộng (vâng tôi có nghĩa là mở rộng, như trong một tham chiếu đến từ khóa mở rộng trong java và có, đây là sự kế thừa). Thành phần là tuyệt vời hơn vì nó hoàn toàn che chắn việc thực hiện của bạn, cho phép bạn thay đổi việc thực hiện mà không ảnh hưởng đến người dùng của lớp.

Tôi khuyên bạn nên thử một cái gì đó như thế này (Tôi đang gõ trực tiếp vào cửa sổ này, vì vậy người mua hãy cẩn thận với các lỗi cú pháp):

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

Một lựa chọn tốt hơn (dựa trên câu trả lời của Asaf) có thể là bọc Bộ sưu tập ApacheFifoBuffer của Apache bằng một lớp chung. Ví dụ:

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
}

Điều duy nhất tôi biết có không gian hạn chế là giao diện BlockingQueue (được thực hiện bởi lớp ArrayBlockingQueue) - nhưng chúng không xóa phần tử đầu tiên nếu được lấp đầy, mà thay vào đó, chặn hoạt động put cho đến khi không gian trống (bị xóa bởi luồng khác ).

Theo hiểu biết của tôi, việc thực hiện tầm thường của bạn là cách dễ nhất để có được một hành vi như vậy.

Bạn có thể sử dụng MinMaxP WarriorityQueue từ Google Guava , từ javadoc:

Một hàng đợi ưu tiên tối thiểu có thể được cấu hình với kích thước tối đa. Nếu vậy, mỗi lần kích thước của hàng đợi vượt quá giá trị đó, hàng đợi sẽ tự động loại bỏ phần tử lớn nhất của nó theo bộ so sánh của nó (có thể là phần tử vừa được thêm vào). Điều này khác với các hàng đợi giới hạn thông thường, có thể chặn hoặc từ chối các phần tử mới khi đầy.

Một LRUMap là một khả năng khác, cũng từ 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;
    }
}