jdk1.8的LinkedList是一个双向链表
LinkedList类的结构：
LinkedList的源码结构如下：
public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, Serializable由此可见，LInkedList继承了AbstractSequentialList类，并且实现了List,Deque,Cloneable,Serializable接口。所以
- 继承了AbstarctSequentialList抽象类：虽然提供有get(index,data)等方法，但是官方推荐顺序访问(因为在LinkedList内部，get(index,data)是遍历整个LinkedList来进行的[如果，index < (size >> 1)从头部遍历否则从尾部遍历]，复杂度为O(N),而ArrayList的get(index,data)的复杂度是O(1))，所以LinkedList推荐使用迭代器遍历.
- 实现了List接口中的所有方法。
- 实现了Cloneable接口，支持浅克隆。底层实现：LinkedList节点并没有被克隆，只是通过Object的clone（）方法得到的Object对象强制转化为了LinkedList,然后把它内部的实例域都置空，然后把被拷贝的LinkedList节点中的每一个值都拷贝到clone中。
- 实现了Deque接口。实现了Deque所有的可选的操作。
- 实现了Serializable接口。表明它支持序列化。（和ArrayList一样，底层都提供了两个方法：readObject（ObjectInputStream o）、writeObject（ObjectOutputStream o），用于实现序列化，底层只序列化节点的个数和节点的值）
LinkedList源码分析
1、存储元素的数据结构：
Node是LinkedList的私有静态内部类。LinkedList就是利用Node来存储数据。
- item:节点的数据值
- next:当前节点的下一个节点的引用也(就是下一个节点的地址)
- prev：当前节点的前一个节点的引用
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;
}
}2、LinkedList中的属性
- size:记录LinedList的大小(LinkedList元素的个数)
- first:头结点
- last:尾节点
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.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;LinkedList的构造方法
LinkedList中定义了两个构造方法，AyyayList中多了一个用于设定初始容量的构造方法。因为LinkedList是通过链表来实现的，当添加元素的时候，LinkedList的长度会动态改变。而ArrayList中是通过数组来存储元素的，所以为AyyayList设定初始容量(数组的长度)的大小。
无参构造：
public LinkedList() {
}用一个集合作为初始化参数传入构造器：
// 首先调用一下空的构造器。
//然后调用addAll(c)方法。
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
//通过调用addAll(int index, Collection<? extends E> c) 完成集合的添加。
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//几乎所有的涉及到在指定位置添加或者删除或修改操作都需要判断传进来的参数是否合法。
// checkPositionIndex(index)方法就起这个作用。该方法后面会介绍。
public boolean addAll(int index, Collection<? extends E> c) {//index为添加第一个元素时的索引。表示从索引index开始添加集合c。
checkPositionIndex(index);
//先把集合转化为数组，然后为该数组添加一个新的引用（Objext[] a）。
Object[] a = c.toArray();
//新建一个变量存储数组的长度。
int numNew = a.length;
//如果待添加的集合为空，直接返回，无需进行后面的步骤。后面都是用来把集合中的元素添加到
//LinkedList中。
if (numNew == 0)
return false;
//这里定义了两个节点：Node<E> succ：指代待添加节点的前驱节点。Node<E> pred：指代待添加节点的后继节点。
//若新添加的元素的位置位于LinkedList最后一个元素的后面，即index==size，说明此时需要添加LinkedList中的集合中的每一个元素都是在LinkedList最后面。所以把succ设置为空，pred指向尾节点。
//否则，后继节点为node(int index)[返回第index个元素]，pred为succ节点的前一个节点。
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
//接着遍历数组中的每个元素。在每次遍历的时候，都新建一个节点，该节点的值存储数组a中遍历的值，该节点的prev用来存储pred节点，next设置为空。
//接着判断待添加节点的前驱节点是否为空，如果为空的话，则把当前节点设置为头节点。
//否则的话就把前驱节点的next值设置为当前节点。最后把pred指向当前节点，以便后续新节点的添加。
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;
}
//此时为处理最后一个添加的元素的链接方式。此时pred代表代签添加的最后一个节点。succ依然为当前最后一个节点的后继节点。
//当succ==null（也就是插入的节点是最后一个节点），last设置为pred[最后一个元素添加后，pred会后移]
//当不为空的时候，将添加的最后一个元素与后继节点相连。
//最后把集合的大小设置为新的大小。
//modCount（修改的次数）自增。
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
} LinkedList其他辅助方法：
①：把参数中的元素作为链表的第一个元素(将元素e添加到LinkedList的首部)
//因为我们需要把该元素设置为头节点，所以需要新建一个变量把头节点存储起来。
//然后新建一个节点，把next指向f，然后自身设置为头结点。
//再判断一下f是否为空，如果为空的话，说明原来的LinkedList为空，所以同时也需要把新节点设置为尾节点。否则就把f的prev设置为newNode。
//size和modCount自增。
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++;
}②：把参数中的元素作为链表的最后一个元素(将元素e添加到LinkedList的尾部)
//因为我们需要把该元素设置为尾节点，所以需要新建一个变量把尾节点存储起来。
//然后新建一个节点，其前驱节点为原last节点，后继节点为空。然后自身设置为尾结点。
//再判断一下l是否为空，如果为空的话，说明原来的LinkedList为空，所以同时也需要把新节点设置为头节点。否则就把l的next设置为newNode。
//size和modCount自增。
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++;
}③：在非空节点succ之前插入元素e
//首先我们需要新建一个变量指向succ节点的前一个节点，因为我们要在succ前面插入一个节点。(因此succ不能为null)
//接着新建一个节点，它的prev设置为我们刚才新建的变量，后置节点设置为succ。
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++;
}④：删除LinkedList中第一个/最后一个节点。且传入的参数必须为相应的头结点/尾节点，值不能为null，最后返回删除的值(其为私有方法)
//定义一个变量element保存将要返回的元素值，接着将首/尾节点相应的后移/前移。
//最后更新更新头结点的prep/尾节点的next(需要进行判断)
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;
}
/**
* Unlinks non-null last node 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;
}⑤删除一个节点（该节点不为空）
//首先获取待删除节点相应的前驱节点prep与后继节点next，
//首先判断prep是否为null，如果是，则删除的节点为头结点，头结点后移；否则，连接指针。next判断同理
//返回删除的节点的元素的值，modCount自增。
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; //加速GC
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null; //加速GC
}
x.item = null; //加速GC
size--;
modCount++;
return element;
}⑥：计算指定索引上的节点（返回Node）
//会首先判断index的索引是否小于链表长度的一半，如果小于则顺序遍历；反之，逆序便利。
Node<E> node(int index) {
// assert isElementIndex(index); //首先确保索引index合法
if (index < (size >> 1)) { //判断索引index是否在链表的前半部分。
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、删除/添加链表的头结点/尾节点：
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
public void addFirst(E e) {
linkFirst(e);
}
public void addLast(E e) {
linkLast(e);
}2、判断元素是否包含在链表中：
//要根据待查询的元素值是否为null，来分条件讨论。
//若元素在链表中不存在，在indexOf方法中返回值-1。
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;
}
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;
}3、从LinkedList中删除指定元素：
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;
}
4、清空LinkedList中的所有元素：
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable Iterator
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next; //将所有的节点的树枝和连接都设置为null，加速jvm的垃圾回收（提前与关键节点断开连接）
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null; //链表为空的条件
size = 0; //链表为空的条件
modCount++;
}5、LnikedList的克隆：
//直接调用超类的clone（）方法，然后把得到的Object对象转换为LinkedList类型。Object的clone（）方法是本地方法（通过native修饰）
@SuppressWarnings("unchecked")
private LinkedList<E> superClone() {
try {
return (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
//首先获取从辅助方法返回的LinkedList对象，接着把该对象的所有域都设置为初始值。
然后把LinkedList中所有的内容复制到返回的对象中。
public Object clone() {
LinkedList<E> clone = superClone(); //调用superclone的返回值
// Put clone into "virgin" state,全部设置为初始值
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;
// Initialize clone with our elements 初始化元素
for (Node<E> x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}6、将LinkedList转化为数组
//通过遍历链表，来将数据添加到数组中，并于最后返回数组
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;
}
//在方法内部，如果a的长度小于集合的大小的话，通过反射创建一个和集合同样大小的数组，接着把集合中的所有元素添加到数组中。
//如果数组的元素的个数大于集合中元素的个数，则把a[size]设置为空。
//代码设计者这样设计代码的目的是为了能够通过返回值观察到LinkedList集合中原来的元素有哪些。通过null把集合中的元素凸显出来。在ArrayList中也有同样的考虑和设计。
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
Object[] result = a;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
if (a.length > size)
a[size] = null;
return a;
}7、更多基本方法：
public boolean add(E e) {
linkLast(e);
return true;
}
public int size() {
return size;
}
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
private boolean isElementIndex(int index) {//此方法用来判断index是否在LinkedList索引范围内
return index >= 0 && index < size;
}
private boolean isPositionIndex(int index) {//此方法用于判断当我们新添加元素的时候，传进来的index是否合法，而且我们新添加的元素可能在LinkedList最后一个元素的后面，所以允许index<=size。
return index >= 0 && index <= size;
}
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}8、以下为实现双端队列接口的方法：
// Queue operations.
public E peek() { //返回头结点的值
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E element() { //返回头结点，若为空，则抛出异常
return getFirst();
}
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E remove() {
return removeFirst();
}
public boolean offer(E e) {
return add(e);
}
// Deque operations
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
public boolean offerLast(E e) {
addLast(e);
return true;
}
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
public void push(E e) {
addFirst(e);
}
public E pop() {
return removeFirst();
}
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
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;
}LinkedList迭代器：
LinkedList的迭代器也是提供了两种，一种是指提供向后遍历的Iterator，另一种是List的专有迭代器ListIterator(略)：
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
public Iterator<E> descendingIterator() {
return new DescendingIterator(); //实现了iterator接口
}总结：
- LinkedList自己实现了序列化和反序列化，因为它实现了writeObject和readObject方法。
- LinkedList是一个以双向链表实现的List。
- LinkedList还是一个双端队列，具有队列(peek(),poll(),offer())、双端队列、栈(push(),pop())的特性。
- LinkedList在首部和尾部添加、删除元素效率高效，在中间添加、删除元素效率较低。
- LinkedList虽然实现了随机访问，但是效率低效，不建议使用。
- LinkedList是线程不安全的
扫一扫
474
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
