Java LinkedList

最新推荐文章于 2024-12-08 00:04:48 发布

原创最新推荐文章于 2024-12-08 00:04:48 发布 · 186 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java LinkedList #LinkedList 迭代器

JDK源码专栏收录该内容

13 篇文章

订阅专栏

本文深入解析了LinkedList的迭代器实现原理，介绍了其内部类ListItr的具体实现细节，包括节点结构、迭代操作如hasNext、next及remove等，并探讨了与ArrayList迭代器的不同之处。

List接口有两个实现，一个是ArrayList，另一个是LinkedList。从字面上就可以看出Array表示的是数组，Link表示的是链表，区别一目了然，今天看看LinkedList的迭代器的实现。

节点定义：


 private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

典型的链表节点结构啊！

ArrayList中可以通过iterator来获取迭代器，很可惜的告诉你，LinkedList中没有。它的基础就是listIterator。


 public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);
}

果不其然，又是一个内部类了。


private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned = null;
        private Node<E> next;
        private int nextIndex;
        private int expectedModCount = modCount;

        ListItr(int index) {
            // assert isPositionIndex(index);
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }

        public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

        public boolean hasPrevious() {
            return nextIndex > 0;
        }

        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();

            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }

        public int nextIndex() {
            return nextIndex;
        }

        public int previousIndex() {
            return nextIndex - 1;
        }

        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }

        public void set(E e) {
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }

        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }