Three Approaches to Implementing Fixed-Size Queues in Java: From Manual Implementation to Apache Commons and Guava Libraries

Introduction and Problem Context

In software development practice, there is often a need to process the most recent N elements of a data stream, a requirement particularly common in scenarios such as log recording, real-time monitoring, and cache management. Although the Java standard library offers a rich collection framework, it does not provide a direct implementation of fixed-size queues. Developers typically need to encapsulate their own solutions or seek third-party libraries to address this issue.

Analysis of Manual Implementation

The simplest solution involves extending existing collection classes. The following is an example implementation based on LinkedList:

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

While this implementation is straightforward, it presents several potential issues: First, it violates the Liskov Substitution Principle by altering the behavior of the parent class; second, each addition operation may trigger multiple removal operations, resulting in suboptimal performance; finally, it lacks thread safety, requiring additional synchronization mechanisms in multi-threaded environments.

Apache Commons Collections Solution

Apache Commons Collections 4 provides the professional CircularFifoQueue class, which serves as the standard solution for fixed-size queue requirements. This class is designed following the First-In-First-Out (FIFO) principle, automatically removing the oldest elements to accommodate new ones when the queue reaches its maximum capacity.

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);
// Output: [2, 3]

The internal implementation of CircularFifoQueue employs circular buffer technology, which offers superior spatial and temporal efficiency compared to manual linked-list implementations. It uses an array to store elements and maintains head and tail pointers to achieve circular overwriting, thereby avoiding frequent memory allocation and garbage collection.

Guava Library Alternative

The Google Guava library offers EvictingQueue as another alternative. Although functionally similar, it differs in API design and implementation details:

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);
// Output: [2, 3]

EvictingQueue uses factory methods to create instances, a design pattern that provides greater flexibility and testability. Internally, it also employs an efficient circular buffer algorithm.

Performance Comparison and Selection Recommendations

From a performance perspective, both Apache Commons' CircularFifoQueue and Guava's EvictingQueue are thoroughly optimized and suitable for production environments. While the manual implementation is simple, it may encounter performance bottlenecks when handling large-scale data operations.

Selection recommendations: If a project already uses Apache Commons Collections, CircularFifoQueue is recommended; if the project is based on the Guava ecosystem, EvictingQueue is the better choice. For simple prototyping or educational purposes, manual implementation can aid in understanding underlying principles.

Practical Application Scenarios

Fixed-size queues find extensive applications across various domains: in logging systems, they can retain only the most recent N log records; in real-time monitoring, they can maintain sliding windows of recent N data points; in cache implementations, they can facilitate variants of the Least Recently Used (LRU) strategy.

Conclusion

Multiple approaches are available for implementing fixed-size queues in Java. Apache Commons Collections' CircularFifoQueue offers the most complete and standardized solution, featuring excellent performance and rich functionality. Developers should select the appropriate implementation based on specific project requirements, existing technology stacks, and performance considerations. Regardless of the chosen approach, understanding the internal implementation principles is crucial for writing efficient and reliable code.