Java集合（四） LinkedList详解
在上篇文章Java集合（三） ArrayList详解的学习和源码分析中，咱们知道ArrayList是以数组实现，它的优点是查询性能高，劣势是按顺序增删性能差。若是在不肯定元素数量的状况时，不建议使用ArrayList。其实当这种状况时，咱们就可使用LinkedList了。java
大O记号
一直以来咱们用快慢来描述存储算法，这种直观的描述是很差的。有一种方法能够量化一种操做的耗时状况。咱们能够借用数学分析中的大O记号来描述这种关系。
解决一个规模为n的问题所花费的步骤若是是n的常数倍，咱们就记这个方法的复杂度为O(n)。例如，给一个数组，求这个数组中的最大值，须要遍历这个数组，若是数组长度为n，那么遍历数组的步骤就是n。因此，这是一种O(n)的操做。一样，解决一个规模为n的问题所花费的步骤若是是n^2的常数倍，咱们就记这个方法的复杂度为O(n^2)。好比冒泡排序。而解决问题的步骤若是与问题规模无关，这个时间复杂度就是O(1)的。好比，数组的随机存取。而数组的顺序存储就是O(n)的。node
链表
在学习LinkedList以前，咱们先对数据结构中链表作一个简单的回顾。链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是经过链表中的指针连接次序实现的。链表由一系列结点（链表中每个元素成为结点）组成，结点能够在运行时动态生成。
能够这样理解：
有一条街，小明住在街中一角，他有小红的地址，而后小红也是住在这条街，他有小花的地址，一样小花也有别人的地址。某天我想找小红玩，可是我不知道她住在哪里，我能够问小明，就知道小红住在哪里了。那么小明小红小花这些人之间的关系就组成一个链表。 git
- 单链表：就是小明只是右手握着小红的地址，他只有小红一我的的地址
- 双链表：就是小红左手握着小明的地址，右手握着小花的地址，她有两我的的地址
- 循环链表：就是小明握着小红的地址，小红握着小花的地址，而小花又握着小明的地址，这样就造成了一个循环
- 有序链表：以某个标准，给链表的元素排序，好比比较内容大小、比较哈希值等 若是还很差理解，咱们能够先看一个类的定义：
public class LinkNode {
public int data;
public LinkNode next;
public LinkNode(int data) {
this.data = data;
this.next = null;
}
}
复制代码
咱们定义了一个LinkNode类，这个类有两个成员变量，一个是整形data，还有一个是指向LinkNode类型的引用。经过这个引用，就能够把多个LinkNode串起来，好比，下面的代码：github
LinkNode head = new LinkNode(1);
head.next = new LinkNode(2);
复制代码
这样就在内存里建立了两个LinkNode对象，它们之间的关系就像这样： 算法
链表增长一项
若是我想在head以后，增长一个链表项，让这个链表变成下图的样子，该怎么作？ 数组
LinkNode newNode = new LinkNode(3);
newNode.next = head.next;
head.next = newNode;
复制代码
反过来，想要把head后面的那个结点删掉，也很简单，只须要让head的next再日后指一项，把原来head后面的那一项跳过去就能够了：安全
head.next = head.next.next;
复制代码
能够看到，在链表中，指定的结点后面添加一个项是常数时间的，也就是O(1),删除一个项也是同样的。但与数组不一样的，若是我要完成“查询链表中的第n项是什么”这个操做，就会变成O(n)的，由于咱们每次查找都必须从头开始，依次向后查找。bash
public static int queryData(LinkNode head, int index) {
LinkNode cur = head;
for (int i = 0; i < index; i++) {
cur = cur.next;
}
return cur.data;
}
复制代码
再看一个问题，假如我知道了一个LinkNode，不妨记为temp，位于一个链表中，若是想知道这个结点的上一个结点是什么，应该怎么办？对于咱们前边定义的链表结构，只能从头开始找，去判断是否有某个结点，它的next与temp相等。若是相等就说明，这个结点就是temp的前序结点。代码以下：数据结构
public static LinkNode findPrevious(LinkNode head, LinkNode temp) {
LinkNode cur = head;
while (cur != null) {
if (cur.next == temp)
return cur;
cur = cur.next;
}
return null;
}
复制代码
双向链表
实际上，在工程实践中，使用链表的时候，常常会有“查询某个结点的前一结点”这样的需求，为了加速这一过程，咱们其实能够修改一下LinkNode的定义，结它加上一个指向前序结点的成员变量：ide
public class DoubleLinkNode {
public int data;
public LinkNode next;
public LinkNode prev;
public DoubleLinkNode(int data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
复制代码
这样的话，链表就成了这个样子了：
好了。链表的学习就到这里了。
LinkedList
概述
LinkedList以双向链表实现。链表无容量限制，但双向链表自己使用了更多空间，也须要额外的链表指针操做。除了实现List接口外，LinkedList还为在列表的开头及结尾get、remove和insert元素提供了统一的命名方法。这些操做能够将连接列表看成栈，队列和双端队列来使用。
按索引访问元素：get(i)/set(i,e)要很是恶心的遍历链表将指针移动到位（若是i > 数组大小的一半，会从末尾开始移动）。插入、删除元素时修改先后节点的指针便可，但仍是要遍历部分链表的指针才能移动到下标所指的位置，只有在链表两头的操做：add(),addFirst(),removeLast()或用iterator()上的remove()能省掉指针的移动。
LinkedList一样是非线程安全的，只在单线程下适合使用。若是多个线程同时访问一个连接列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。（结构修改指添加或删除一个或多个元素的任何操做；仅设置元素的值不是结构修改。）这通常经过对天然封装该列表的对象进行同步操做来完成。若是不存在这样的对象，则应该使用 Collections.synchronizedList 方法来“包装”该列表。
LinkedList的iterator和listIterator方法返回的迭代器是快速失败的（fail-fast机制）：在迭代器建立以后，若是从结构上对列表进行修改，除非经过迭代器自身的remove或add方法，其余任什么时候间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。
LinkedList实现了Serializable接口，所以它支持序列化，可以经过序列化传输，实现了Cloneable接口，能被克隆。
LinkedList源码解析
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable,
java.io.Serializable {
//LinkedList中链表元素个数
transient int size = 0;
//链表头结点
transient Node<E> first;
//链表尾结点
transient Node<E> last;
//默认构造方法，生成一个空的链表
public LinkedList() {
}
//根据c里面的元素生成一个LinkedList
public LinkedList(Collection<? extends E> c) {
//调用空的构造方法
this();
//将c里面的元素添加到空链表尾部
addAll(c);
}
//首部增长结点，结点的值为e
private void linkFirst(E e) {
final Node<E> f = first;//f指向头结点
//生成一个新结点，结点的值为e，其前向指针为null，后向指针为f
final Node<E> newNode = new Node<>(null, e, f);
//first指向新生成的结点，f保存着旧的头结点信息
first = newNode;
if (f == null)
//若是f为null,则表示整个链表目前是空的，则尾结点也指向新结点
last = newNode;
else
//f(老的头结点)的前向指向最新的结点信息
f.prev = newNode;
size++;//元素个数+1
modCount++;//修改次数+1
}
//尾部增长结点，结点的值为e
void linkLast(E e) {
final Node<E> l = last; //l指向尾结点
//生成一个新结点，结点的值为e，其前向指针为l，后向指针为null
final Node<E> newNode = new Node<>(l, e, null);
//last指向新生成的结点，l保存着旧的尾结点信息
last = newNode;
if (l == null)
//若是l为null，则表示整个链表目前是空的，则头结点也指向新结点
first = newNode;
else
//l(旧的尾结点)的后向指针指向最新的结点信息
l.next = newNode;
size++;//元素个数+1
modCount++;//修改次数+1
}
//非空结点succ以前插入新结点，新结点的值为e
void linkBefore(E e, Node<E> succ) {
// assert succ != null; //外界调用需保证succ不为null,不然程序会抛出空指针异常
final Node<E> pred = succ.prev;//pred指向succ的前向结点
//生成一个新结点，结点的值为e，其前向指针指向pred,后向指针指向succ
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;//succ的前向指针指向newNode
if (pred == null)
//若是pred为null,则表示succ为头结点，此时头结点指向最新生成的结点newNode
first = newNode;
else
//pred的后向指针指向新生成的结点，此时已经完成告终点的插入操做
pred.next = newNode;
size++;//元素个数+1
modCount++;//修改次数+1
}
//删除头结点，并返回该结点的值
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;//需确保f为头结点，且链表不为null
final E element = f.item;//得到结点的值
final Node<E> next = f.next;//next指向f的后向结点
f.item = null;//释放数据结点
f.next = null; // help GC //释放f的后向指针
first = next; //first指向f的后向结点
if (next == null)
//若是next为null,则表示f为last结点，此时链表即为空链表
last = null;
else
//修改next的前向指针，由于first结点的前向指针为null
next.prev = null;
size--; //元素个数-1
modCount++; //修改次数+1
return element;
}
//删除尾结点，并返回尾结点的内容
private E unlinkLast(Node<E> l) {
// assert l == last && l != null; //需确保l为尾结点，且链表不为null
final E element = l.item; //得到结点的值
final Node<E> prev = l.prev; //prev执行1的前向结点
l.item = null; //释放l结点的值
l.prev = null; // help GC //释放l结点的前向指针
last = prev; //last结点指向l的前向结点
if (prev == null)
//若是prev为null,则表示l为first结点，此时链表即为空链表
first = null;
else
//修改prev的后向指针，由于last结点的后向指针为null
prev.next = null;
size--;//元素个数-1
modCount++;//修改次数+1
return element;
}
//删除结点x
E unlink(Node<E> x) {
// assert x != null; //需确保x不为null，不然后续操做会抛出空指针异常
final E element = x.item; //保存x结点的值
final Node<E> next = x.next;//next指向x的后向结点
final Node<E> prev = x.prev;//prev指向x的前向结点
if (prev == null) {
//若是prev为空，则x结点为first结点，此时first结点指向next结点（x的后向结点）
first = next;
} else {
prev.next = next;//x的前向结点的后向指针指向x的后向结点
x.prev = null; //释放x的前向指针
}
if (next == null) {
//若是next结点为空，则x结点为尾部结点，此时last结点指向prev结点（x的前向结点）
last = prev;
} else {
next.prev = prev;//x的后向结点的前向指针指向x的前向结点
x.next = null; //释放x的后向指针
}
x.item = null; //释放x的值节点，此时x节点能够彻底被GC回收
size--; //元素个数-1
modCount++; //修改次数+1
return element;
}
//得到头结点的值
public E getFirst() {
final Node<E> f = first;//f指向first结点
if (f == null)//若是链表为空
throw new NoSuchElementException();
return f.item;//返回first结点的值
}
//得到尾结点的值
public E getLast() {
final Node<E> l = last; //l指向last结点
if (l == null)//若是链表为空
throw new NoSuchElementException();
return l.item;//返回last结点的值
}
//移除头结点
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);//摘除尾结点
}
//添加到头结点，结点的值为e
public void addFirst(E e) {
linkFirst(e);//添加到头部
}
//添加到尾结点
public void addLast(E e) {
linkLast(e);//添加到尾部
}
//判断元素（值为o）是否o在链表中
public boolean contains(Object o) {
return indexOf(o) != -1;//定位元素
}
//返回元素个数
public int size() {
return size;
}
//添加元素，元素值为e
public boolean add(E e) {
linkLast(e);//添加到链表尾部
return true;
}
//移除值为o的元素，o能够为null，找到一个删除即返回
public boolean remove(Object o) {
if (o == null) {//元素为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;
}
//将c中的元素都添加到当前链表中
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);//添加到链表尾部
}
//在序号为index处，添加c中全部的元素到当前链表中（后向添加）
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);//判断index是否超出界
Object[] a = c.toArray();//将集合转换为数组
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {//若是index为元素个数，即index个结点为尾结点
succ = null;
pred = last;//指向为结点
} else {
succ = node(index); //succ指向第index个结点
pred = succ.prev; //pred指向succ的前向结点
}
//for循环结束后，a里面的元素都添加到当前链表里面，后向添加
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
//新生成一个结点，结点的前向指针指向pred,后向指针为null
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
//若是pred为null，则succ为当前头结点
first = newNode;
else
//pred的后向指针指向新结点
pred.next = newNode;
pred = newNode;//pred移动到新结点
}
if (succ == null) {
last = pred;//succ为null，这表示index为尾结点以后
} else {
//pred表示全部元素添加以后的最后结点，此时pred的后向指针指向以前的记录的结点
pred.next = succ;
succ.prev = pred;//以前记录的结点指向添加元素以后的最后结点
}
size += numNew;//元素个数+num
modCount++;//修改次数+1
return true;
}
//清除链表里面的全部元素
public void clear() {
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null; //释放值结点，便于GC回收
x.next = null; //释放前向指针
x.prev = null; //释放后向指针
x = next; //后向遍历
}
first = last = null;//释放头尾结点
size = 0;
modCount++;
}
//得到第index个结点的值
public E get(int index) {
checkElementIndex(index);
return node(index).item; //点位第index结点，返回值信息
}
//设置第index元素的值
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);//定位第index个结点
E oldVal = x.item;
x.item = element;
return oldVal;
}
//第index个结点以前添加结点
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
//删除第index个结点
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
//判断index是不是链表中的元素的索引
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
//判断index是不是链表中的元素的索引
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
private String outOfBoundsMsg(int index) {
return "Index: " + index + ", Size: " + size;
}
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//定位链表中的第index个结点
Node<E> node(int index) {
// assert isElementIndex(index);//确保是合法的索引，即0<=index<=size
//index小于size的一半时，从头向后找
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {//index大于size的一半时，从尾向前找
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
//定位元素，首次出现的元素的值为o的结点序号
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;
}
//定位元素，最后一次出现的元素值为o的元素序号
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;
}
//实现队列操做，返回第一个元素的值
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);
}
//添加头结点
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();
}
//删除值为o的结点
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
//删除值为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;
}
//返回双向迭代器
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
//私有内部类，实现双向迭代器
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;//记录当前结点信息
private Node<E> 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++;//结点序号+1
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<E> 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++;
}
// Lambda表达式结合迭代器进行遍历
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();
}
}
private static class Node<E> {
E item; //结点的值
Node<E> next; //结点的后向指针
Node<E> prev; //结点的前向指针
//构造方法中已完成Node成员的赋值
Node(Node<E> prev, E element, Node<E> next) {
this.item = element; //结点的值赋值为element
this.next = next; //后向指针赋值
this.prev = prev; //前向指针赋值
}
}
//返回前向迭代器
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
//前向迭代器
private class DescendingIterator implements Iterator<E> {
private final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}
@SuppressWarnings("unchecked")
private LinkedList<E> superClone() {
try {
return (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
//拷贝操做，执行浅拷贝，只复制引用，而没有复制引用指向的内存
public Object clone() {
LinkedList<E> 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<E> x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}
//转换为数组
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;
}
//转换为数组
@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;
}
//序列化版本
private static final long serialVersionUID = 876323262645176354L;
//序列化
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out size
s.writeInt(size);
// Write out all elements in the proper order.
for (Node<E> x = first; x != null; x = x.next)
s.writeObject(x.item);
}
//反序列化
@SuppressWarnings("unchecked")
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read in size
int size = s.readInt();
// Read in all elements in the proper order.
for (int i = 0; i < size; i++)
linkLast((E) s.readObject());
}
//获取一个分割器，1.8新增
@Override
public Spliterator<E> spliterator() {
return new LLSpliterator<E>(this, -1, 0);
}
/**
* A customized variant of Spliterators.IteratorSpliterator
*/
static final class LLSpliterator<E> implements Spliterator<E> {
···
}
}
复制代码
总结
关于LinkedList的源码，给出几点比较重要的总结：
1.从源码中很明显能够看出，LinkedList的实现是基于双向链表的，且头结点中不存放数据。
2.注意两个不一样的构造方法。无参构造方法直接创建一个仅包含head节点的空链表；包含Collection的构造方法，先调用无参构造方法创建一个空链表，然后将Collection中的数据加入到链表的尾部后面。
3.在查找和删除某元素时，源码中都划分为该元素为null和不为null两种状况来处理，LinkedList中容许元素为null。
4.LinkedList是基于链表实现的，所以不存在容量不足的问题，因此这里没有扩容的方法。
5.Node node(int index)方法。该方法返回双向链表中指定位置处的节点，而链表中是没有下标索引的，要指定位置出的元素，就要遍历该链表，从源码的实现中，咱们看到这里有一个加速动做。源码中先将index与长度size的一半比较，若是index<(size<<1)，就只从位置0日后遍历到位置index处，而若是index>(size<<1)，就只从位置size往前遍历到位置index处。这样能够减小一部分没必要要的遍历，从而提升必定的效率（实际上效率仍是很低）。
6.LinkedList是基于链表实现的，所以插入删除效率高，查找效率低（虽然有一个加速动做）。
7.要注意源码中还实现了栈和队列的操做方法，所以也能够做为栈、队列和双端队列来使用。
参考
相关文章
- 1. Java集合：LinkedList详解
- 2. Java集合详解2：LinkedList和Queue
- 3. 【Java集合】LinkedList详解中篇
- 4. Java集合 LinkedList 底层详解
- 5. java集合框架---ArrayList/Vector/LinkedList详解
- 6. java集合：LinkedList
- 7. java集合LinkedList
- 8. java集合－LinkedList
- 9. Java集合——LinkedList
- 10. Java集合--LinkedList
- 更多相关文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • Flink 数据传输及反压详解
- • ☆技术问答集锦（13）Java Instrument原理
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. js中 charCodeAt
- 2. Android中通过ViewHelper.setTranslationY实现View移动控制（NineOldAndroids开源项目）
- 3. 【Android】日常记录：BottomNavigationView自定义样式，修改点击后图片
- 4. maya 文件检查 ui和数据分离 （一）
- 5. eclipse 修改项目的jdk版本
- 6. Android InputMethod设置
- 7. Simulink中Bus Selector出现很多? ? ?
- 8. 【Openfire笔记】启动Mac版Openfire时提示“系统偏好设置错误”
- 9. AutoPLP在偏好标签中的生产与应用
- 10. 数据库关闭的四种方式
欢迎关注本站公众号,获取更多信息
