13518219792
ArrayList源码分析--jdk1.8
LinkedList源码分析--jdk1.8
HashMap源码分析--jdk1.8
AQS源码分析--jdk1.8
ReentrantLock源码分析--jdk1.8
创新互联主要从事成都做网站、网站建设、网页设计、企业做网站、公司建网站等业务。立足成都服务柘荣,十多年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18980820575
1.LinkedList是用双向链表实现的集合，基于内部类Node
实现的集合。
2.LinkedList支持双向链表访问、克隆、序列化，元素有序且可以重复。
3.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 使用 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 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 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中特有的新增方法
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 c)；//添加Collection类型元素
/**
* 添加一个集合
*/
public boolean addAll(Collection c) {
//在末尾添加
return addAll(size, c);
}4)addAll(int index, Collection c)；//指定位置，添加Collection类型元素
/**
* 从指定的位置开始，将指定collection中的所有元素插入到此列表中，新元素的顺序为指定collection的迭代器所返回的元素顺序
*/
public boolean addAll(int index, Collection 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);
}
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，可以作为小的技巧使用。
/**
* 覆盖指定下标元素
*/
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));
}
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;
} /**
* 查找下标， 如果为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;
} /**
* 通过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;
} /**
* 克隆
* 复制，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;
} /**
* 内部类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;
}
} /**
* 返回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 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();
}
} /**
* @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();
}
} /**
* @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 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 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;
}
} 1）LinkedList可以存放null，本质是泛型E类型的内部类。
2）LinkedList插入删除快，查询慢，需要从头/尾节点遍历找到元素，移动数据只需要修改相邻节点元素，效率高。
3）LinkedList父类继承了Iterable，所以在遍历它的时候推荐使用iterator循环，效率更高。
4）LinkedList操作头/尾结点有对应First/Last方法，效率高，查询也类似二分法的遍历。
5）LinkedList实现Deque双端队列，有相关队列出栈/入栈方法。 
