LinkedList源码分析--jdk1.8
JDK1.8
ArrayList源码分析--jdk1.8
LinkedList源码分析--jdk1.8
HashMap源码分析--jdk1.8
AQS源码分析--jdk1.8
ReentrantLock源码分析--jdk1.8
创新互联主要从事成都做网站、网站建设、网页设计、企业做网站、公司建网站等业务。立足成都服务柘荣,十多年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18980820575
LinkedList概述
1.LinkedList是用双向链表实现的集合,基于内部类Node
实现的集合。
2.LinkedList支持双向链表访问、克隆、序列化,元素有序且可以重复。
3.LinkedList没有初始化大小,也没有扩容机制,通过头结点、尾节点迭代查找。
LinkedList数据结构
数据结构是集合的精华所在,数据结构往往也限制了集合的作用和侧重点,了解各种数据结构是我们分析源码的必经之路。
LinkedList的数据结构如下:
链表基础知识补充:
1)单向链表:
element:用来存放元素
next:用来指向下一个节点元素
通过每个结点的指针指向下一个结点从而链接起来的结构,最后一个节点的next指向null。
2)单向循环链表
element、next 跟前面一样
在单向链表的最后一个节点的next会指向头节点,而不是指向null,这样存成一个环
3)双向链表
element:存放元素
pre:用来指向前一个元素
next:指向后一个元素
双向链表是包含两个指针的,pre指向前一个节点,next指向后一个节点,但是第一个节点head的pre指向null,最后一个节点的tail指向null。
4)双向循环链表
element、pre、next 跟前面的一样
第一个节点的pre指向最后一个节点,最后一个节点的next指向第一个节点,也形成一个“环”。
LinkedList源码分析
/**
* LinkedList 使用 iterator迭代器更加 快速
* 用链表实现的集合,元素有序且可以重复
* 双向链表
*/
public class LinkedList
extends AbstractSequentialList
implements List, Deque, Cloneable, java.io.Serializable
{
/**
* 实际元素个数
*/
transient int size = 0;
/**
* 头结点
*/
transient Node first;
/**
* 尾结点
*/
transient Node last;
/**
* 无参构造方法.
*/
public LinkedList() {
}
/**
* 集合参数构造方法
*/
public LinkedList(Collection extends E> c) {
this();
addAll(c);
}
/**
* 内部类Node
*/
private static class Node {
E item; // 数据域
Node next; // 下一个
Node prev; // 上一个
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
LinkedList继承和实现分析
LinkedList extends AbstractSequentialList
AbstractSequentialList extends AbstractList
AbstractList extends AbstractCollection
java中所有类都继承Object,所以LinkedList的继承结构如上图。
1. AbstractSequentialList是一个抽象类,继承了AbstractList接口,AbstractList抽象类中可以有抽象方法,还可以有具体的实现方法,AbstractList实现接口中一些通用的方法,AbstractSequentialList再继承AbstractList,拿到通用基础的方法,然后自己在重写实现基于链表的方法:add/addAll/get/iterator/listIterator/remove/set,这样的好处是:让代码更简洁,AbstractList随机存取功能基类,AbstractSequentialList链表存取功能基类,父类抽象,子类个性,父类一般是抽象类,由子类来实现丰富。
2.LinkedList实现了List、Deque 、Cloneable、Serializable接口。
1)List接口,集合通用操作方法定义。
2)Deque接口,双向队列,在Queue单项队列的基础上增加为双向队列,提高查询/操作效率
3)Cloneable接口,可以使用Object.Clone()方法。
4)Serializable接口,序列化接口,表明该类可以被序列化,什么是序列化?简单的说,就是能够从类变成字节流传输,反序列化,就是从字节流变成原来的类
LinkedList核心方法分析
1. add方法(7种重载实现)--增
LinkedList中特有的新增方法
Deque中要实现的新增方法
1)add(E);//默认直接在末尾添加元素
/**
* 新增元素
*/
public boolean add(E e) {
// 添加到末尾
linkLast(e);
return true;
}
/**
* 链接到末尾.
*/
void linkLast(E e) {
// 保存尾结点,l为final类型,不可更改
final Node l = last;
// 新生成结点的上一个为l,下一个为null
final Node newNode = new Node<>(l, e, null);
// 重新赋值尾结点
last = newNode;
if (l == null) // 尾结点为空
first = newNode; // 赋值头结点
else
l.next = newNode; // 尾结点的下一个为新生成的结点
size++; // 大小加1
modCount++; // 结构性修改加1
}
2)add(int index, E element);//给指定下标,添加元素
/**
* 在index位置插入节点
* 1.如果index等于size,则在末尾新增元素,原因:size为实际元素个数,index为下标,所以index=size时,说明要在末尾插入元素
* 2.如果index不等于size,则根据index下标找到节点,在节点前插入元素,原因:需要占用index下标位置。
*/
public void add(int index, E element) {
//查看下标是否越界
checkPositionIndex(index);
//如果指定下标等于实际元素个数,则添加到末尾
if (index == size)
linkLast(element);
else //否则,找到index位置元素添加到index后
linkBefore(element, node(index));
}
/**
* 判断下标是否越界
*/
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 根据index下标找到节点
* 优化:由于是双向链表,所以判断索引位置(size/2),前半段从头节点开始查找,后半段从尾节点开始查找
*/
Node node(int index) {
// assert isElementIndex(index);
// 判断插入的位置在链表前半段或者是后半段 size/2的1次方
if (index < (size >> 1)) { // 插入位置在前半段
Node x = first;
for (int i = 0; i < index; i++) // 从头结点开始正向遍历
x = x.next;
return x;
} else {// 插入位置在后半段
Node x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
/**
* 在非空节点succ前插入数据
*/
void linkBefore(E e, Node succ) {
// assert succ != null;
final Node pred = succ.prev;
final Node newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
3)addAll(Collection extends E> c);//添加Collection类型元素
/**
* 添加一个集合
*/
public boolean addAll(Collection extends E> c) {
//在末尾添加
return addAll(size, c);
}
4)addAll(int index, Collection extends E> c);//指定位置,添加Collection类型元素
/**
* 从指定的位置开始,将指定collection中的所有元素插入到此列表中,新元素的顺序为指定collection的迭代器所返回的元素顺序
*/
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 pred, succ; //上一个 下一个
if (index == size) { // 如果插入位置为链表末尾,则后继为null,上一个为尾结点
succ = null;
pred = last;
} else { // 插入位置为其他某个位置
succ = node(index); // 寻找到该结点
pred = succ.prev; // 保存该结点的上一个
}
for (Object o : a) { // 遍历数组
@SuppressWarnings("unchecked") E e = (E) o;
Node newNode = new Node<>(pred, e, null); // 生成新结点
if (pred == null) // 表示在第一个元素之前插入(索引为0的结点)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) { // 表示在最后一个元素之后插入
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
// 修改实际元素个数
size += numNew;
// 结构性修改加1
modCount++;
return true;
}
5)addFirst(E e);//头结点添加元素
/**
* 头结点插入元素
*/
public void addFirst(E e) {
linkFirst(e);
}
/**
* 链接头结点
*/
private void linkFirst(E e) {
final Node f = first;
final Node newNode = new Node<>(null, e, f);//新建节点,头结点为null,尾节点为first
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
6)addLast(E e);//尾结点添加元素
/**
* 尾节点添加元素
*/
public void addLast(E e) {
linkLast(e);
}
/**
* 链接尾节点
*/
void linkLast(E e) {
// 保存尾结点,l为final类型,不可更改
final Node l = last;
// 新生成结点的上一个为l,下一个为null
final Node newNode = new Node<>(l, e, null);
// 重新赋值尾结点
last = newNode;
if (l == null) // 尾结点为空
first = newNode; // 赋值头结点
else
l.next = newNode; // 尾结点的下一个为新生成的结点
size++; // 大小加1
modCount++; // 结构性修改加1
}
7)push(E e);//添加头结点
/**
* addFirst,添加头结点
*/
public void push(E e) {
addFirst(e);
}
2.remove方法(11种重载实现)--删
LinkedList中特有的删除方法
Deque中要实现的删除方法
1)E remove(); //删除头元素
/**
* 删除头结点
*/
public E remove() {
return removeFirst();
}
/**
* 删除头结点
*/
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
/**
* 头结点设置为下一个节点
*/
private E unlinkFirst(Node f) {
// assert f == first && f != null;
final E element = f.item;
final Node 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;
}
2)E remove(int index); //根据下标删除元素
/**
* 根据下标删除元素
*/
public E remove(int index) {
//检查下标是否合法
checkElementIndex(index);
return unlink(node(index));
}
/**
* 删除指定节点元素
*/
E unlink(Node x) {
// assert x != null;
// 保存结点的元素
final E element = x.item;
// 保存x的下一个
final Node next = x.next;
// 保存x的上一个
final Node prev = x.prev;
//如果上一个节点为null,则说明是头结点,把next赋值first
if (prev == null) {
first = next;
} else {//如果不是头结点,则把上一个节点的next赋值为next的元素,x的上一个节点赋值为null,以便GC
prev.next = next;
x.prev = null;
}
//如果下一个节点为空,则说明是尾节点,把prev赋值为lst
if (next == null) {
last = prev;
} else {//如果不是尾节点,则把下一个节点的prev赋值为prev的元素,x的一下个节点赋值为null,以便GC
next.prev = prev;
x.next = null;
}
x.item = null; // 结点元素赋值为空,以便
size--; // 减少元素实际个数
modCount++; // 结构性修改加1
return element;
}
3)boolean remove(Object o); //删除元素o
/**
* 删除元素o
*/
public boolean remove(Object o) {
//判断o是否为null,付过为null用equals,会报空指针
if (o == null) {
for (Node x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
4)E removeFirst(); //删除头结点
/**
* 删除头结点
*/
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
5)E removeLast(); //删除尾结点
/**
* 删除尾结点
*/
public E removeLast() {
final Node l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
6)boolean removeFirstOccurrence(Object o); //删除此节点中第一次出现的o
/**
* 删除此节点中第一次出现的o(从头到尾遍历列表时)
*/
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
7)boolean removeLastOccurrence(Object o); //删除此节点中最后一次出现的o
/**
* 删除此列表中最后一次出现的元素o(从头到尾遍历列表时)
*/
public boolean removeLastOccurrence(Object o) {
if (o == null) {
for (Node x = last; x != null; x = x.prev) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node x = last; x != null; x = x.prev) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
8)E poll(); //删除头结点
/**
* 删除头结点
*/
public E poll() {
final Node f = first;
return (f == null) ? null : unlinkFirst(f);
}
9)E pollFirst(); //删除头结点
/**
* 删除头结点
* @since 1.6
*/
public E pollFirst() {
final Node f = first;
return (f == null) ? null : unlinkFirst(f);
}
10)E pollLast(); //删除尾结点
/**
* 删除尾结点
* @since 1.6
*/
public E pollLast() {
final Node l = last;
return (l == null) ? null : unlinkLast(l);
}
11)E pop(); //删除头结点
/**
* 删除头结点
* @since 1.6
*/
public E pop() {
return removeFirst();
}
总结:
remove函数用户移除指定下标的元素,此时会把指定下标到数组末尾的元素向前移动一个单位,并且会把数组最后一个元素设置为null,这样是为了方便之后将整个数组不被使用时,会被GC,可以作为小的技巧使用。
3.set方法--改
/**
* 覆盖指定下标元素
*/
public E set(int index, E element) {
//判断下标是否越界
checkElementIndex(index);
//获得下标节点
Node x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
/**
* 判断下标是否越界
*/
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
4.get方法(6种重载)--查
LinkedList中特有的查询方法
Deque中要实现的查询方法
1)E get(int index); //根据下标获取指定节点的元素值
/**
* 返回指定下标的值
*/
public E get(int index) {
//判断下标是否越界
checkElementIndex(index);
return node(index).item;
}
/**
* 判断下标是否越界
*/
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 判断下标是否越界
*/
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
/**
* 根据index下标找到节点
* 优化:由于是双向链表,所以判断索引位置(size/2),前半段从头节点开始查找,后半段从尾节点开始查找
*/
Node node(int index) {
// assert isElementIndex(index);
// 判断插入的位置在链表前半段或者是后半段 size/2的1次方
if (index < (size >> 1)) { // 插入位置在前半段
Node x = first;
for (int i = 0; i < index; i++) // 从头结点开始正向遍历
x = x.next;
return x;
} else {// 插入位置在后半段
Node x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
2)E getFirst(); //获取头节点的元素值
/**
* 获取头结点
*/
public E getFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
3)E getFirst(); //获取头节点的元素值
/**
* 获取尾节点
*/
public E getLast() {
final Node l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
4)E peek(); //获取头节点的元素值
/**
* 获取头结点
* @since 1.5
*/
public E peek() {
final Node f = first;
return (f == null) ? null : f.item;
}
5)E peekFirst(); //获取头节点的元素值
/**
* 获取头节点的元素值
* @since 1.6
*/
public E peekFirst() {
final Node f = first;
return (f == null) ? null : f.item;
}
6)E peekFirst(); //获取尾节点的元素值
/**
* 获取尾节点的元素值
* @since 1.6
*/
public E peekLast() {
final Node l = last;
return (l == null) ? null : l.item;
}
5.indexOf方法--通过o查找下标,从头到尾查找
/**
* 查找下标, 如果为null,直接和null比较,返回下标
* 通过o查找下标,从头到尾查找
*/
public int indexOf(Object o) {
int index = 0;
//判断o是否为null,付过为null用equals,会报空指针
if (o == null) {
for (Node x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
6.lastIndexOf方法--通过o查找下标,从尾到头查找
/**
* 通过o查找下标,从尾到头查找
*/
public int lastIndexOf(Object o) {
int index = size;
//判断o是否为null,付过为null用equals,会报空指针
if (o == null) {
for (Node x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
for (Node x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}
7.clone方法--克隆
/**
* 克隆
* 复制,LinkedList 的浅拷贝
*/
public Object clone() {
LinkedList clone = superClone();
// Put clone into "virgin" state
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;
// Initialize clone with our elements
for (Node x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}
8.Node内部类--存储存储元素的对象
/**
* 内部类Node,LinkedList存储元素的对象
* @param
*/
private static class Node {
E item; // 数据域
Node next; // 下一个
Node prev; // 上一个
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
9.ListItr内部类--类似Iterator,可以帮我们对List进行遍历,增删改查等
/**
* 返回index位置的interator
*/
public ListIterator listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
/**
* 内部类,类似Iterator,可以帮我们对List进行遍历,增删改查等
*/
private class ListItr implements ListIterator {
private Node lastReturned = null;
private Node next;
private int nextIndex;
private int expectedModCount = modCount;
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
public void forEachRemaining(Consumer super E> action) {
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
10.DescendingIterator内部类--逆序的ListItr
/**
* @since 1.6
* 实例化一个DescendingIterator对象,并返回
*/
public Iterator descendingIterator() {
return new DescendingIterator();
}
/**
* Adapter to provide descending iterators via ListItr.previous
* DescendingIterator是逆序的ListItr
*/
private class DescendingIterator implements Iterator {
private final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}
11.LLSpliterator内部类--将元素分割成多份,分别交于不于的线程去遍历,以提高效率
/**
* @since 1.8
* 实例化一个LLSpliterator对象,并返回
*/
@Override
public Spliterator spliterator() {
return new LLSpliterator(this, -1, 0);
}
/** A customized variant of Spliterators.IteratorSpliterator
* 实例化一个LLSpliterator对象,并返回。LLSpliterator是JDK1.8之后LinkedList新增的内部类,
* 大概用途是将元素分割成多份,分别交于不于的线程去遍历,以提高效率
* */
static final class LLSpliterator implements Spliterator {
static final int BATCH_UNIT = 1 << 10; // batch array size increment
static final int MAX_BATCH = 1 << 25; // max batch array size;
final LinkedList list; // null OK unless traversed
Node current; // current node; null until initialized
int est; // size estimate; -1 until first needed
int expectedModCount; // initialized when est set
int batch; // batch size for splits
LLSpliterator(LinkedList list, int est, int expectedModCount) {
this.list = list;
this.est = est;
this.expectedModCount = expectedModCount;
}
final int getEst() {
int s; // force initialization
final LinkedList lst;
if ((s = est) < 0) {
if ((lst = list) == null)
s = est = 0;
else {
expectedModCount = lst.modCount;
current = lst.first;
s = est = lst.size;
}
}
return s;
}
public long estimateSize() { return (long) getEst(); }
public Spliterator trySplit() {
Node p;
int s = getEst();
if (s > 1 && (p = current) != null) {
int n = batch + BATCH_UNIT;
if (n > s)
n = s;
if (n > MAX_BATCH)
n = MAX_BATCH;
Object[] a = new Object[n];
int j = 0;
do { a[j++] = p.item; } while ((p = p.next) != null && j < n);
current = p;
batch = j;
est = s - j;
return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED);
}
return null;
}
public void forEachRemaining(Consumer super E> action) {
Node p; int n;
if (action == null) throw new NullPointerException();
if ((n = getEst()) > 0 && (p = current) != null) {
current = null;
est = 0;
do {
E e = p.item;
p = p.next;
action.accept(e);
} while (p != null && --n > 0);
}
if (list.modCount != expectedModCount)
throw new ConcurrentModificationException();
}
public boolean tryAdvance(Consumer super E> action) {
Node p;
if (action == null) throw new NullPointerException();
if (getEst() > 0 && (p = current) != null) {
--est;
E e = p.item;
current = p.next;
action.accept(e);
if (list.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
return false;
}
public int characteristics() {
return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
}
}
LinkedList总结
1)LinkedList可以存放null,本质是泛型E类型的内部类。
2)LinkedList插入删除快,查询慢,需要从头/尾节点遍历找到元素,移动数据只需要修改相邻节点元素,效率高。
3)LinkedList父类继承了Iterable,所以在遍历它的时候推荐使用iterator循环,效率更高。
4)LinkedList操作头/尾结点有对应First/Last方法,效率高,查询也类似二分法的遍历。
5)LinkedList实现Deque双端队列,有相关队列出栈/入栈方法。
名称栏目:LinkedList源码分析--jdk1.8
网站URL:http://myzitong.com/article/gdseho.html