特性
Deque：实现了双端队列特性
Cloneable：拷贝特性
Serializable：序列化
基本属性
transient int size = 0;
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
size：LinkedList集合中元素的大小
first：第一个节点元素
last：最后一个节点元素
总结：
从代码中可以看到LinkedList中维护的都是一个个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;
}
}
Node 中也维护了三个属性：
item：具体数据
next：指向下一个节点的引用
prev：指向上一个节点的引用
总结：
由于每一节点都维护了next、prev由此可以看的出是LinkedList是一个双端队列
LinkedList数据结构图：
双端队列既可以从头找到尾也可以从尾找到头
构造器
无参构造
public LinkedList() {
}
有参构造
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);//构建LinkedList数据结构
}
//添加元素，并构建链表结构
public boolean addAll(int index, Collection<? extends E> c) {
//检查下标的有效性
checkPositionIndex(index);
//判断数据是否null
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;
}
主要方法
添加元素
普通的添加方法，一般添加到链表的最后面
流程图：
public boolean add(E e) {
linkLast(e);
return true;
}
//目标节点创建后寻找前驱节点， 前驱节点存在就修改前驱节点的后继，指向目标节点
void linkLast(E e) {
final Node<E> l = last;//获取这个list对象内部的Node类型成员last，即末位节点，以该节点作为新插入元素的前驱节点
final Node<E> newNode = new Node<>(l, e, null);//创建新节点
last = newNode;//把新节点作为该list对象的最后一个节点
if (l == null)//处理原先的末位节点，如果这个list本来就是一个空的链表
first = newNode;//把新节点作为首节点
else
l.next = newNode;//如果链表内部已经有元素，把原来的末位节点的后继指向新节点，完成链表修改
size++;//修改当前list的size，
modCount++;//并记录该list对象被执行修改的次数
}
指定位置添加元素
流程图：
源码：
public void add(int index, E element) {
checkPositionIndex(index);//检查下标的合法性
if (index == size)//插入位置是末位，那还是上面末位添加的逻辑
linkLast(element);
else
linkBefore(element, node(index));
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
Node<E> node(int index) {
if (index < (size >> 1)) {//二分查找 index离哪端更近 就从哪端开始找
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;//找到index位置的元素
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
//指位添加方法核心逻辑 操作新节点，紧接修改原有节点的前驱属性，最后再修改前驱节点的后继属性
void linkBefore(E e, Node<E> succ) {
final Node<E> pred = succ.prev;//原位置节点的前驱pred
final Node<E> newNode = new Node<>(pred, e, succ);//创建新节点,设置新节点其前驱为原位置节点的前驱pred，其后继为原位置节点succ
succ.prev = newNode;//将新节点设置到原位置节点的前驱
if (pred == null)//前驱如果为空，空链表，则新节点设置为first
first = newNode;
else
pred.next = newNode;//将新节点设置到前驱节点的后继
size++;//修改当前list的size
modCount++;//记录该list对象被执行修改的次数。
}
注意：LinkedList 在插入数据优于ArrayList ，主要是因为他只需要修改指针的指向即可，而不需要将整个数组的数据进行转移
删除元素
结构图：
删除只是断开它们之间的链接
public E remove(int index) {
checkElementIndex(index);
//node(index)找到index位置的元素
return unlink(node(index));
}
//remove(Object o)这个删除元素的方法的形参o是数据本身，而不是LinkedList集合中的元素（节点），所以需要先通过节点遍历的方式，找到o数据对应的元素，然后再调用unlink(Node x)方法将其删除
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) {
//x的数据域element
final E element = x.item;
//x的下一个结点
final Node<E> next = x.next;
//x的上一个结点
final Node<E> prev = x.prev;
//如果x的上一个结点是空结点的话，那么说明x是头结点
if (prev == null) {
first = next;
} else {
prev.next = next;//将x的前后节点相连 双向链表
x.prev = null;//x的属性置空
}
//如果x的下一个结点是空结点的话，那么说明x是尾结点
if (next == null) {
last = prev;
} else {
next.prev = prev;//将x的前后节点相连 双向链表
x.next = null;
}
x.item = null;//指向null 方便GC回收
size--;
modCount++;
return element;
}
Deque 中的Remove
//将first 节点的next 设置为新的头节点，然后将 f 清空。 removeLast 操作也类似。
private E unlinkFirst(Node<E> f) {
final E element = f.item;
//获取到头结点的下一个结点
final Node<E> next = f.next;
f.item = null;
f.next = null; // 方便 GC
//头指针指向的是头结点的下一个结点
first = next;
//如果next为空，说明这个链表只有一个结点
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
双端链表（队列Queue）
java中队列的实现就是LinkedList： 我们之所以说LinkedList 为双端链表，是因为他实现了Deque 接口；我们知道，队列是先进先出的，添加元素只能从队尾添加，删除元素只能从队头删除，Queue中的方法就体现了这种特性。 支持队列的一些操作，我们来看一下有哪些方法实现：
● pop（）是栈结构的实现类的方法，返回的是栈顶元素，并且将栈顶元素删除
● poll（）是队列的数据结构，获取对头元素并且删除队头元素
● push（）是栈结构的实现类的方法，把元素压入到栈中
● peek（）获取队头元素 ，但是不删除队列的头元素
● offer（）添加队尾元素
可以看到Deque 中提供的方法主要有上述的几个方法，接下来我们来看看在LinkedList 中是如何实现这些方法的。
队列的增
offer（）添加队尾元素
public boolean offer(E e) {
return add(e);
}
具体的实现就是在尾部添加一个元素
队列的删
poll（）是队列的数据结构，获取对头元素并且删除队头元素
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
具体的实现前面已经讲过，删除的是队列头部的元素
队列的查
peek（）获取队头元素 ，但是不删除队列的头元素
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
栈的增
push（）是栈结构的实现类的方法，把元素压入到栈中
push（） 方法的底层实现，其实就是调用了 addFirst（Object o）
public void push(E e) {
addFirst(e);
}
栈的删
pop（）是栈结构的实现类的方法，返回的是栈顶元素，并且将栈顶元素删除
public E pop() {
return removeFirst();
}
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
注意
在实际开发中LinkedList的使用很局限，在指定下标新增数据时，在数据量越大的情况下，ArrayList的速率会更加快，因为越到后面，ArrayList是以1.5倍扩容，扩容后就可以直接使用，在添加数据时可以直接通过下标直接添加，LinkedList在指定下标时添加要去遍历整个链然后需要重新整理前后的指针。
扫一扫
785
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
