第1部分 List概括
先回顾一下List的框架图
(01) List 是一个接口,它继承于Collection的接口。它代表着有序的队列。
(02) AbstractList 是一个抽象类,它继承于AbstractCollection。AbstractList实现List接口中除size()、get(int location)之外的函数。
(03) AbstractSequentialList 是一个抽象类,它继承于AbstractList。AbstractSequentialList 实现了“链表中,根据index索引值操作链表的全部函数”。
(04) ArrayList, LinkedList, Vector, Stack是List的4个实现类。
ArrayList 是一个数组队列,相当于动态数组。它由数组实现,随机访问效率高,随机插入、随机删除效率低。
LinkedList 是一个双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList随机访问效率低,但随机插入、随机删除效率低。
Vector 是矢量队列,和ArrayList一样,它也是一个动态数组,由数组实现。但是ArrayList是非线程安全的,而Vector是线程安全的。
Stack 是栈,它继承于Vector。它的特性是:先进后出(FILO, First In Last Out)。
第2部分 List使用场景
学东西的最终目的是为了能够理解、使用它。下面先概括的说明一下各个List的使用场景,后面再分析原因。
如果涉及到“栈”、“队列”、“链表”等操作,应该考虑用List,具体的选择哪个List,根据下面的标准来取舍。
(01) 对于需要快速插入,删除元素,应该使用LinkedList。
(02) 对于需要快速随机访问元素,应该使用ArrayList。
(03) 对于“单线程环境” 或者 “多线程环境,但List仅仅只会被单个线程操作”,此时应该使用非同步的类(如ArrayList)。
对于“多线程环境,且List可能同时被多个线程操作”,此时,应该使用同步的类(如Vector)。
通过下面的测试程序,我们来验证上面的(01)和(02)结论。参考代码如下:
![](https://i-blog.csdnimg.cn/blog_migrate/81178cc93a2a3bb5048d90d76e7ec935.gif)
1 import java.util.*; 2 import java.lang.Class; 3 4 /* 5 * @desc 对比ArrayList和LinkedList的插入、随机读取效率、删除的效率 6 * 7 * @author skywang 8 */ 9 public class ListCompareTest { 10 11 private static final int COUNT = 100000; 12 13 private static LinkedList linkedList = new LinkedList(); 14 private static ArrayList arrayList = new ArrayList(); 15 private static Vector vector = new Vector(); 16 private static Stack stack = new Stack(); 17 18 public static void main(String[] args) { 19 // 换行符 20 System.out.println(); 21 // 插入 22 insertByPosition(stack) ; 23 insertByPosition(vector) ; 24 insertByPosition(linkedList) ; 25 insertByPosition(arrayList) ; 26 27 // 换行符 28 System.out.println(); 29 // 随机读取 30 readByPosition(stack); 31 readByPosition(vector); 32 readByPosition(linkedList); 33 readByPosition(arrayList); 34 35 // 换行符 36 System.out.println(); 37 // 删除 38 deleteByPosition(stack); 39 deleteByPosition(vector); 40 deleteByPosition(linkedList); 41 deleteByPosition(arrayList); 42 } 43 44 // 获取list的名称 45 private static String getListName(List list) { 46 if (list instanceof LinkedList) { 47 return "LinkedList"; 48 } else if (list instanceof ArrayList) { 49 return "ArrayList"; 50 } else if (list instanceof Stack) { 51 return "Stack"; 52 } else if (list instanceof Vector) { 53 return "Vector"; 54 } else { 55 return "List"; 56 } 57 } 58 59 // 向list的指定位置插入COUNT个元素,并统计时间 60 private static void insertByPosition(List list) { 61 long startTime = System.currentTimeMillis(); 62 63 // 向list的位置0插入COUNT个数 64 for (int i=0; i<COUNT; i++) 65 list.add(0, i); 66 67 long endTime = System.currentTimeMillis(); 68 long interval = endTime - startTime; 69 System.out.println(getListName(list) + " : insert "+COUNT+" elements into the 1st position use time:" + interval+" ms"); 70 } 71 72 // 从list的指定位置删除COUNT个元素,并统计时间 73 private static void deleteByPosition(List list) { 74 long startTime = System.currentTimeMillis(); 75 76 // 删除list第一个位置元素 77 for (int i=0; i<COUNT; i++) 78 list.remove(0); 79 80 long endTime = System.currentTimeMillis(); 81 long interval = endTime - startTime; 82 System.out.println(getListName(list) + " : delete "+COUNT+" elements from the 1st position use time:" + interval+" ms"); 83 } 84 85 // 根据position,不断从list中读取元素,并统计时间 86 private static void readByPosition(List list) { 87 long startTime = System.currentTimeMillis(); 88 89 // 读取list元素 90 for (int i=0; i<COUNT; i++) 91 list.get(i); 92 93 long endTime = System.currentTimeMillis(); 94 long interval = endTime - startTime; 95 System.out.println(getListName(list) + " : read "+COUNT+" elements by position use time:" + interval+" ms"); 96 } 97 }
运行结果如下:
Stack : insert 100000 elements into the 1st position use time:1640 ms Vector : insert 100000 elements into the 1st position use time:1607 ms LinkedList : insert 100000 elements into the 1st position use time:29 ms ArrayList : insert 100000 elements into the 1st position use time:1617 ms Stack : read 100000 elements by position use time:9 ms Vector : read 100000 elements by position use time:6 ms LinkedList : read 100000 elements by position use time:10809 ms ArrayList : read 100000 elements by position use time:5 ms Stack : delete 100000 elements from the 1st position use time:1916 ms Vector : delete 100000 elements from the 1st position use time:1910 ms LinkedList : delete 100000 elements from the 1st position use time:15 ms ArrayList : delete 100000 elements from the 1st position use time:1909 ms
从中,我们可以发现:
插入10万个元素,LinkedList所花时间最短:29ms。
删除10万个元素,LinkedList所花时间最短:15ms。
遍历10万个元素,LinkedList所花时间最长:10809 ms;而ArrayList、Stack和Vector则相差不多,都只用了几秒。
考虑到Vector是支持同步的,而Stack又是继承于Vector的;因此,得出结论:
(01) 对于需要快速插入,删除元素,应该使用LinkedList。
(02) 对于需要快速随机访问元素,应该使用ArrayList。
(03) 对于“单线程环境” 或者 “多线程环境,但List仅仅只会被单个线程操作”,此时应该使用非同步的类。
第3部分 LinkedList和ArrayList性能差异分析
下面我们看看为什么LinkedList中插入元素很快,而ArrayList中插入元素很慢!
LinkedList.java中向指定位置插入元素的代码如下:
// 在index前添加节点,且节点的值为element public void add(int index, E element) { addBefore(element, (index==size ? header : entry(index))); } // 获取双向链表中指定位置的节点 private Entry<E> entry(int index) { if (index < 0 || index >= size) throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size); Entry<E> e = header; // 获取index处的节点。 // 若index < 双向链表长度的1/2,则从前向后查找; // 否则,从后向前查找。 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; } // 将节点(节点数据是e)添加到entry节点之前。 private Entry<E> addBefore(E e, Entry<E> entry) { // 新建节点newEntry,将newEntry插入到节点e之前;并且设置newEntry的数据是e Entry<E> newEntry = new Entry<E>(e, entry, entry.previous); // 插入newEntry到链表中 newEntry.previous.next = newEntry; newEntry.next.previous = newEntry; size++; modCount++; return newEntry; }
从中,我们可以看出:通过add(int index, E element)向LinkedList插入元素时。先是在双向链表中找到要插入节点的位置index;找到之后,再插入一个新节点。
双向链表查找index位置的节点时,有一个加速动作:若index < 双向链表长度的1/2,则从前向后查找; 否则,从后向前查找。
接着,我们看看ArrayList.java中向指定位置插入元素的代码。如下:
// 将e添加到ArrayList的指定位置 public void add(int index, E element) { if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); ensureCapacity(size+1); // Increments modCount!! System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; }
ensureCapacity(size+1) 的作用是“确认ArrayList的容量,若容量不够,则增加容量。”
真正耗时的操作是 System.arraycopy(elementData, index, elementData, index + 1, size - index);
Sun JDK包的java/lang/System.java中的arraycopy()声明如下:
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
arraycopy()是个JNI函数,它是在JVM中实现的。sunJDK中看不到源码,不过可以在OpenJDK包中看到的源码。网上有对arraycopy()的分析说明,请参考:System.arraycopy源码分析
实际上,我们只需要了解: System.arraycopy(elementData, index, elementData, index + 1, size - index); 会移动index之后所有元素即可。这就意味着,ArrayList的add(int index, E element)函数,会引起index之后所有元素的改变!
通过上面的分析,我们就能理解为什么LinkedList中插入元素很快,而ArrayList中插入元素很慢。
“删除元素”与“插入元素”的原理类似,这里就不再过多说明。
接下来,我们看看 “为什么LinkedList中随机访问很慢,而ArrayList中随机访问很快”。
先看看LinkedList随机访问的代码
// 返回LinkedList指定位置的元素 public E get(int index) { return entry(index).element; } // 获取双向链表中指定位置的节点 private Entry<E> entry(int index) { if (index < 0 || index >= size) throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size); Entry<E> e = header; // 获取index处的节点。 // 若index < 双向链表长度的1/2,则从前先后查找; // 否则,从后向前查找。 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; }
从中,我们可以看出:通过get(int index)获取LinkedList第index个元素时。先是在双向链表中找到要index位置的元素;找到之后再返回。
双向链表查找index位置的节点时,有一个加速动作:若index < 双向链表长度的1/2,则从前向后查找; 否则,从后向前查找。
下面看看ArrayList随机访问的代码
// 获取index位置的元素值 public E get(int index) { RangeCheck(index); return (E) elementData[index]; } private void RangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); }
从中,我们可以看出:通过get(int index)获取ArrayList第index个元素时。直接返回数组中index位置的元素,而不需要像LinkedList一样进行查找。
第4部分 Vector和ArrayList比较
相同之处
1 它们都是List
它们都继承于AbstractList,并且实现List接口。
ArrayList和Vector的类定义如下:
// ArrayList的定义 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable // Vector的定义 public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}
2 它们都实现了RandomAccess和Cloneable接口
实现RandomAccess接口,意味着它们都支持快速随机访问;
实现Cloneable接口,意味着它们能克隆自己。
3 它们都是通过数组实现的,本质上都是动态数组
ArrayList.java中定义数组elementData用于保存元素
// 保存ArrayList中数据的数组 private transient Object[] elementData;
Vector.java中也定义了数组elementData用于保存元素
// 保存Vector中数据的数组 protected Object[] elementData;
4 它们的默认数组容量是10
若创建ArrayList或Vector时,没指定容量大小;则使用默认容量大小10。
ArrayList的默认构造函数如下:
// ArrayList构造函数。默认容量是10。 public ArrayList() { this(10); }
Vector的默认构造函数如下:
// Vector构造函数。默认容量是10。 public Vector() { this(10); }
5 它们都支持Iterator和listIterator遍历
它们都继承于AbstractList,而AbstractList中分别实现了 “iterator()接口返回Iterator迭代器” 和 “listIterator()返回ListIterator迭代器”。
不同之处
1 线程安全性不一样
ArrayList是非线程安全;
而Vector是线程安全的,它的函数都是synchronized的,即都是支持同步的。
ArrayList适用于单线程,Vector适用于多线程。
2 对序列化支持不同
ArrayList支持序列化,而Vector不支持;即ArrayList有实现java.io.Serializable接口,而Vector没有实现该接口。
3 构造函数个数不同
ArrayList有3个构造函数,而Vector有4个构造函数。Vector除了包括和ArrayList类似的3个构造函数之外,另外的一个构造函数可以指定容量增加系数。
ArrayList的构造函数如下:
// 默认构造函数 ArrayList() // capacity是ArrayList的默认容量大小。当由于增加数据导致容量不足时,容量会添加上一次容量大小的一半。 ArrayList(int capacity) // 创建一个包含collection的ArrayList ArrayList(Collection<? extends E> collection)
Vector的构造函数如下:
// 默认构造函数 Vector() // capacity是Vector的默认容量大小。当由于增加数据导致容量增加时,每次容量会增加一倍。 Vector(int capacity) // 创建一个包含collection的Vector Vector(Collection<? extends E> collection) // capacity是Vector的默认容量大小,capacityIncrement是每次Vector容量增加时的增量值。 Vector(int capacity, int capacityIncrement)
4 容量增加方式不同
逐个添加元素时,若ArrayList容量不足时,“新的容量”=“(原始容量x3)/2 + 1”。
而Vector的容量增长与“增长系数有关”,若指定了“增长系数”,且“增长系数有效(即,大于0)”;那么,每次容量不足时,“新的容量”=“原始容量+增长系数”。若增长系数无效(即,小于/等于0),则“新的容量”=“原始容量 x 2”。
ArrayList中容量增长的主要函数如下:
public void ensureCapacity(int minCapacity) { // 将“修改统计数”+1 modCount++; int oldCapacity = elementData.length; // 若当前容量不足以容纳当前的元素个数,设置 新的容量=“(原始容量x3)/2 + 1” if (minCapacity > oldCapacity) { Object oldData[] = elementData; int newCapacity = (oldCapacity * 3)/2 + 1; if (newCapacity < minCapacity) newCapacity = minCapacity; elementData = Arrays.copyOf(elementData, newCapacity); } }
Vector中容量增长的主要函数如下:
private void ensureCapacityHelper(int minCapacity) { int oldCapacity = elementData.length; // 当Vector的容量不足以容纳当前的全部元素,增加容量大小。 // 若 容量增量系数>0(即capacityIncrement>0),则将容量增大当capacityIncrement // 否则,将容量增大一倍。 if (minCapacity > oldCapacity) { Object[] oldData = elementData; int newCapacity = (capacityIncrement > 0) ? (oldCapacity + capacityIncrement) : (oldCapacity * 2); if (newCapacity < minCapacity) { newCapacity = minCapacity; } elementData = Arrays.copyOf(elementData, newCapacity); } }
5 对Enumeration的支持不同。Vector支持通过Enumeration去遍历,而List不支持
Vector中实现Enumeration的代码如下:
public Enumeration<E> elements() { // 通过匿名类实现Enumeration return new Enumeration<E>() { int count = 0; // 是否存在下一个元素 public boolean hasMoreElements() { return count < elementCount; } // 获取下一个元素 public E nextElement() { synchronized (Vector.this) { if (count < elementCount) { return (E)elementData[count++]; } } throw new NoSuchElementException("Vector Enumeration"); } }; }
第6部分 Stack介绍
Stack简介
Stack是栈。它的特性是:先进后出(FILO, First In Last Out)。
java工具包中的Stack是继承于Vector(矢量队列)的,由于Vector是通过数组实现的,这就意味着,Stack也是通过数组实现的,而非链表。当然,我们也可以将LinkedList当作栈来使用!在“Java 集合系列06之 Vector详细介绍(源码解析)和使用示例”中,已经详细介绍过Vector的数据结构,这里就不再对Stack的数据结构进行说明了。
Stack的继承关系
java.lang.Object ↳ java.util.AbstractCollection<E> ↳ java.util.AbstractList<E> ↳ java.util.Vector<E> ↳ java.util.Stack<E> public class Stack<E> extends Vector<E> {}
Stack和Collection的关系如下图:
Stack的构造函数
Stack只有一个默认构造函数,如下:
Stack()
Stack的API
Stack是栈,它常用的API如下:
boolean empty() synchronized E peek() synchronized E pop() E push(E object) synchronized int search(Object o)
由于Stack和继承于Vector,因此它也包含Vector中的全部API。
第7部分 Stack源码解析(基于JDK1.6.0_45)
Stack的源码非常简单,下面我们对它进行学习。
![](https://i-blog.csdnimg.cn/blog_migrate/81178cc93a2a3bb5048d90d76e7ec935.gif)
1 package java.util; 2 3 public 4 class Stack<E> extends Vector<E> { 5 // 版本ID。这个用于版本升级控制,这里不须理会! 6 private static final long serialVersionUID = 1224463164541339165L; 7 8 // 构造函数 9 public Stack() { 10 } 11 12 // push函数:将元素存入栈顶 13 public E push(E item) { 14 // 将元素存入栈顶。 15 // addElement()的实现在Vector.java中 16 addElement(item); 17 18 return item; 19 } 20 21 // pop函数:返回栈顶元素,并将其从栈中删除 22 public synchronized E pop() { 23 E obj; 24 int len = size(); 25 26 obj = peek(); 27 // 删除栈顶元素,removeElementAt()的实现在Vector.java中 28 removeElementAt(len - 1); 29 30 return obj; 31 } 32 33 // peek函数:返回栈顶元素,不执行删除操作 34 public synchronized E peek() { 35 int len = size(); 36 37 if (len == 0) 38 throw new EmptyStackException(); 39 // 返回栈顶元素,elementAt()具体实现在Vector.java中 40 return elementAt(len - 1); 41 } 42 43 // 栈是否为空 44 public boolean empty() { 45 return size() == 0; 46 } 47 48 // 查找“元素o”在栈中的位置:由栈底向栈顶方向数 49 public synchronized int search(Object o) { 50 // 获取元素索引,elementAt()具体实现在Vector.java中 51 int i = lastIndexOf(o); 52 53 if (i >= 0) { 54 return size() - i; 55 } 56 return -1; 57 } 58 }
总结:
(01) Stack实际上也是通过数组去实现的。
执行push时(即,将元素推入栈中),是通过将元素追加的数组的末尾中。
执行peek时(即,取出栈顶元素,不执行删除),是返回数组末尾的元素。
执行pop时(即,取出栈顶元素,并将该元素从栈中删除),是取出数组末尾的元素,然后将该元素从数组中删除。
(02) Stack继承于Vector,意味着Vector拥有的属性和功能,Stack都拥有。
第8部分 Vector示例
下面我们通过实例学习如何使用Stack
![](https://i-blog.csdnimg.cn/blog_migrate/81178cc93a2a3bb5048d90d76e7ec935.gif)
1 import java.util.Stack; 2 import java.util.Iterator; 3 import java.util.List; 4 5 /** 6 * @desc Stack的测试程序。测试常用API的用法 7 * 8 * @author skywang 9 */ 10 public class StackTest { 11 12 public static void main(String[] args) { 13 Stack stack = new Stack(); 14 // 将1,2,3,4,5添加到栈中 15 for(int i=1; i<6; i++) { 16 stack.push(String.valueOf(i)); 17 } 18 19 // 遍历并打印出该栈 20 iteratorThroughRandomAccess(stack) ; 21 22 // 查找“2”在栈中的位置,并输出 23 int pos = stack.search("2"); 24 System.out.println("the postion of 2 is:"+pos); 25 26 // pup栈顶元素之后,遍历栈 27 stack.pop(); 28 iteratorThroughRandomAccess(stack) ; 29 30 // peek栈顶元素之后,遍历栈 31 String val = (String)stack.peek(); 32 System.out.println("peek:"+val); 33 iteratorThroughRandomAccess(stack) ; 34 35 // 通过Iterator去遍历Stack 36 iteratorThroughIterator(stack) ; 37 } 38 39 /** 40 * 通过快速访问遍历Stack 41 */ 42 public static void iteratorThroughRandomAccess(List list) { 43 String val = null; 44 for (int i=0; i<list.size(); i++) { 45 val = (String)list.get(i); 46 System.out.print(val+" "); 47 } 48 System.out.println(); 49 } 50 51 /** 52 * 通过迭代器遍历Stack 53 */ 54 public static void iteratorThroughIterator(List list) { 55 56 String val = null; 57 for(Iterator iter = list.iterator(); iter.hasNext(); ) { 58 val = (String)iter.next(); 59 System.out.print(val+" "); 60 } 61 System.out.println(); 62 } 63 64 }
运行结果:
1 2 3 4 5 the postion of 2 is:4 1 2 3 4 peek:4 1 2 3 4 1 2 3 4