ArrayList的插入和删除元素的操作会花费线性时间,那么有没有插入和删除元素比较省时的集合呢,看下LinkedList这个实现。
老样子,先看看它实现了那些接口。
之前看过的接口不看了。先看下java.util.Deque。
这个接口扩展了java.util.Queue,Queue也是Java Collections Framework中一个重要的接口,它表示了队列。当然队列本身也属于集合(java.util.Collection是更高层次的抽象)。
Queue提供了添加、删除和获取元素的方法,每种方法提供2个版本。如添加元素,add和offer都可以完成这个操作,区别在于add方法如果添加失败会抛出异常,而offer方法则会返回false。Queue接口只提供队列的抽象概念,但并没有定义元素的操作顺序。其实现可以提供先入先出或者先入后出(栈)这样的性质。
大概了解了java.util.Queue后继续看java.util.Deque。既然Deque扩展了Queue,那它本质上也是队列喽。原来Deque是“double ended queue”的缩写,也就是双端队列的意思,单词读音为“deck”(蛋壳儿。。。)。 so,这个接口定义了在队列两端操作(添加、删除和获取)元素的方法。
像Queue接口一样,Deque也对这些操作方法提供了2个版本。
接下来看一下java.util.AbstractSequentialList这个抽象类,这个类的作用和java.util.AbstractList作用一样,提供一些“骨架”实现。区别在于这个类提供了“按次序访问”的基础,而AbstractList提供了“自由访问”的基础。也就是说,如果我们要实现一个基于链表的集合的话,可以继承这个类;要实现基于数组的集合的话,就继承AbstractList类。
好了,在看LinkedList的源代码之前,还是先思考一下,如果自己实现LinkedList要怎么做。既然是链表,那么内部一定会有一个“链”,而“链”是由“环”组成,说明内部会有“环”这样的概念。每个环都和下一个环相扣,有两个特殊的环,首环和尾环。首先,没有任意一环的下一环是首环,尾环没有下一环;然后,首环和尾环上是不携带数据的(当然普通环也是可以保存null元素滴)。如果再从代码上考虑一下,每一个环都有下一个环的引用,这样可以构成一个链。但每个环也可以即有上一个环的引用,又有下一个环的引用,也可以构成链。它们有什么区别呢?其实这就是所谓的单向链表和双向链表,java.util.LinkedList内部使用双向链表实现。那可以使用单向链表实现吗?那就试试吧。
首先要有头节点和尾节点,设想一下,如果没有它们,我们要保存的数据该放哪。。。然后还是要有一个size的私有变量,这样一些方法就好实现了。
“环”的实现很简单。是一个内部类。
之前在总结ArrayList的时候,看到了当在集合尾部插入元素时,操作时间为常数时间(假设没有进行数组扩展);但当往集合首部插入元素时,内部数组中所有的元素都得往后移动一个位置(内部进行数组的拷贝),这样会花费O(n)的时间。我们看下单向链表实现里的情况。
可以看到,当在集合首部插入元素时,操作时间为常数时间;但当在集合尾部插入元素时,由于我们访问内部数据的入口只有内部的header和tail,又因为是单向链,我们要在集合尾部插入元素时,需要改变tail前一个元素的next,而要找到tail的前一个元素,需要从header开始往下找,所以操作时间还是O(n),看来单向链表还是不能达到我们的目的。。。
好啦,还是看看LinkedList怎么玩儿的吧。
在LinkedList中,只有一个首节点。当集合为空时,首节点的上一个节点和下一个节点都指向自己。可以想到,Linked内部的双向链表是一个环状结构,header作为起点和终点。
看一下LinkedList的添加元素方法:
再看看删除方法:
可见在LinkedList首部和尾部添加和删除元素,操作时间都为常数时间。而在LinkedList中访问元素呢。
尽管做了一些优化,但当要访问元素越靠近链表中间位置时,要花费的时间越长。所以在LinkedList中,基于位置(Index)的操作都是低效的。
OK,小总结一下。LinkedList内部采用双向链表实现,在表的两端进行插入和删除操作花费常数时间;基于位置的操作时低效的,当然查找元素也是低效的。
老样子,先看看它实现了那些接口。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
之前看过的接口不看了。先看下java.util.Deque。
public interface Deque<E> extends Queue<E>
这个接口扩展了java.util.Queue,Queue也是Java Collections Framework中一个重要的接口,它表示了队列。当然队列本身也属于集合(java.util.Collection是更高层次的抽象)。
public interface Queue<E> extends Collection<E>{
boolean add(E e);
boolean offer(E e);
E remove();
E poll();
E element();
E peek();
}
Queue提供了添加、删除和获取元素的方法,每种方法提供2个版本。如添加元素,add和offer都可以完成这个操作,区别在于add方法如果添加失败会抛出异常,而offer方法则会返回false。Queue接口只提供队列的抽象概念,但并没有定义元素的操作顺序。其实现可以提供先入先出或者先入后出(栈)这样的性质。
大概了解了java.util.Queue后继续看java.util.Deque。既然Deque扩展了Queue,那它本质上也是队列喽。原来Deque是“double ended queue”的缩写,也就是双端队列的意思,单词读音为“deck”(蛋壳儿。。。)。 so,这个接口定义了在队列两端操作(添加、删除和获取)元素的方法。
public interface Deque<E> extends Queue<E> {
void addFirst(E e);
void addLast(E e);
boolean offerFirst(E e);
boolean offerLast(E e);
E removeFirst();
E removeLast();
E pollFirst();
E pollLast();
E getFirst();
E getLast();
E peekFirst();
E peekLast();
boolean removeFirstOccurrence(Object o);
boolean removeLastOccurrence(Object o);
void push(E e);
E pop();
Iterator<E> descendingIterator();
}
像Queue接口一样,Deque也对这些操作方法提供了2个版本。
接下来看一下java.util.AbstractSequentialList这个抽象类,这个类的作用和java.util.AbstractList作用一样,提供一些“骨架”实现。区别在于这个类提供了“按次序访问”的基础,而AbstractList提供了“自由访问”的基础。也就是说,如果我们要实现一个基于链表的集合的话,可以继承这个类;要实现基于数组的集合的话,就继承AbstractList类。
好了,在看LinkedList的源代码之前,还是先思考一下,如果自己实现LinkedList要怎么做。既然是链表,那么内部一定会有一个“链”,而“链”是由“环”组成,说明内部会有“环”这样的概念。每个环都和下一个环相扣,有两个特殊的环,首环和尾环。首先,没有任意一环的下一环是首环,尾环没有下一环;然后,首环和尾环上是不携带数据的(当然普通环也是可以保存null元素滴)。如果再从代码上考虑一下,每一个环都有下一个环的引用,这样可以构成一个链。但每个环也可以即有上一个环的引用,又有下一个环的引用,也可以构成链。它们有什么区别呢?其实这就是所谓的单向链表和双向链表,java.util.LinkedList内部使用双向链表实现。那可以使用单向链表实现吗?那就试试吧。
首先要有头节点和尾节点,设想一下,如果没有它们,我们要保存的数据该放哪。。。然后还是要有一个size的私有变量,这样一些方法就好实现了。
/**
* 单向链表实现的LinkedList
* 每个节点含有本节点元素及指向下一个节点的链,
* 最后一个节点的next链为空。
*
* @author BrokenDreams
*/
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>,Deque<E>{
//头节点
private Entry<E> header = new Entry<E>(null, null);
//尾节点
private Entry<E> tail = new Entry<E>(null, null);
private transient int size = 0;
public LinkedList() {
header.next = tail;
}
public LinkedList(Collection<? extends E> c){
this();
addAll(c);
}
“环”的实现很简单。是一个内部类。
private static class Entry<E> {
E element;
Entry<E> next;
public Entry(E element, Entry<E> next) {
super();
this.element = element;
this.next = next;
}
}
之前在总结ArrayList的时候,看到了当在集合尾部插入元素时,操作时间为常数时间(假设没有进行数组扩展);但当往集合首部插入元素时,内部数组中所有的元素都得往后移动一个位置(内部进行数组的拷贝),这样会花费O(n)的时间。我们看下单向链表实现里的情况。
@Override
public boolean add(E e) {
if(size == 0){
addAfter(e, header);
return true;
}
Entry<E> node = header.next;
while(node != null){
if(node.next == tail){
addAfter(e, node);
return true;
}
node = node.next;
}
//never here
return false;
}
private Entry<E> addAfter(E e, Entry<E> entry){
Entry<E> newEntry = new Entry<E>(e, null);
Entry<E> nextEntry = entry.next;
entry.next = newEntry;
newEntry.next = nextEntry;
size++;
modCount++;
return newEntry;
}
@Override
public void addFirst(E e) {
addAfter(e, header);
}
可以看到,当在集合首部插入元素时,操作时间为常数时间;但当在集合尾部插入元素时,由于我们访问内部数据的入口只有内部的header和tail,又因为是单向链,我们要在集合尾部插入元素时,需要改变tail前一个元素的next,而要找到tail的前一个元素,需要从header开始往下找,所以操作时间还是O(n),看来单向链表还是不能达到我们的目的。。。
好啦,还是看看LinkedList怎么玩儿的吧。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
private transient Entry<E> header = new Entry<E>(null, null, null);
private transient int size = 0;
/**
* Constructs an empty list.
*/
public LinkedList() {
header.next = header.previous = header;
}
private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
在LinkedList中,只有一个首节点。当集合为空时,首节点的上一个节点和下一个节点都指向自己。可以想到,Linked内部的双向链表是一个环状结构,header作为起点和终点。
看一下LinkedList的添加元素方法:
/**
* Inserts the specified element at the beginning of this list.
*
* @param e the element to add
*/
public void addFirst(E e) {
addBefore(e, header.next);
}
/**
* Appends the specified element to the end of this list.
*
* <p>This method is equivalent to {@link #add}.
*
* @param e the element to add
*/
public void addLast(E e) {
addBefore(e, header);
}
/**
* Appends the specified element to the end of this list.
*
* <p>This method is equivalent to {@link #addLast}.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
addBefore(e, header);
return true;
}
private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}
再看看删除方法:
/**
* Retrieves and removes the head (first element) of this list.
*
* @return the head of this list
* @throws NoSuchElementException if this list is empty
* @since 1.5
*/
public E remove() {
return removeFirst();
}
/**
* Removes and returns the first element from this list.
*
* @return the first element from this list
* @throws NoSuchElementException if this list is empty
*/
public E removeFirst() {
return remove(header.next);
}
/**
* Removes and returns the last element from this list.
*
* @return the last element from this list
* @throws NoSuchElementException if this list is empty
*/
public E removeLast() {
return remove(header.previous);
}
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();
E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
return result;
}
可见在LinkedList首部和尾部添加和删除元素,操作时间都为常数时间。而在LinkedList中访问元素呢。
/**
* Returns the element at the specified position in this list.
*
* @param index index of the element to return
* @return the element at the specified position in this list
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E get(int index) {
return entry(index).element;
}
/**
* Removes the element at the specified position in this list. Shifts any
* subsequent elements to the left (subtracts one from their indices).
* Returns the element that was removed from the list.
*
* @param index the index of the element to be removed
* @return the element previously at the specified position
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E remove(int index) {
return remove(entry(index));
}
/**
* Returns the indexed entry.
*/
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
尽管做了一些优化,但当要访问元素越靠近链表中间位置时,要花费的时间越长。所以在LinkedList中,基于位置(Index)的操作都是低效的。
OK,小总结一下。LinkedList内部采用双向链表实现,在表的两端进行插入和删除操作花费常数时间;基于位置的操作时低效的,当然查找元素也是低效的。