jdk源码剖析之LinkedList
2017-04-20 11:48
615 查看
LinkedList的实现原理
LinkedList底层是通过双向链表实现的,在LinkedList中定义了一个Node内部类,其内部结构如下:
其包含一个prev和一个next分别指向上一个节点和下一个节点。在LinkedList定义如下:
linkFirst:
1.创建新的节点指向原first
2.并置当前节点为first
linkLast:
1.原last节点的next节点指向我们的newNode
2.置newNode为新的last节点
unlinkFirst:
1.当前first节点置为null,方便gc时回收。
2.修改first节点next节点的prev为null。
3.当前first节点修改为first的next节点。
unlinkLast:
1.当前last节点置为null,方便gc回收。
2.当前last节点的prev节点的next置为null。
3.当前last修改为原last节点的prev节点。
unlink:
LinkedList底层是通过双向链表实现的,在LinkedList中定义了一个Node内部类,其内部结构如下:
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; } }
其包含一个prev和一个next分别指向上一个节点和下一个节点。在LinkedList定义如下:
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable { transient int size = 0; /** * Pointer to first node. * Invariant: (first == null && last == null) || * (first.prev == null && first.item != null) */ transient Node<E> first; /** * Pointer to last node. * Invariant: (first == null && last == null) || * (last.next == null && last.item != null) */ transient Node<E> last; /** * The number of times this list has been <i>structurally modified</i>. * Structural modifications are those that change the size of the * list, or otherwise perturb it in such a fashion that iterations in * progress may yield incorrect results. * * <p>This field is used by the iterator and list iterator implementation * returned by the {@code iterator} and {@code listIterator} methods. * If the value of this field changes unexpectedly, the iterator (or list * iterator) will throw a {@code ConcurrentModificationException} in * response to the {@code next}, {@code remove}, {@code previous}, * {@code set} or {@code add} operations. This provides * <i>fail-fast</i> behavior, rather than non-deterministic behavior in * the face of concurrent modification during iteration. * * <p><b>Use of this field by subclasses is optional.</b> If a subclass * wishes to provide fail-fast iterators (and list iterators), then it * merely has to increment this field in its {@code add(int, E)} and * {@code remove(int)} methods (and any other methods that it overrides * that result in structural modifications to the list). A single call to * {@code add(int, E)} or {@code remove(int)} must add no more than * one to this field, or the iterators (and list iterators) will throw * bogus {@code ConcurrentModificationExceptions}. If an implementation * does not wish to provide fail-fast iterators, this field may be * ignored. */ protected transient int modCount = 0; }包含first、last、size和modCount。其中的核心方法包括:
linkFirst:
1.创建新的节点指向原first
2.并置当前节点为first
/** * Links e as first element. */ private void linkFirst(E e) { final Node<E> f = first; final Node<E> newNode = new Node<>(null, e, f); first = newNode; if (f == null) last = newNode; else f.prev = newNode; size++; modCount++; }
linkLast:
1.原last节点的next节点指向我们的newNode
2.置newNode为新的last节点
/** * Links e as last element. */ void linkLast(E e) { final Node<E> l = last; final Node<E> newNode = new Node<>(l, e, null); last = newNode; if (l == null) first = newNode; else l.next = newNode; size++; modCount++; }
unlinkFirst:
1.当前first节点置为null,方便gc时回收。
2.修改first节点next节点的prev为null。
3.当前first节点修改为first的next节点。
/** * Unlinks non-null first node f. */ private E unlinkFirst(Node<E> f) { // assert f == first && f != null; final E element = f.item; final Node<E> next = f.next; f.item = null; f.next = null; // help GC first = next; if (next == null) last = null; else next.prev = null; size--; modCount++; return element; }
unlinkLast:
1.当前last节点置为null,方便gc回收。
2.当前last节点的prev节点的next置为null。
3.当前last修改为原last节点的prev节点。
/** * Unlinks non-null last node l. */ private E unlinkLast(Node<E> l) { // assert l == last && l != null; final E element = l.item; final Node<E> prev = l.prev; l.item = null; l.prev = null; // help GC last = prev; if (prev == null) first = null; else prev.next = null; size--; modCount++; return element; }
unlink:
/** * Unlinks non-null node x. */ E unlink(Node<E> x) { // assert x != null; final E element = x.item; final Node<E> next = x.next; final Node<E> prev = x.prev; if (prev == null) { first = next; } else { prev.next = next; x.prev = null; } if (next == null) { last = prev; } else { next.prev = prev; x.next = null; } x.item = null; size--; modCount++; return element; }
相关文章推荐
- LinkedList源码剖析(JDK6)
- 【Java集合源码剖析】LinkedList源码剖析
- JDK源码阅读LinkedList
- LinkedList源码分析(基于JDK1.6)
- Java Collections Framework之Deque(LinkedList实现)源码分析(基于JDK1.6)(已补充)
- Java Collections Framework之Queue(LinkedList实现)源码分析(基于JDK1.6)
- jdk集合源码之LinkedList
- 【Java集合源码剖析】LinkedList源码剖析
- jdk源码分析之LinkedList
- Java之LinkedList源码解读(JDK 1.8)
- LinkedList源码剖析
- 【java集合框架源码剖析系列】java源码剖析之LinkedList
- 基于JDK1.8的LinkedList源码学习笔记
- Java之LinkedList源码解读(JDK 1.8)
- 【Java集合源码剖析】LinkedList源码剖析
- Java类集框架之LinkedList源码剖析
- 【集合框架】JDK1.8源码分析之LinkedList(七)
- JDK源码阅读——ArrayList\LinkedList
- Java Collections Framework之LinkedList源码分析(基于JDK1.6)
- Java LinkedList源码剖析