Java LinkedList 实现原理

原创 2016年08月31日 16:19:09

LinkedList 大家都不陌生,来看看他的实现原理,首先声明,他是一个双链条,即previous,next 

   /**
     * Constructs a new empty instance of {@code LinkedList}.
     */
    public LinkedList() {
        voidLink = new Link<E>(null, null, null);
        voidLink.previous = voidLink;
        voidLink.next = voidLink;
    }
默认无参构造方法中,新建了一个空节点,他的previous,next都 指向他自己。另外一个构造方法:

   /**
     * Constructs a new instance of {@code LinkedList} that holds all of the
     * elements contained in the specified {@code collection}. The order of the
     * elements in this new {@code LinkedList} will be determined by the
     * iteration order of {@code collection}.
     *
     * @param collection
     *            the collection of elements to add.
     */
    public LinkedList(Collection<? extends E> collection) {
        this();
        addAll(collection);
    }
默认添加节点的位置是在最后:

/**
     * Adds the specified object at the end of this {@code LinkedList}.
     *
     * @param object
     *            the object to add.
     * @return always true
     */
    @Override
    public boolean add(E object) {
        return addLastImpl(object);
    }

    private boolean addLastImpl(E object) {
        Link<E> oldLast = voidLink.previous;
        Link<E> newLink = new Link<E>(object, oldLast, voidLink);
        voidLink.previous = newLink;
        oldLast.next = newLink;
        size++;
        modCount++;
        return true;
    }
其中链条的设置顺序为:

1.先设置新添加的节点的previous,next

2.然后设置老节点的next,和空节点的previous,完成节点链条的设置值。

3.总大小自增,修改次数自增

属性modCount的作用在于:
private class SimpleListIterator implements Iterator<E> {
        int pos = -1;

        int expectedModCount;

        int lastPosition = -1;

        SimpleListIterator() {
            expectedModCount = modCount;
        }

        public boolean hasNext() {
            return pos + 1 < size();
        }

        public E next() {
            if (expectedModCount == modCount) {
                try {
                    E result = get(pos + 1);
                    lastPosition = ++pos;
                    return result;
                } catch (IndexOutOfBoundsException e) {
                    throw new NoSuchElementException();
                }
            }
            throw new ConcurrentModificationException();
        }

        public void remove() {
            if (this.lastPosition == -1) {
                throw new IllegalStateException();
            }

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

            try {
                AbstractList.this.remove(lastPosition);
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }

            expectedModCount = modCount;
            if (pos == lastPosition) {
                pos--;
            }
            lastPosition = -1;
        }
    }
当你在遍历整个list列表数据时,如果异步线程修改了这个列表的数据时,这个list遍历过程能够及时的抛错并退出当前的遍历,可以很好的保护数据读取的一致性。
如果我们要移除一部分数据时:

    /**
     * Removes the object at the specified location from this {@code LinkedList}.
     *
     * @param location
     *            the index of the object to remove
     * @return the removed object
     * @throws IndexOutOfBoundsException
     *             if {@code location < 0 || location >= size()}
     */
    @Override
    public E remove(int location) {
        if (location >= 0 && location < size) {
            Link<E> link = voidLink;
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            Link<E> previous = link.previous;
            Link<E> next = link.next;
            previous.next = next;
            next.previous = previous;
            size--;
            modCount++;
            return link.data;
        }
        throw new IndexOutOfBoundsException();
    }
移除数据相对比较简单:

1.定位移除节点的位置

2.上一节点的next 设值

3.下一节点的previous 设值
相关的方法: removeFirstImpl,removeLastImpl

其中里面有一个关键字:transient


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Java LinkedList的实现原理详解

LinkedList是Java List类型的集合类的一种实现,此外,LinkedList还实现了Deque接口。本文基于Java1.8,对于LinkedList的实现原理做一下详细讲解。 (Java...

Java集合之ArrayList和LinkedList的实现原理以及Iterator详解

ArrayList实现可变数组的原理:   当元素超出数组内容,会产生一个新数组,将原来数组的数据复制到新数组中,再将新的元素添加到新数组中。   ArrayList:是按照原数组的50%来延长,...

【JAVA笔记】Linkedlist的实现原理

待补充

深入Java集合学习系列:LinkedList的实现原理

1. LinkedList概述:   List 接口的链接列表实现。实现所有可选的列表操作,并且允许所有元素(包括 null)。除了实现 List 接口外,LinkedList 类还为在列表的开头...

java LinkedList实现原理概述

一、LinkedList实现原理概述 LinkedList 和 ArrayList 一样,都实现了 List 接口,但其内部的数据结构有本质的不同。LinkedList 是基于链表实现的(通过名...

Java用LinkedList实现的Stack

  • 2017年01月04日 11:11
  • 1KB
  • 下载

java中ArrayList与LinkedList的原理及区别

ArrayListArrayList实现原理就是动态数组,为什么叫动态数组呢,就是当ArrayList容量扩大时,底层的数组的容量会自动扩大50%,并且ArrayList是线程不安全的。 其优点是查询...

java jdk1.7版本的LinkedList底层原理解析

LinkedList集合与ArrayList即可的区别是LinkedList存储的元素是有序的,底层的实现原理也不一样。LinkedList底层是通过一个双向链表实现(在jdk1.6及以前,是一个循环...

Java_LinkedList工作原理

Doubly-linked list implementation of the List and Deque interfaces. Implements all optional list o...

Java中LinkedList原理解析

一句话概括,Java中的LinkedList其实就是使用了一个双向链表 上面可以清晰的看出,链表中每个元素对应一个节点,节点里面包含三部分,一个是前一个节点的引用,一个是元素内容,一个是后一个...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java LinkedList 实现原理
举报原因:
原因补充:

(最多只允许输入30个字)