LinkedList源码分析

最新推荐文章于 2024-07-05 17:30:16 发布
最新推荐文章于 2024-07-05 17:30:16 发布
阅读量152 收藏 1
点赞数
分类专栏： java 文章标签： java LinkedList
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_32600929/article/details/84000630
版权

LinkedList源码分析

1.总体概览

LinkedList的继承体系：
在这里插入图片描述

2.属性分析

LinkedList总共有三个属性：

transient int size = 0;

transient Node<E> first;

transient Node<E> last;
  • size:即是LinkedList的大小
  • Node first：即是LinkedList的第一个节点
  • Node last：即是LinkedList的最后一个节点

这里看一下Node这个类。熟悉C或者C++的人对Node这个名词一定不陌生，和C/C++语言中的Node一样，LinkedList中的Node中，也包括两个Node，一个指向前一个Node，一个指向下一个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.方法分析

  1. 构造一个空的LinkedList
public LinkedList() {
}
  1. 构造一个包含指定集合的LinkedList，并且是按照集合的迭代器顺序的
    主要调用public boolean addAll(int index, Collection<? extends E> c){}方法在指定的位置index开始添加元素
  • 首先对下标index进行检查，如果指定的位置不正确，抛出异常
  • 将指定集合转为数组，对数组的长队进行判断，如果为零则返回false，表示添加失败
  • 定义一个前节点pred，一个后节点succ
  • 如果下标index等于LinkedList的长度，代表是从链表末尾开始添加，后节点succ为空，前节点pred是链表最后一个节点；否则后节点succ是一个新的节点，前节点pred是后节点succ的前一个节点
  • 遍历数组，将数组中的每个元素构造成一个新节点newNode，newNode的前一个节点是pred，后一个节点是null。如果pred是空，则新节点newNode是链表第一个节点first，否则将新节点newNode添加到pred后面。每次循环结束，新节点newNode称为前节点pred，进行下一个的节点添加
  • 循环结束后，如果后节点succ为空，则前节点pred是尾节点last；否则将后节点succ添加到前节点pred末尾
  • 将数组长度增加到链表长度
public LinkedList(Collection<? extends E> c) {
	this();
	addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
	return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
	checkPositionIndex(index);

	Object[] a = c.toArray();
	int numNew = a.length;
	if (numNew == 0)
		return false;

	Node<E> pred, succ;
	if (index == size) {
		succ = null;
		pred = last;
	} else {
		succ = node(index);
		pred = succ.prev;
	}

	for (Object o : a) {
		@SuppressWarnings("unchecked") E e = (E) o;
		Node<E> newNode = new Node<>(pred, e, null);
		if (pred == null)
			first = newNode;
		else
			pred.next = newNode;
		pred = newNode;
	}

	if (succ == null) {
		last = pred;
	} else {
		pred.next = succ;
		succ.prev = pred;
	}

	size += numNew;
	modCount++;
	return true;
}
private void checkPositionIndex(int index) {
	if (!isPositionIndex(index))
		throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
	return index >= 0 && index <= size;
}

3.移除第一个节点
首先进行检查，如果第一个节点已经是空，则抛出异常。然后调用private E unlinkFirst(Node f){}方法移除第一个节点

  • 获取第一个节点first的值item和下一个节点next的引用
  • 将第一个节点first的值和下一个节点的应用置为空，进行垃圾回收
  • 将下一个节点next设置为链表的第一个节点
  • 如果节点next为空，代表这是链表最后一个节点，将链表尾节点last置为空；否则将新的首节点的前节点引用置为空，因为这是链表第一个节点，前面没有节点
  • 将链表长度减一，返回删除节点的值item
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 = next;
	if (next == null)
		last = null;
	else
		next.prev = null;
	size--;
	modCount++;
	return element;
}
  1. 移除最后一个节点
    首先获取最后一个节点last进行判断，如果该节点已经为空则抛出异常，否则调用private E unlinkLast(Node l){}移除最后一个节点，思想和移除第一个节点大致相同
  • 获取最后一个节点last的值item和前一个节点pred的引用
  • 将最后一个节点last的值和前一个节点pred置为空，进行垃圾回收
  • 将前一个节点prev设置为链表的最后一个节点
  • 如果节点prev为空，代表这是链表最后一个节点，将链表首节点pred置为空；否则将新的尾节点的后节点引用置为空，因为这是链表最后一个节点，后面没有节点
  • 将链表长度减一，返回删除节点的值item
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 = prev;
	if (prev == null)
		first = null;
	else
		prev.next = null;
	size--;
	modCount++;
	return element;
}
  1. 在链表首增加一个节点
    调用private void linkFirst(E e){}方法在链表首增加一个节点
  • 取出链表本来的首节点first，赋值给f，构造一个包含指定元素的新节点newNode，新节点newNode的前节点引用为空，后节点的引用为f
  • 将新节点newNode赋值给first
  • 如果首节点f为空，代表原来链表为空，将新节点newNode同事赋值给尾节点last；否则将首节点f的前节点引用指向新节点newNode，将链表链在新节点newNode的后面，此时新节点newNode就成了首节点
  • 将链表长度加一
public void addFirst(E e) {
	linkFirst(e);
}
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++;
}
  1. 在链表尾增加一个节点
    调用void linkLast(E e){}方法在链表尾增加一个节点，思路和在链表首增加一个节点大致相同
  • 取出链表本来的尾节点last，赋值给l，构造一个包含指定元素的新节点newNode，新节点newNode的前节点引用为l，后节点的引用为空
  • 将新节点newNode赋值给last
  • 如果尾节点l为空，代表原来链表为空，将新节点newNode同事赋值给首节点first；否则将尾节点l的后节点引用指向新节点newNode，将链表链在新节点newNode的前面，此时新节点newNode就成了尾节点
  • 将链表长度减一
public void addLast(E e) {
	linkLast(e);         
}
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++;
}
  1. 清空链表
    遍历整个链表，去除此次遍历的节点x，将x的下一个节点复制给next，将x的前节点引用，值，后节点引用都置为null，进行垃圾回收，然后再讲next赋值给x，进行下一次的循环。最后将首尾节点都置为空，将链表长度置为0。
public void clear() {
	for (Node<E> x = first; x != null; ) {
		Node<E> next = x.next;
		x.item = null;
		x.next = null;
		x.prev = null;
		x = next;
	}
	first = last = null;
	size = 0;
	modCount++;
}
  1. 判断链表是否包含某个元素
    判断链表是否包含某个元素，也就是计算这个元素在链表中的下标，如果返回为-1，则代表链表中不含这个元素
  • 如果元素为空，遍历链表中的空值
  • 如果元素不为空，遍历链表中符合条件的值，找不到返回-1
  • 如果返回-1，代表链表中不包含这个元素，返回false
public boolean contains(Object o) {
	return indexOf(o) != -1;
}
public int indexOf(Object o) {
	int index = 0;
	if (o == null) {
		for (Node<E> x = first; x != null; x = x.next) {
			if (x.item == null)
				return index;
			index++;
		}
	} else {
		for (Node<E> x = first; x != null; x = x.next) {
			if (o.equals(x.item))
				return index;
			index++;
		}
	}
	return -1;
}
  1. 返回链表长度
    返回链表长度，即size的值
public int size() {
	return size;
}
  1. 增加一个元素
    在链表尾用void linkLast(E e){}方法增加一个节点
public boolean add(E e) {
	linkLast(e);
	return true;
}
  1. 移除一个包含指定元素的节点
    首先对改元素进行空值判断，遍历到改节点的位置，调用E unlink(Node x){}方法从链表中剔除该节点
  • 依次取出改节点的值item、前节点的引用prev、后节点的引用next
  • 如果前节点prev引用为空，那这就是首节点first，将后节点next设置为新的首节点first；否则将后节点next的引用赋值给前节点prev的后节点引用，即将后面的节点直接链接在前面节点后面，忽略这个节点，将prev置为空
  • 如果后节点next引用为空，那这就是尾节点last，将前节点的引用赋值给尾节点last；否则将前节点prev的引用赋值给后面一个节点next的前节点引用，将next置为空，忽略这个节点
  • 最后将值item设置为空，将链表长度size减一
public boolean remove(Object o) {
	if (o == null) {
		for (Node<E> x = first; x != null; x = x.next) {
			if (x.item == null) {
				unlink(x);
				return true;
			}
		}
	} else {
		for (Node<E> x = first; x != null; x = x.next) {
			if (o.equals(x.item)) {
				unlink(x);
				return true;
			}
		}
	}
	return false;
}
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;
}
  1. 返回指定下标index的节点值
    先进行下标检查，然后调用Node node(int index){}获取节点的值
  • 这里看出取值时不是从头开始遍历的，而是对链表长度一分为二，分两段遍历。前半段顺序遍历，后半段逆序遍历。因为每个节点都有前节点prev的引用，所以可以逆序遍历
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}
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;
    }
}
  1. 替换指定下标index的值
    首先对下标index进行检查，然后调用Node node(int index){}取到下标index对应的节点，将节点的值item替换为element，返回节点之前保存的值
public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}
  1. 在指定下标index处增加一个值之元素element的节点
    如果指定下标刚好等于链表的长度，则调用void linkLast(E e){}方法在链表尾增加一个节点；否则调用void linkBefore(E e, Node succ){}方法在指定下标的节点前增加一个节点
  • 先取出指定下标的节点succ的前节点pred，构造一个前节点为pred，值为element，后节点为succ的新节点newNode
  • 将指定下标的节点succ的前节点引用设置为newNode，代表将后面所有的节点都链接在新的节点newNode的后面
  • 如果前节点pred为空，代表增加的位置在链表首，将新节点newNode设置为首节点first；否则将新节点newNode赋值给指定下标的节点succ的前节点pred的后节点引用，将以新节点为首的链表链接在后面
  • 将链表长度size加一
public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}
void linkBefore(E e, Node<E> succ) {
	// assert succ != null;
	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.next = newNode;
	size++;
	modCount++;
}
  1. 移除指定下标的节点
    先进行下标的判断，然后调用E unlink(Node x){}方法从链表中剔除该节点(此方法已经前面描述过)
public E remove(int index) {
	checkElementIndex(index);
	return unlink(node(index));
}
  1. 找出链表中最后一个值为Object的下标
    逆序遍历链表，找出符合条件的下标，同样分空值和非空值进行判断
public int lastIndexOf(Object o) {
	int index = size;
	if (o == null) {
		for (Node<E> x = last; x != null; x = x.prev) {
			index--;
			if (x.item == null)
				return index;
		}
	} else {
		for (Node<E> x = last; x != null; x = x.prev) {
			index--;
			if (o.equals(x.item))
				return index;
		}
	}
	return -1;
}
  1. 取出链表首节点的值，但是并不删除
    取出第一个节点的值，如果是空则返回空，否则返回节点的值
public E peek() {
	final Node<E> f = first;
	return (f == null) ? null : f.item;
}
  1. 取出链表第一个元素的值，但是并不删除
public E element() {
	return getFirst();
}
public E getFirst() {
	final Node<E> f = first;
	if (f == null)
		throw new NoSuchElementException();
	return f.item;
}
  1. 弹出首节点
    这个方法使得链表像队列一样，弹出并删除第一个节点的值
public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
  1. 删除链表的一个节点
    调用public E removeFirst(){}方法，实际从链表首开始删除节点
public E remove() {
	return removeFirst();
}
  1. 增加一个节点
    实际调用的public boolean add(E e){}方法在链表末尾增加一个节点
public boolean offer(E e) {
	return add(e);
}
  1. 在链表首增加一个节点
    实际调用的是public void addFirst(E e){}方法
public boolean offerFirst(E e) {
	addFirst(e);
	return true;
}
  1. 在链表尾增加一个节点
    实际调用的是public void addLast(E e){}方法
public boolean offerLast(E e) {
	addLast(e);
	return true;
}
  1. 取出首节点的值
public E peekFirst() {
	final Node<E> f = first;
	return (f == null) ? null : f.item;
 }
  1. 取出尾节点的值
public E peekLast() {
	final Node<E> l = last;
	return (l == null) ? null : l.item;
}
  1. 弹出首节点的值
    取出首节点的值并删除
public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }
  1. 弹出尾节点的值
public E pollLast() {
	final Node<E> l = last;
	return (l == null) ? null : unlinkLast(l);
}
  1. 在链表首压入一个节点
    实际调用的是public void addFirst(E e){}方法
public void push(E e) {
	addFirst(e);
}
  1. 弹出链表首的节点
    实际调用的是public E removeFirst(){}方法
public E pop() {
	return removeFirst();
}
  1. 删除第一个出现的包含某个值的节点
    实际调用的是public boolean remove(Object o){}方法
public boolean removeFirstOccurrence(Object o) {
	return remove(o);
}
  1. 删除最后一次出现包含某个值的节点
    逆序遍历链表，找出符合条件的下标，同样分空值和非空值进行判断，找到则调用E unlink(Node x){}方法删除
public boolean removeLastOccurrence(Object o) {
	if (o == null) {
		for (Node<E> x = last; x != null; x = x.prev) {
			if (x.item == null) {
				unlink(x);
				return true;
			}
		}
	} else {
		for (Node<E> x = last; x != null; x = x.prev) {
			if (o.equals(x.item)) {
				unlink(x);
				return true;
			}
		}
	}
	return false;
}
  1. 链表转数组
    这是一个比较简单的方法，构造以一个数组，一次将链表中节点的值加入数组
public Object[] toArray() {
	Object[] result = new Object[size];
	int i = 0;
	for (Node<E> x = first; x != null; x = x.next)
		result[i++] = x.item;
	return result;
}
Java集合系列之LinkedList源码分析
08-27
Java集合系列之LinkedList源码分析 概述： 本文详细介绍了Java集合系列之LinkedList的源码分析，主要介绍了LinkedList的底层实现、成员变量、构造器、增删改查方法等。LinkedList是一种基于双向链表的数据结构，...
LinkedList 源码分析
努力学习，努力爱你！
09-11 673
E item;// 节点值// 指向的下一个节点（后继节点）// 指向的前一个节点（前驱结点）// 初始化参数顺序分别是：前驱结点、本身节点值、后继节点。
java-Linkedlist源码分析
最新发布
weixin_41247813的博客
07-05 784
LinkedList` 通过 `first` 和 `last` 字段分别指向链表的首节点和尾节点，这样可以高效地进行头部和尾部的插入和删除操作。如果链表为空，则新节点既是 `first` 也是 `last`。- `unlinkFirst(Node f)`：断开头部节点的链接，并返回节点中的元素。- `unlinkLast(Node l)`：断开尾部节点的链接，并返回节点中的元素。- `unlink(Node x)`：断开指定节点的链接，并返回节点中的元素。
java LinkedList 源码分析（通俗易懂)
Cyan_RA9的博客
03-16 2485
java 集合篇章——LinkedList类内容分享。包含LinkedLIst类的底层实现和源码分析。
ArrayList和LinkedList源码分析
weixin_42614150的博客
04-14 236
ArrayList:初始化时没有直接创建存储数据的数组，在第一次添加元素时，会创建长度为10的数组，当数组长度不够用时，会自动扩容，每次扩容1.5倍，对象创建时类似于单例中的懒汉式，延迟数组的创建，节省了内存空间。 //扩容方法 private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; //每次扩容1.5倍 .
linkedlist源码分析
yuruizai110的博客
11-25 543
一.继承体系 二.源码分析 添加链表元素 //获取指定索引元素 Node&amp;amp;lt;E&amp;amp;gt; node(int index){ //二分查找 if(index &amp;amp;lt; (size &amp;amp;gt;&amp;amp;gt; 1)){ //如果索引值在链表size/2之内 Node&amp;amp;lt;E&amp;amp;gt; prevN
Java LinkedList源码分析
01-20
简介 　LinkedList 是一个常用的集合类，用于顺序存储元素。 LinkedList 经常和 ArrayList 一起被提及。...本文分析 LinkedList 的具体实现。 　继承关系 　public class LinkedList 　extends AbstractS
Java 集合之LinkedList源码分析
01-20
LinkedList是通过节点的连接实现链表的数据结构，向linkedList中插入或删除元素的速度是特别快，而随机访问的速度相对较慢，这个是由于链表本身的性质造成的，在链表中，每个节点都包含了前一个节点的引用，后一个...
简述乐观锁和悲观锁
qq_32600929的博客
04-08 6943
简述乐观锁和悲观锁 乐观锁和悲观锁都是一种思想，并不是真实存在于数据库中的一种机制。 悲观锁 当认为数据被并发修改的几率比较大，需要在修改之前借助于数据库锁机制,先对数据进行加锁的思想被称为悲观锁，又称PCC(Pessimistic Concurrency Control)。在效率方面，处理锁的操作会产生了额外的开销，而且增加了死锁的机会。当一个线程在处理某行数据的时候，其它线程只能等待。 悲观锁...
接口和抽象类的区别
qq_32600929的博客
08-19 1365
抽象类和接口的区别 1.抽象类   在了解抽象类之前先了解抽象方法，抽象方法是一种特殊的方法，它只有声明，没有具体的实现，声明格式为： abstract void fun();   抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，那么这个类就是抽象类。因为抽象类含有未实现的方法，所以抽象类不能实现。所以抽象类视为了继承而存在的。如果定义了一个抽...
RocketMQ事务消息原理简析
qq_32600929的博客
01-13 744
在项目中，经常遇到这样一个场景，需要保证数据持久化和消息发送要么同时成功，要么同时失败。比如当用户在交易系统下了一个订单，购物车需要消费订单消息清除加购数据、积分系统需要变更用户积分、短信平台需要给买家发送提醒等，交易系统要将订单落入DB和发送订单消息保证一致。利用RocketMQ事务消息特性，就可以达到这个目的。本文将探究RocketMQ事务消息使用方法及实现原理
HashSet、LinkedHashSet源码解析
qq_32600929的博客
11-29 452
HashSet、LinkedHashSet源码解析 HashMap的底层结构是HashMap,所以很多方法也是调用Map的方法来实现的。LinkedHashSet是HashSet的子类，只是它的底层结构是LinkedHashMap，它的大部分方法也是调用父类HashSet实现的 1.总体概览 HashSet的继承体系： LinkedHashSet的继承体系： 2.属性分析 private tr...
简述正向代理和反向代理
qq_32600929的博客
03-02 380
正向代理和反向代理 正向代理 是一个位于客户端和目标服务器之间的服务器(代理服务器)，为了从目标服务器取得内容，客户端向代理服务器发送一个请求并指定目标，然后代理服务器向目标服务器转交请求并将获得的内容返回给客户端。比如科学上网。 正向代理是代理服务器代理了客户端，和目标服务器进行交互。目标服务器不知道真正的客户端是谁。 正向代理可以突破访问的限制，比如科学上网。 正向代理可以通过代理服务器的缓...
Session和Cookie
qq_32600929的博客
12-25 199
Session和Cookie 关于网络编程中的会话，维基百科是这样解释的： 在计算机科学领域来说，尤其是在网络领域，会话（session）是一种持久网络协议，在用户（或用户代理）端和服务器端之间创建关联，从而起到交换数据包的作用机制，session在网络协议（例如telnet或FTP）中是非常重要的部分。 在不包含会话层（例如UDP）或者是无法长时间驻留会话层（例如HTTP）的传输协议中，会话的...
深入理解JVM(一)：运行时数据区
qq_32600929的博客
10-31 186
深入理解JVM(一)：运行时数据区 运行时数据区 JVM在执行java程序的过程中，会把内存分为几个不同的数据区域，如上图所示。 程序计数器 虽然图片中程序计数器所占的面积比较大，但实际上程序计数器所占的内存非常小，也是唯一一块在所有JVM中都没有规定OOM的区域。它的作用是当前线程所执行的字节码的行号指示器、字节码行号的记录器。 在JVM的概念模型中，字节码解释器就是通过读取和改变这个计数器的...
Lambda表达式初探
qq_32600929的博客
11-10 167
Lambda表达式初探 Lambda表达式是java8的重要更新，是被广大开发者期待已久的新特性。使用Lambda表达式可以用更简洁的代码来创建函数式接口的实例。 lambda表达式的类型，也被称为目标类型，Lambda表达式的目标类型必须是函数式接口。函数式接口代表只包含一个抽象方法的接口，函数式接口可以包含多个默认方法、类方法、但只能声明一个抽象方法。使用@FunctionalInterfac...
equals()和hashCode()
qq_32600929的博客
10-02 152
equals()和hashCode() String中的equals()和hashCode() equals(): 1.首先比较两个对象的引用，若引用相同，则返回true 2.判断anObject是否是String类型，如果是，将两个字符串转为字节数组逐字节进行比对，始终相同返回true，有一个字节不同返回false 3.返回false public boolean equals(Object a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值