Implement a queue using a linked list Implement a queue using a linked list.


I'm looking for a code review, optimizations and best practices.

public class QueueAsLinkedList&lt;T&gt; {

    private Node&lt;T&gt; front;
    private Node&lt;T&gt; rear;
    private int size;

    public QueueAsLinkedList() {} 

    private static class Node&lt;T&gt; {
        T item;
        Node&lt;T&gt; next;

        Node (T item, Node&lt;T&gt; next) {
            this.item = item;
            this.next = next;
        }
    }

    public void add(T item) {
        Node&lt;T&gt; node = new Node&lt;T&gt;(item, null);
        if (rear == null) {
            rear = node;
            front = node;
        } else {
            rear.next = node;
        }

        rear = node;
        size++;
    }

    public T remove() {
        if (front == null) {
            throw new NoSuchElementException();
        }
        T item = front.item;
        front = front.next;
        if (front == null) {
            rear = null;
        }
        size--;
        return item;
    }

    public T peek() {
        if (front == null) {
            throw new NoSuchElementException();
        }
        return front.item;
    }

    public int getCount() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }


    public static void main(String[] args) {
        QueueAsLinkedList&lt;Integer&gt; ll = new QueueAsLinkedList&lt;Integer&gt;();
        ll.add(1);   ll.add(2); ll.add(3);
        while (!ll.isEmpty()) {
            System.out.println(ll.remove());
        }
    }
}
There is no point in having the constructor for Node require the 'next' node. It is never part of the constructor, in your code.
The default constructor is useless code here. You may as well remove it, it does nothing.
the method getCount should be called size to be conformant with other classes.
I prefer when people use just one signal for the system state. In your code, you use size == 0 in some places to determine if the queue is empty, and in other places you use front == null


Otherwise the code looks functional, and neat.