Reverse a doubly linkedlist Reverse a doubly linkedlist. Looking for code review, optimizations and best practices.

public class ReverseDoublyLinkedList&lt;T&gt; implements Iterable&lt;T&gt; {

    private Node&lt;T&gt; first;
    private Node&lt;T&gt; last;
    private int size;

    public ReverseDoublyLinkedList() { };

    public ReverseDoublyLinkedList(List&lt;T&gt; c) {
        for (T item : c) {
            add(item);
        }
    };

    public void add (T t) {
        final Node&lt;T&gt; l = last;
        final Node&lt;T&gt; node = new Node&lt;T&gt;(null, t, null);
        last = node;
        if (first == null) {
            first = node;
        } else {
            l.right = node;
            node.left = l;
        }
        size++;
    }

    private static class Node&lt;T&gt; {
        Node&lt;T&gt; left;
        T item;
        Node&lt;T&gt; right;

        public Node(Node&lt;T&gt; left, T item, Node&lt;T&gt; right) {
            this.left = left;
            this.item = item;
            this.right = right;
        }
    }

    public void reverse() {
        if (first == null) {
            throw new IllegalArgumentException("The root cannot be null.");
        }

        Node&lt;T&gt; node = first;
        while (node != null) {
            Node&lt;T&gt; temp = node.left;
            node.left = node.right;
            node.right = temp;

            node = node.left;
        }

        Node&lt;T&gt; temp = last;
        last = first;
        first = temp;
    }

    @Override
    public Iterator&lt;T&gt; iterator() {
        return new ListItr();
    }

    private class ListItr implements Iterator&lt;T&gt; {
        private int count;
        private Node&lt;T&gt; currentNode;

        public ListItr() {
             this.currentNode = first;
        }

        @Override
        public boolean hasNext() {
            return count &lt; size;
        }

        @Override
        public T next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }

            T item = currentNode.item;
            currentNode = currentNode.right;
            count++;
            return item;
        }

        @Override
        public void remove() {
            currentNode.left.right = currentNode.right;
            currentNode.right.left = currentNode.left;
        }
    }

    public static void main(String[] args) {
        ReverseDoublyLinkedList&lt;Integer&gt; foo = new ReverseDoublyLinkedList&lt;Integer&gt;();
        foo.add(10);
        foo.add(20);
        foo.add(30);

        foo.reverse();

        Iterator&lt;Integer&gt; itr = foo.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }
    }
}
The name ReverseDoublyLinkedList is not so good.  Just stick to DoublyLinkedList.

It would make more sense if the reverse method returned a new instance of the list.  Actually, I would have defined a static method that takes a list and return a reversed list.