LinkedList 源码分析

2019年3月11日 275次阅读 来源: java集合源码分析

LinkedList介绍

JangGwa带你再熟悉一下LinkedList，首先简单介绍下LinkedList。

1.基于双向链表实现，链表无容量限制。

2.LinkedList是非线程安全的。

3.实现了List接口，实现了get(int location)、remove(int location)等根据索引值来获取、删除节点的函数。

4.实现了Deque接口，可以将LinkedList当做双端队列使用。

5.实现了Cloneable接口，能被克隆。

6.实现了Serializable接口，支持序列化。

LinkedList源码解析

LinkedList继承了AbstractSequentialList并实现了List,Deque, Cloneable, java.io.Serializable 接口，上面做了相应的介绍就不再阐述了。关键我们看两个重要的属性header和size。

header:双向链表的表头，它是双向链表节点所对应的类Entry的实例。Entry中包含成员变量： previous, next, element。其中，previous是该节点的上一个节点，next是该节点的下一个节点，element是该节点所包含的值。

size:双向链表中节点的个数

public class LinkedList
    
      extends AbstractSequentialList
     
       implements List
      
       , Deque
       
        , Cloneable, java.io.Serializable { // 链表的表头，表头不包含任何数据。Entry是个链表类数据结构。 private transient Entry
        
          header = new Entry
         
          (null, null, null); // LinkedList中元素个数 private transient int size = 0; // 默认构造函数：创建一个空的链表 public LinkedList() { header.next = header.previous = header; } // 包含“集合”的构造函数:创建一个包含“集合”的LinkedList public LinkedList(Collection
           c) { this(); addAll(c); }

双向链表的节点所对应的数据结构。

private static class Entry
    
      { // 当前节点所包含的值 E element; // 下一个节点 Entry
     
       next; // 上一个节点 Entry
      
        previous; Entry(E element, Entry
       
         next, Entry
        
          previous) { this.element = element; this.next = next; this.previous = previous; } }

获取链表指定位置节点

将index与长度size的一半比较，如果index size/2，就只从位置size往前遍历到位置index处。

private Entry
    
      entry(int index) { if (index < 0 || index >= size) throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size); Entry
     
       e = header; // 获取index处的节点。 // 若index < 双向链表长度的1/2,则从前先后查找; // 否则，从后向前查找。 if (index < (size >> 1)) { for (int i = 0; i <= index;="" i++)="" e="e.next;" }="" else="" {="" for="" (int="" i="size;"> index; i--) e = e.previous; } return e; }

get()和set()

 // 返回LinkedList指定位置的元素
public E get(int index) {
    return entry(index).element;
}

// 设置index位置对应的节点的值为element
public E set(int index, E element) {
    Entry
    
      e = entry(index); E oldVal = e.element; e.element = element; return oldVal; }
    
// 将e添加到当前节点的前面
    public void add(E e) {
        checkForComodification();
        lastReturned = header;
        addBefore(e, next);
        nextIndex++;
        expectedModCount++;
    }

// 将元素添加到LinkedList的起始位置
public void addFirst(E e) {
    addBefore(e, header.next);
}

// 将元素添加到LinkedList的结束位置
public void addLast(E e) {
    addBefore(e, header);
}

// 将元素(E)添加到LinkedList中
public boolean add(E e) {
    // 将节点(节点数据是e)添加到表头(header)之前。
    // 即，将节点添加到双向链表的末端。
    addBefore(e, header);
    return true;
}
// 从LinkedList中删除元素(o)
public boolean remove(Object o) {
    if (o==null) {
        // 若o为null的删除情况
        for (Entry
    
      e = header.next; e != header; e = e.next) { if (e.element==null) { remove(e); return true; } } } else { // 若o不为null的删除情况 for (Entry
     
       e = header.next; e != header; e = e.next) { if (o.equals(e.element)) { remove(e); return true; } } } return false; } // 将节点从链表中删除 private E remove(Entry
      
        e) { if (e == header) throw new NoSuchElementException(); E result = e.element; e.previous.next = e.next; e.next.previous = e.previous; e.next = e.previous = null; e.element = null; size--; modCount++; return result; }

清空LinkedList

// 清空双向链表
public void clear() {
    Entry
    
      e = header.next; // 从表头开始，逐个向后遍历；对遍历到的节点执行一下操作： // (01) 设置前一个节点为null // (02) 设置当前节点的内容为null // (03) 设置后一个节点为“新的当前节点” while (e != header) { Entry
     
       next = e.next; e.next = e.previous = null; e.element = null; e = next; } header.next = header.previous = header; // 设置大小为0 size = 0; modCount++; }
     
    
public Object clone() {
    LinkedList
    
      clone = null; // 克隆一个LinkedList克隆对象 try { clone = (LinkedList
     
      ) super.clone(); } catch (CloneNotSupportedException e) { throw new InternalError(); } // 新建LinkedList表头节点 clone.header = new Entry
      
       (null, null, null); clone.header.next = clone.header.previous = clone.header; clone.size = 0; clone.modCount = 0; // 将链表中所有节点的数据都添加到克隆对象中 for (Entry
       
         e = header.next; e != header; e = e.next) clone.add(e.element); return clone; }

总结

  • LinkedList的实现是基于双向循环链表的。有一个重要的内部类:Entry，是双向链表节点所对应的数据结构。
  • 不存在容量不足的问题。
  • LinkedList是基于链表实现的，因此插入删除效率高，查找效率低。
  • LinkedList的克隆函数，即是将全部元素克隆到一个新的LinkedList对象中。
  • LinkedList实现java.io.Serializable。当写入到输出流时，先写入“容量”，再依次写入“每一个节点保护的值”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。
    原文作者：java集合源码分析
    原文地址: https://juejin.im/entry/57c945c32e958a0068cefb27
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞