当前位置: > 教程 > 编程教程 >

面试必会之LinkedList源码分析
栏目分类:编程教程   发布日期:2019-12-08   浏览次数:

作者:小知来源:https://www.javazhiyin.com/31249.html 注:本文所有方法和示例基于jdk1.8 概述 LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列,它是基于双向链表实现的,是线程不安全的,允许元素为null的双向链表。 源码分析 1. 变
作者:小知
来源:https://www.javazhiyin.com/31249.html

注:本文所有方法和示例基于jdk1.8

概述

LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列,它是基于双向链表实现的,是线程不安全的,允许元素为null的双向链表。

面试必会之LinkedList源码分析

源码分析

1. 变量

/**
 * 集合元素数量
 **/
transient int size = 0;
/**
 * 指向第一个节点的指针
 * Invariant: (first == null && last == null) ||
 * (first.prev == null && first.item != null)
 */
transient Node<E> first;
/**
 * 指向最后一个节点的指针
 * Invariant: (first == null && last == null) ||
 * (last.next == null && last.item != null)
 */
transient Node<E> last;

2. 构造方法

/**
 * 无参构造方法
 */
public LinkedList() {
}
/**
 * 将集合c所有元素插入链表中
 */
public LinkedList(Collection<? extends E> c) {
 this();
 addAll(c);
}

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

因为一个Node既有prev也有next,所以证明它是一个双向链表。

4. 添加元素

addAll(Collection c)

将集合c添加到链表,如果不传index,则默认是添加到尾部。如果调用addAll(int index, Collection<? extends E> c)方法,则添加到index后面。

面试必会之LinkedList源码分析

面试必会之LinkedList源码分析

面试必会之LinkedList源码分析

假设我们要在index=2处添加{1,2}到链表中,图解如下:

第一步:拿到index=2的前驱节点 prev=ele1

第二步:遍历集合prev.next=newNode,并实时更新prev节点以便下一次

遍历:prev=newNode

第三步:将index=2的节点ele2接上:prev.next=ele2,ele2.prev=prev

面试必会之LinkedList源码分析

注意node(index)方法:寻找处于index的节点,有一个小优化,结点在前半段则从头开始遍历,在后半段则从尾开始遍历,这样就保证了只需要遍历最多一半结点就可以找到指定索引的结点。

addFirst(E e)方法

将e元素添加到链表并设置其为头节点(first)。

public void addFirst(E e) {
 linkFirst(e);
}
//将e链接成列表的第一个元素
private void linkFirst(E e) {
 final Node<E> f = first;
 // 前驱为空,值为e,后继为f
 final Node<E> newNode = new Node<>(null, e, f);
 first = newNode;
 //若f为空,则表明列表中还没有元素,last也应该指向newNode
 if (f == null)
 last = newNode;
 else
 //否则,前first的前驱指向newNode
 f.prev = newNode;
 size++;
 modCount++;
}


  1. 拿到first节点命名为f
  2. 新创建一个节点newNode设置其next节点为f节点
  3. 将newNode赋值给first
  4. 若f为空,则表明列表中还没有元素,last也应该指向newNode;否则,前first的前驱指向newNode。
  5. 图解如下:


面试必会之LinkedList源码分析


面试必会之LinkedList源码分析

addLast(E e)方法

将e元素添加到链表并设置其为尾节点(last)。

public void addLast(E e) {
 linkLast(e);
}
/**
 * 将e链接成列表的last元素
 */
void linkLast(E e) {
 final Node<E> l = last;
 // 前驱为前last,值为e,后继为null
 final Node<E> newNode = new Node<>(l, e, null);
 last = newNode;
 //最后一个节点为空,说明列表中无元素
 if (l == null)
 //first同样指向此节点
 first = newNode;
 else
 //否则,前last的后继指向当前节点
 l.next = newNode;
 size++;
 modCount++;
}

过程与linkFirst()方法类似,这里略过。

add(E e)方法

在尾部追加元素e。

public boolean add(E e) {
 linkLast(e);
 return true;
}
void linkLast(E e) {
 final Node<E> l = last;
 // 前驱为前last,值为e,后继为null
 final Node<E> newNode = new Node<>(l, e, null);
 last = newNode;
 //最后一个节点为空,说明列表中无元素
 if (l == null)
 //first同样指向此节点
 first = newNode;
 else
 //否则,前last的后继指向当前节点
 l.next = newNode;
 size++;
 modCount++;
}

add(int index, E element)方法

在链表的index处添加元素element.

public void add(int index, E element) {
 checkPositionIndex(index);
 if (index == size)
 linkLast(element);
 else
 linkBefore(element, node(index));
}
/**
 * 在succ节点前增加元素e(succ不能为空)
 */
void linkBefore(E e, Node<E> succ) {
 // assert succ != null;
 // 拿到succ的前驱
 final Node<E> pred = succ.prev;
 // 新new节点:前驱为pred,值为e,后继为succ
 final Node<E> newNode = new Node<>(pred, e, succ);
 // 将succ的前驱指向当前节点
 succ.prev = newNode;
 // pred为空,说明此时succ为首节点
 if (pred == null)
 // 指向当前节点
 first = newNode;
 else
 // 否则,将succ之前的前驱的后继指向当前节点
 pred.next = newNode;
 size++;
 modCount++;
}

linkLast方法上文有讲。

linkBefore(E e, Node<E> succ)方法步骤:

  1. 拿到succ的前驱节点
  2. 新new节点:前驱为pred,值为e,后继为succ : Node<>(pred, e, succ);
  3. 将succ的前驱指向当前节点
  4. pred为空,说明此时succ为首节点,first指向当前节点;否则,将succ之前的前驱的后继指向当前节点

5. 获取/查询元素

get(int index)方法

根据索引获取链表中的元素。

public E get(int index) {
 checkElementIndex(index);
 return node(index).item;
}
// 检测index合法性
private void checkElementIndex(int index) {
 if (!isElementIndex(index))
 throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// 根据index 获取元素
Node<E> node(int index) {
 // assert isElementIndex(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;
 }
}

node方法上文有详细讲解,这里不做介绍。

getFirst()方法

获取头节点。

public E getFirst() {
 final Node<E> f = first;
 if (f == null)
 throw new NoSuchElementException();
 return f.item;
}

getLast()方法

获取尾节点。

public E getLast() {
 final Node<E> l = last;
 if (l == null)
 throw new NoSuchElementException();
 return l.item;
}

6. 删除元素

remove(Object o)

根据Object对象删除元素。

面试必会之LinkedList源码分析

面试必会之LinkedList源码分析

  1. 遍历链表查找 item==null 并执行unlink(x)方法删除
  2. 如果前驱为null,说明x为首节点,first指向x的后继,x的前驱的后继指向x的后继,即略过了x.
  3. 如果后继为null,说明x为尾节点,last指向x的前驱;否则x的后继的前驱指向x的前驱,即略过了x,置空x.next
  4. 引用置空:x.item = null
  5. 图解:


面试必会之LinkedList源码分析

remove(int index)方法

根据链表的索引删除元素。

public E remove(int index) {
 checkElementIndex(index);
 //node(index)会返回index对应的元素
 return unlink(node(index));
}
E unlink(Node<E> x) 方法上文有详解。

removeFirst()方法

删除头节点。

public E removeFirst() {
 final Node<E> f = first;
 if (f == null)
 throw new NoSuchElementException();
 return unlinkFirst(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指向前first的后继,也就是列表中的2号位
 first = next;
 //如果此时2号位为空,那么列表中此时已无节点
 if (next == null)
 //last指向null
 last = null;
 else
 // 首节点无前驱 
 next.prev = null;
 size--;
 modCount++;
 return element;
}

原理与添加头节点类似。

removeLast()方法

删除尾节点(last)

public E removeLast() {
 final Node<E> l = last;
 if (l == null)
 throw new NoSuchElementException();
 return unlinkLast(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指向前last的前驱,也就是列表中的倒数2号位
 last = prev;
 // 如果此时倒数2号位为空,那么列表中已无节点
 if (prev == null)
 // first指向null
 first = null;
 else
 // 尾节点无后继
 prev.next = null;
 size--;
 modCount++;
 // 返回尾节点保存的元素值
 return element;
}

7. 修改元素

修改元素比较简单,先找到index对应节点,然后对值进行修改。

public E set(int index, E element) {
 checkElementIndex(index);
 // 获取到需要修改元素的节点
 Node<E> x = node(index);
 // 保存之前的值
 E oldVal = x.item;
 // 执行修改
 x.item = element;
 // 返回旧值
 return oldVal;
}

8. 与ArrayList的对比

优点:

  1. 不需要扩容和预留空间,空间效率高
  2. 增删效率高

缺点:

  1. 随机访问时间效率低
  2. 改查效率低

扩展阅读

ArrayList,LinkedList和String

ArrayList VS LinkedList VS Vector

Java基础—基于JDK1.8的LinkedList源码分析

Java HashMap源码学习

AbstractQueuedSynchronizer源码分析之概要分析

宇宙第二IDE——使用IDEA快捷键阅读源码

相关热词:

js特效 教程 资源 资讯