คิวที่ จำกัด ขนาดที่มีองค์ประกอบ 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 คอมมอนส์คอลเลกชัน 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 Collection (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;
    }
}

ใช้การประพันธ์ไม่ขยาย (ใช่ฉันหมายถึงการขยายตามที่อ้างอิงถึงคำสำคัญการขยายใน 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 Collections 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;
    }
}