How to Implement a Fixed-Size Priority Queue with Custom Comparator in Java?

Question

Is there a PriorityQueue implementation with fixed capacity and a custom comparator in Java?

public class FixedSizePriorityQueue<E> extends TreeSet<E> {

    private int elementsLeft;

    public FixedSizePriorityQueue(int maxSize) {
        super(new NaturalComparator());
        this.elementsLeft = maxSize;
    }

    public FixedSizePriorityQueue(int maxSize, Comparator<E> comparator) {
        super(comparator);
        this.elementsLeft = maxSize;
    }

    @Override
    public boolean add(E e) {
        if (elementsLeft == 0 && size() == 0) {
            return false;
        } else if (elementsLeft > 0) {
            boolean added = super.add(e);
            if (added) {
                elementsLeft--;
            }
            return added;
        } else {
            int compared = super.comparator().compare(e, this.first());
            if (compared == 1) {
                pollFirst();
                super.add(e);
                return true;
            } else {
                return false;
            }
        }
    }
}

Answer

In scenarios where dealing with large datasets, managing a fixed-size priority queue that can accommodate a custom comparator can be a challenge. This guide provides an effective solution by implementing a custom PriorityQueue in Java, allowing you to manage the memory footprint and efficiently find the largest elements.

public class FixedSizePriorityQueue<E> extends TreeSet<E> {

    private int elementsLeft;

    public FixedSizePriorityQueue(int maxSize) {
        super(new NaturalComparator());
        this.elementsLeft = maxSize;
    }

    public FixedSizePriorityQueue(int maxSize, Comparator<E> comparator) {
        super(comparator);
        this.elementsLeft = maxSize;
    }

    @Override
    public boolean add(E e) {
        if (elementsLeft == 0 && size() == 0) {
            return false;
        } else if (elementsLeft > 0) {
            boolean added = super.add(e);
            if (added) {
                elementsLeft--;
            }
            return added;
        } else {
            int compared = super.comparator().compare(e, this.first());
            if (compared == 1) {
                pollFirst();
                super.add(e);
                return true;
            } else {
                return false;
            }
        }
    }
}

Causes

Need for efficient memory usage when handling large datasets.
Requirement to sort or prioritize elements based on custom criteria.
Desire to avoid excessive overhead from default PriorityQueue implementations.

Solutions

Implement a custom PriorityQueue class that extends a data structure such as TreeSet.
Utilize a comparator to define custom sorting behavior while enforcing a fixed size.

Common Mistakes

Mistake: Forgetting to set the comparator when instantiating the PriorityQueue.

Solution: Always pass the appropriate comparator to the constructor when creating the queue.

Mistake: Not checking the queue size before adding elements.

Solution: Implement a check within the add method to manage the size correctly.

Mistake: Assuming TreeSet handles duplicates automatically.

Solution: Utilize the comparator correctly to define how duplicates should be handled.

Helpers

Java PriorityQueue
Fixed size PriorityQueue
Custom comparator PriorityQueue
Java TreeSet implementation
PriorityQueue for large datasets