来源:
Java编程的逻辑
JDK源码
1 构造方法
LinkedList的构造方法与ArrayList类似,有两个,一个是默认构造方法,另外一个可以接受一个已有的Collection,如下所示:
public LinkedList()
public LinkedList(Collection<? extends E> c)
2 接口
实现了List、Deque和Queue接口
2.1 List
LinkedList与ArrayList一样,同样实现了List接口,而List接口扩展了Collection接口,Collection又扩展了Iterable接口,所有这些接口的方法都是可以使用的
2.2 队列(Queue)
public interface Queue<E> extends Collection<E> {
boolean add(E e);
boolean offer(E e);
E remove();
E poll();
E element();
E peek();
}
Queue扩展了Collection,它的主要操作有三个:
- 在尾部添加元素 (add, offer)
- 查看头部元素 (element, peek),返回头部元素,但不改变队列
- 删除头部元素 (remove, poll),返回头部元素,并且从队列中删除
每种操作都有两种形式,区别在于:对于特殊情况的处理不同。
特殊情况是指,队列为空或者队列为满,为空容易理解,为满是指队列有长度大小限制,而且已经占满了。LinkedList的实现中,队列长度没有限制,但别的Queue的实现可能有。
在队列为空时,element和remove会抛出异常NoSuchElementException,而peek和poll返回特殊值null,在队列为满时,add会抛出异常IllegalStateException,而offer只是返回false
实现了此接口就可以当作队列使用
2.3 栈(Deque)
主要有三个方法:
void push(E e);//在头部添加元素,栈的空间可能是有限的,如果栈满了,push会抛出异常IllegalStateException
E pop();//返回头部元素,并且从栈中删除,如果栈为空,会抛出异常NoSuchElementException
E peek();//查看栈头部元素,不修改栈,如果栈为空,返回null
2.4 双端队列(Deque)
主要方法如下:
void addFirst(E e);
void addLast(E e);
E getFirst();
E getLast();
boolean offerFirst(E e);
boolean offerLast(E e);
E peekFirst();
E peekLast();
E pollFirst();
E pollLast();
E removeFirst();
E removeLast();
xxxFirst操作头部,xxxLast操作尾部;
与队列类似,每种操作有两种形式,区别也是在队列为空或满时,处理不同;
为空时,getXXX/removeXXX会抛出异常,而peekXXX/pollXXX会返回null;队列满时,addXXX会抛出异常,offerXXX只是返回false。
注意:栈和队列只是双端队列的特殊情况,它们的方法都可以使用双端队列的方法替代,不过,使用不同的名称和方法,概念上更为清晰。
2.5 迭代器(Deque)
Deque接口还有一个迭代器方法,可以从后往前遍历
Iterator<E> descendingIterator();
3 实现原理
3.1 内部组成
内部实现是双向链表
为了表示链接关系,需要一个节点的概念,节点包括实际的元素,但同时有两个链接,分别指向前一个节点(前驱)和后一个节点(后继),节点是一个内部类,具体定义为:
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指向前一个节点。
LinkedList内部组成就是如下三个实例变量:
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
size表示链表长度,默认为0,first指向头节点,last指向尾节点,初始值都为null。
LinkedList的所有public方法内部操作的都是这三个实例变量
2.3 Add方法
add方法的代码为:
public boolean add(E e) {
linkLast(e);
return true;
}
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++;
}
与ArrayList区别:ArrayList中数组元素连续存放,可以直接随机访问,而在LinkedList中,则必须从头或尾,顺着链接查找,效率比较低。
2.4 根据索引访问元素get方法
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;
}
//size>>1等于size/2,如果索引位置在前半部分 (index<(size>>1)),则从头节点开始查找,否则,从尾节点开始查找。
Node<E> node(int index) {
if (index < (size >> 1)) {
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;
}
}
与ArrayList区别:ArrayList中数组元素连续存放,可以直接随机访问,而在LinkedList中,则必须从头或尾,顺着链接查找,效率比较低。
2.5 根据内容查找元素indexOf方法
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
//o为null时,不能用o.equals(x.item),否则空指针异常
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;
}
2.6 插入元素
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
//插入尾
linkLast(element);
else
//插入道index对应节点的前面
linkBefore(element, node(index));
}
void linkBefore(E e, Node<E> succ) {
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++;
}
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++;
}
2.7 删除元素
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
E unlink(Node<E> x) {
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;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
3 特点分析
LinkedList内部是用双向链表实现的,维护了长度、头节点和尾节点,有如下特点:
- 按需分配空间,不需要预先分配很多空间
- 不可以随机访问,按照索引位置访问效率比较低,必须从头或尾顺着链接找,效率为O(N/2)。
- 不管列表是否已排序,只要是按照内容查找元素,效率都比较低,必须逐个比较,效率为O(N)。
- 在两端添加、删除元素的效率很高,为O(1)。
- 在中间插入、删除元素,要先定位,效率比较低,为O(N),但修改本身的效率很高,效率为O(1)。
LinkedList和ArrayList的使用选择:如果列表长度未知,添加、删除操作比较多,尤其经常从两端进行操作,而按照索引位置访问相对比较少,则LinkedList就是比较理想的选择
无论是ArrayList还是LinkedList,按内容查找元素的效率都很低,都需要逐个进行比较