集合源码解析：LinkedList的底层实现原理

jdk7.0源码解析LinkedList底层实现原理

---

一、LinkedList的概述

LinkedList是List接口的实现类，底层用双向链表实现，有序、有下标、元素可以重复；线程不安全，因为底层方法为非同步。

二、LinkedList的存储结构

底层通过双向链表来实现，链表的每一个节点为Node，除了自身的数据域之外，还有一个前指针(prev)和后指针(next)，分别指向前驱节点和后续节点(没有就为null)。同时双向链表还有一个first指针指向头结点，和 last指针指向尾节点，实现结构如下：

三、LinkedList内部实现原理机制(源码解析)

1. LinkedList的基本元素

   public class LinkedList<E>
       extends AbstractSequentialList<E>
       implements List<E>, Deque<E>, Cloneable, 
                  java.io.Serializable
   {
         
         
   	// 记录集合中元素的个数
       transient int size = 0;
       
   	// 指向头结点
       transient Node<E> first;
       
       //指向尾节点
       transient Node<E> last;
   

2. 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;
       }
   }
   

3. LinkedList中的构造方法：

   // 无参数的构造方法 
   public LinkedList() {
         
          }
   
   /* 将Collection类型的集合作为参数构建LinkedList
      同时将Collection集合中的所有元素存储在构建的
      LinkedList集合中，调用addAll方法
   */
   public LinkedList(Collection<? extends E> c) {
         
         
       this();
       addAll(c);
   }
   

4. LinkedList中添加：add方法的实现

   对于链表数据结构，往链表结构中添加元素的操作无非是在表头添加元素或是尾部添加元素，再或者是添加在指定位置上。由于LinkedList有头指针和尾指针，所以在链表头和链 表尾部进行添加时，效率较高，但是如果添加在指定位置上，则需要先对链表进行遍历， 所以相对效率低。

   a. 在表头添加元素：addFirst(E e)

   

   

   扫描二维码关注公众号，回复： 12198535 查看本文章

   // 在链表头部添加元素
   public void addFirst(E e) {
         
         
       linkFirst(e);
   }
   private void linkFirst(E e) {
         
         
       // f 指向头节点
       final Node<E> f = first;
       /* 新建 一个节点，以前一个节点为null
          e为节点的数据，f作为新节点的下一个节点
       */
       final Node<E> newNode = new Node<>(null, e, f);
       // 头指针指向新节点
       first = newNode;
       // 如果头指针为null，代表创建的是第一个节点
       if (f == null)
           //如果新创建为第一个结点 ， 尾指针指向新节点
           last = newNode;
       else
           //如果新建的不是第一个节点，则原有头结点的前一个为 新建节点
           f.prev = newNode;
       size++; // 元素个数加1
       modCount++; // 对集合操作的次数加1
   }
   

   b. 在表尾添加元素：addLast(E e)

   

   

   // 在链表尾部添加元素
   public void addLast(E e) {
         
         
       linkLast(e);
   }
   void linkLast(E e) {
         
         
       // l 指向尾节点 
       final Node<E> l = last;
       /*新建一个节点：以原有的尾节点作为新节点的头节点
         e为新节点的存储元素，null为新节点的下一个节点
       */
       final Node<E> newNode = new Node<>(l, e, null);
       //尾节点 指向新建节点 
       last = newNode;
       // 判断新创建的节点是否为 第一个节点
       if (l == null)
           //如果新创建的节点为第一个节点，则头节点指向新节点
           first = newNode;
       else
           // 如果新建的节点不是第一个节点，则原有尾节点的下一个节点为新节点
           l.next = newNode;
       size++;
       modCount++;
   }
   

   c. 在指定位置存储元素：list.add(int index, E element)

   

   //将元素存储在指定下标位置上
   public void add(int index, E element) {
         
         
       // 检测指定下标是否在 0~size之间
       checkPositionIndex(index);
   	//如果指定下标为size,代表存储在尾部
       if (index == size)
           linkLast(element);
       else
           //插入到指定下标位置上 
           linkBefore(element, node(index));
   }
   //根据下标获取对应位置的节点
   Node<E> node(int index) {
         
         
       /*
       	采用的二分法查找的思想，如果下标 <长度的一半，
           则从0下标进行遍历查找(从往后查找)，
           否则从往前进行查找，将查找的节点作为返回值返回
       */
   
       if (index < (size >> 1)) {
         
         
           Node<E> x = first;
           for (int i = 0; i < index; i++)
               x = x.next;
           return x;
       } else {
         
         
           Node<E> x = last;
           for (int i = size - 1; i > index; i--)
               x = x.prev;
           return x;
       }
   }
   void linkBefore(E e, Node<E> succ) {
         
         
       // 获取下标对应的 前节点
       final Node<E> pred = succ.prev;
       /* 创建新的节点， 以下标对应位置的前节点最为新节点的前节点
          同时将 下标位置对应的节点作为新节点的下一个节点
       */
       final Node<E> newNode = new Node<>(pred, e, succ);
       // 新节点 作为 下标对应节点的前节点
       succ.prev = newNode;
       // 判断下标对应的节点是否为头结点
       if (pred == null)
           // 下标对应的是头结点，则 头指针 指向新 节点
           first = newNode;
       else
           /* 下标对应的节点不是头结点，则新节点 pred的下一个节点
              备注：pred 代表下标对应节点的前一个节点
           */
           pred.next = newNode;
       size++;
       modCount++;
   }
   

   d. 添加方法：add(E e)

   // 往LinkedList中添加元素，默认往链表的尾部添加
   public boolean add(E e) {
         
         
       linkLast(e);
       return true;
   }
   

5. LinkedList中删除方法：remove

   

   //根据指定的下标删除对应的元素
   public E remove(int index) {
         
         
       // 检测下标是否在: 0 ~ size-1
       checkElementIndex(index);
       // 调用node方法获取下标对应的节点，并调用unlink方法删除
       return unlink(node(index));
   }
   // 删除节点
   E unlink(Node<E> x) {
         
         
       //获取被删除节点的元素，最后作为返回值返回
       final E element = x.item;
       //记录被删除节点的下一个节点
       final Node<E> next = x.next;
       //记录被删除出节点的上一个节点
       final Node<E> prev = x.prev;
   	//如果前一个节点为null,代表被删除的节点为头结点
       if (prev == null) {
         
         
           //头指针指向 被删除节点的下一个节点
           first = next;
       } else {
         
         
           /*
              如果删除的不是头结点，则被删除的节点的前一个
              节点的 next 指向被删除节点的下一个节点
           */
           prev.next = next;
           // 被删除节点的前节点置 null
           x.prev = null;
       }
   	// 如果删除的为为节点
       if (next == null) {
         
         
           // 尾指针指向被删除节点的前一个节点
           last = prev;
       } else {
         
         
           /* 如果被删除的节点不是尾节点,则被删除节点的前一个
              的next指向 而被删除节点的 下一个节点
           */
           next.prev = prev;
           //被删除节点的下一个节点置null
           x.next = null;
       }
    	// 被删除节点的元素置 null
       x.item = null;
       // 元素个数 减 1
       size--;
       modCount++;//对集合元素的改变次数加1
       return element;// 被删除的元素作为返回值返回
   }
   

6. LinkedList中查询方法：get(int index)

   //根据下标获取对应节点元素
   public E get(int index) {
         
         
       // 检测下标的有效性
       checkElementIndex(index);
       // 获取下标对应的节点
       return node(index).item;
   }
   // 获取下标对应 的节点(前面介绍过)
   Node<E> node(int index) {
         
         
       
   
       if (index < (size >> 1)) {
         
         
           Node<E> x = first;
           for (int i = 0; i < index; i++)
               x = x.next;
           return x;
       } else {
         
         
           Node<E> x = last;
           for (int i = size - 1; i > index; i--)
               x = x.prev;
           return x;
       }
   }
   

四、总结

LinkedList底层用双向链表实现，具有头指针和尾指针，可以快速的对头节点和尾节点进行操作，链表相对于数组而言，添加和删除效率要高，但是查询效率较低。