JDK中集合包Collection和List的源码解读配合大神的一起看，秒懂。

最新推荐文章于 2024-04-17 10:59:38 发布

MARS用了8年

最新推荐文章于 2024-04-17 10:59:38 发布

阅读量3.9k

点赞数

分类专栏： jdk 文章标签：学习 jdk 源码 java 集合

jdk 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

大神总结的目录：http://www.cnblogs.com/skywang12345/p/3323085.html(转载)，仅供个人学习，如有抄袭请包容(我也忘了cry....)

一、总体架构

1) 简介

Java集合是java提供的工具包，包含了常用的数据结构：集合、链表、队列、栈、数组、映射等。Java集合工具包位置是java.util.*

Java集合主要可以划分为4个部分：List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections)、。

2) 架构图

3) 说明

看上面的框架图，先抓住它的主干，即Collection和Map。

1 Collection是一个接口，是高度抽象出来的集合，它包含了集合的基本操作和属性。

Collection包含了List和Set两大分支。

(01) List是一个有序的队列，每一个元素都有它的索引。第一个元素的索引值是0。

List的实现类有LinkedList, ArrayList, Vector, Stack。

(02) Set是一个不允许有重复元素的集合。

Set的实现类有HastSet和TreeSet。HashSet依赖于HashMap，它实际上是通过HashMap实现的；TreeSet依赖于TreeMap，它实际上是通过TreeMap实现的。

2 Map是一个映射接口，即key-value键值对。Map中的每一个元素包含“一个key”和“key对应的value”。

AbstractMap是个抽象类，它实现了Map接口中的大部分API。而HashMap，TreeMap，WeakHashMap都是继承于AbstractMap。

Hashtable虽然继承于Dictionary，但它实现了Map接口。

接下来，再看Iterator。它是遍历集合的工具，即我们通常通过Iterator迭代器来遍历集合。我们说Collection依赖于Iterator，是因为Collection的实现类都要实现iterator()函数，返回一个Iterator对象。

ListIterator是专门为遍历List而存在的。

再看Enumeration，它是JDK 1.0引入的抽象类。作用和Iterator一样，也是遍历集合；但是Enumeration的功能要比Iterator少。在上面的框图中，Enumeration只能在Hashtable, Vector, Stack中使用。

最后，看Arrays和Collections。它们是操作数组、集合的两个工具类。

二、 Collection架构

1) 概要

Collection是一个接口，它主要的两个分支是：List 和Set。

List和Set都是接口，它们继承于Collection。List是有序的队列，List中可以有重复的元素；而Set是数学概念中的集合，Set中没有重复元素！

List和Set都有它们各自的实现类。

为了方便，我们抽象出了AbstractCollection抽象类，它实现了Collection中的绝大部分函数；这样，在Collection的实现类中，我们就可以通过继承AbstractCollection省去重复编码。AbstractList和AbstractSet都继承于AbstractCollection，具体的List实现类继承于AbstractList，而Set的实现类则继承于AbstractSet。

另外，Collection中有一个iterator()函数，它的作用是返回一个Iterator接口。通常，我们通过Iterator迭代器来遍历集合。ListIterator是List接口所特有的，在List接口中，通过ListIterator()返回一个ListIterator对象。

接下来，我们看看各个接口和抽象类的介绍；然后，再对实现类进行详细的了解。

本章内容包括：

1 Collection简介

2 List简介

3 Set简介

4AbstractCollection

5 AbstractList

6 AbstractSet

7 Iterator

8 ListIterator

2) Collection简介

Collection的定义如下：

public interfaceCollection<E> extends Iterable<E> {}

它是一个接口，是高度抽象出来的集合，它包含了集合的基本操作：添加、删除、清空、遍历(读取)、是否为空、获取大小、是否保护某元素等等。

Collection接口的所有子类(直接子类和间接子类)都必须实现2种构造函数：不带参数的构造函数和参数为Collection的构造函数。带参数的构造函数，可以用来转换Collection的类型。

// Collection的API

abstractboolean add(E object)

abstractboolean addAll(Collection<?extends E> collection)

abstract void clear()

abstractboolean contains(Object object)

abstractboolean containsAll(Collection<?> collection)

abstractboolean equals(Object object)

abstract int hashCode()

abstractboolean isEmpty()

abstractIterator<E> iterator()

abstractboolean remove(Object object)

abstractboolean removeAll(Collection<?> collection)

abstractboolean retainAll(Collection<?> collection)

abstract int size()

abstract <T>T[] toArray(T[] array)

abstractObject[] toArray()

3) List简介

List的定义如下：

public interfaceList<E> extends Collection<E> {}

List是一个继承于Collection的接口，即List是集合中的一种。List是有序的队列，List中的每一个元素都有一个索引；第一个元素的索引值是0，往后的元素的索引值依次+1。和Set不同，List中允许有重复的元素。

List的官方介绍如下：

A List is acollection which maintains an ordering for its elements. Every element in theList has an index. Each element can thus be accessed by its index, with thefirst index being zero. Normally, Lists allow duplicate elements, as comparedto Sets, where elements have to be unique.

关于API方面。既然List是继承于Collection接口，它自然就包含了Collection中的全部函数接口；由于List是有序队列，它也额外的有自己的API接口。主要有“添加、删除、获取、修改指定位置的元素”、“获取List中的子队列”等。

// List的API

abstractboolean add(E object)

abstractboolean addAll(Collection<?extends E> collection)

abstract void clear()

abstractboolean contains(Object object)

abstractboolean containsAll(Collection<?> collection)

abstractboolean equals(Object object)

abstract int hashCode()

abstractboolean isEmpty()

abstractIterator<E> iterator()

abstractboolean remove(Object object)

abstractboolean removeAll(Collection<?> collection)

abstractboolean retainAll(Collection<?> collection)

abstract int size()

abstract <T>T[] toArray(T[] array)

abstractObject[] toArray()

// 相比与Collection，List新增的API：

abstract void add(int location, E object)

abstractboolean addAll(int location,Collection<? extends E> collection)

abstract E get(int location)

abstract int indexOf(Object object)

abstract int lastIndexOf(Object object)

abstractListIterator<E> listIterator(int location)

abstractListIterator<E> listIterator()

abstract E remove(int location)

abstract E set(int location, E object)

abstractList<E> subList(intstart, int end)

4) Set简介

Set的定义如下：

public interfaceSet<E> extends Collection<E> {}

Set是一个继承于Collection的接口，即Set也是集合中的一种。Set是没有重复元素的集合。

关于API方面。Set的API和Collection完全一样。

// Set的API

abstractboolean add(E object)

abstractboolean addAll(Collection<?extends E> collection)

abstract void clear()

abstractboolean contains(Object object)

abstractboolean containsAll(Collection<?> collection)

abstractboolean equals(Object object)

abstract int hashCode()

abstractboolean isEmpty()

abstractIterator<E> iterator()

abstract boolean remove(Object object)

abstractboolean removeAll(Collection<?> collection)

abstractboolean retainAll(Collection<?> collection)

abstract int size()

abstract <T>T[] toArray(T[] array)

abstractObject[] toArray()

5) AbstractCollection简介

AbstractCollection的定义如下：

public abstractclass AbstractCollection<E> implements Collection<E> {}

AbstractCollection是一个抽象类，它实现了Collection中除iterator()和size()之外的函数。

AbstractCollection的主要作用：它实现了Collection接口中的大部分函数。从而方便其它类实现Collection，比如ArrayList、LinkedList等，它们这些类想要实现Collection接口，通过继承AbstractCollection就已经实现了大部分的接口了。

6) AbstractList简介

AbstractList的定义如下：

public abstractclass AbstractList<E> extends AbstractCollection<E> implementsList<E> {}

AbstractList是一个继承于AbstractCollection，并且实现List接口的抽象类。它实现了List中除size()、get(int location)之外的函数。

AbstractList的主要作用：它实现了List接口中的大部分函数。从而方便其它类继承List。

另外，和AbstractCollection相比，AbstractList抽象类中，实现了iterator()接口。

7) AbstractSet简介

AbstractSet的定义如下：

public abstractclass AbstractSet<E> extends AbstractCollection<E> implementsSet<E> {}

AbstractSet是一个继承于AbstractCollection，并且实现Set接口的抽象类。由于Set接口和Collection接口中的API完全一样，Set也就没有自己单独的API。和AbstractCollection一样，它实现了List中除iterator()和size()之外的函数。

AbstractSet的主要作用：它实现了Set接口中的大部分函数。从而方便其它类实现Set接口。

8) Iterator简介

Iterator的定义如下：

public interfaceIterator<E> {}

Iterator是一个接口，它是集合的迭代器。集合可以通过Iterator去遍历集合中的元素。Iterator提供的API接口，包括：是否存在下一个元素、获取下一个元素、删除当前元素。

注意：Iterator遍历Collection时，是fail-fast机制的。即，当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。关于fail-fast的详细内容，我们会在后面专门进行说明。

// Iterator的API

abstract booleanhasNext()

abstract E next()

abstract void remove()

9) ListIterator简介

ListIterator的定义如下：

public interfaceListIterator<E> extends Iterator<E> {}

ListIterator是一个继承于Iterator的接口，它是队列迭代器。专门用于便利List，能提供向前/向后遍历。相比于Iterator，它新增了添加、是否存在上一个元素、获取上一个元素等等API接口。

// ListIterator的API

// 继承于Iterator的接口

abstract booleanhasNext()

abstract E next()

abstract voidremove()

// 新增API接口

abstract voidadd(E object)

abstract booleanhasPrevious()

abstract intnextIndex()

abstract Eprevious()

abstract intpreviousIndex()

abstract voidset(E object)

三、 ArrayList类

1) ArrayList概要

上一章，我们学习了Collection的架构。这一章开始，我们对Collection的具体实现类进行讲解；首先，讲解List，而List中ArrayList又最为常用。因此，本章我们讲解ArrayList。先对ArrayList有个整体认识，再学习它的源码，最后再通过例子来学习如何使用它。内容包括：

第1部分 ArrayList简介

第2部分 ArrayList数据结构

第3部分 ArrayList源码解析(基于JDK1.6.0_45)

第4部分 ArrayList遍历方式

第5部分 toArray()异常

第6部分 ArrayList示例

2) ArrayList简介

ArrayList 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess,Cloneable, java.io.Serializable这些接口。

ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。

ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

ArrayList构造函数

// 默认构造函数

ArrayList()

// capacity是ArrayList的默认容量大小。当由于增加数据导致容量不足时，容量会添加上一次容量大小的一半。

ArrayList(intcapacity)

// 创建一个包含collection的ArrayList

ArrayList(Collection<?extends E> collection)

ArrayList的API

// Collection中定义的API

boolean add(E object)

boolean addAll(Collection<? extendsE> collection)

void clear()

boolean contains(Object object)

boolean containsAll(Collection<?>collection)

boolean equals(Object object)

int hashCode()

boolean isEmpty()

Iterator<E> iterator()

boolean remove(Object object)

boolean removeAll(Collection<?>collection)

boolean retainAll(Collection<?>collection)

int size()

<T> T[] toArray(T[] array)

Object[] toArray()

//AbstractCollection中定义的API

void add(int location, E object)

boolean addAll(int location,Collection<? extends E> collection)

E get(int location)

int indexOf(Object object)

int lastIndexOf(Object object)

ListIterator<E> listIterator(int location)

ListIterator<E> listIterator()

E remove(int location)

E set(int location, E object)

List<E> subList(int start, int end)

// ArrayList新增的API

Object clone()

void ensureCapacity(int minimumCapacity)

void trimToSize()

void removeRange(int fromIndex, inttoIndex)

3) ArrayList数据结构

ArrayList的继承关系

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.ArrayList<E>

public classArrayList<E> extends AbstractList<E>

implements List<E>, RandomAccess,Cloneable, java.io.Serializable {}

ArrayList包含了两个重要的对象：elementData 和 size。

(01) elementData 是"Object[]类型的数组"，它保存了添加到ArrayList中的元素。实际上，elementData是个动态数组，我们能通过构造函数 ArrayList(int initialCapacity)来执行它的初始容量为initialCapacity；如果通过不含参数的构造函数ArrayList()来创建ArrayList，则elementData的容量默认是10。elementData数组的大小会根据ArrayList容量的增长而动态的增长，具体的增长方式，请参考源码分析中的ensureCapacity()函数。

(02) size 则是动态数组的实际大小。

4) ArrayList源码解析

为了更了解ArrayList的原理，对ArrayList源码代码作出分析。ArrayList是通过数组实现的，源码比较容易理解。

总结：

(01) ArrayList 实际上是通过一个数组去保存数据的。当我们构造ArrayList时；若使用默认构造函数，则ArrayList的默认容量大小是10。

(02) 当ArrayList容量不足以容纳全部元素时，ArrayList会重新设置容量：新的容量=“(原始容量x3)/2 + 1”。

(03) ArrayList的克隆函数，即是将全部元素克隆到一个数组中。

(04) ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写入“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。

5) ArrayList遍历方式

ArrayList支持3种遍历方式

(01) 第一种，通过迭代器遍历。即通过Iterator去遍历。

Integer value =null;

Iterator iter =list.iterator();

while(iter.hasNext()) {

value = (Integer)iter.next();

}

(02) 第二种，随机访问，通过索引值去遍历。

由于ArrayList实现了RandomAccess接口，它支持通过索引值去随机访问元素。

Integer value =null;

int size =list.size();

for (int i=0;i<size; i++) {

value = (Integer)list.get(i);

}

(03) 第三种，for循环遍历。如下：

Integer value =null;

for (Integerinteg:list) {

value = integ;

}

遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高，而使用迭代器的效率最低！

System.arraycopy(elementData,0, a, 0, size); // 复制功能

6) toArray()异常

当我们调用ArrayList中的toArray()，可能遇到过抛出“java.lang.ClassCastException”异常的情况。下面我们说说这是怎么回事。

ArrayList提供了2个toArray()函数：

Object[] toArray()

<T> T[]toArray(T[] contents)

调用 toArray() 函数会抛出“java.lang.ClassCastException”异常，但是调用toArray(T[] contents) 能正常返回 T[]。

toArray() 会抛出异常是因为 toArray() 返回的是Object[] 数组，将 Object[] 转换为其它类型(如如，将Object[]转换为的Integer[])则会抛出“java.lang.ClassCastException”异常，因为Java不支持向下转型。具体的可以参考前面ArrayList.java的源码介绍部分的toArray()。

解决该问题的办法是调用 <T>T[] toArray(T[] contents) ，而不是 Object[] toArray()。

调用 toArray(T[]contents) 返回T[]的可以通过以下几种方式实现。

// toArray(T[]contents)调用方式一

public staticInteger[] vectorToArray1(ArrayList<Integer> v) {

Integer[] newText = new Integer[v.size()];

v.toArray(newText);

return newText;

}

// toArray(T[]contents)调用方式二。最常用！

public static Integer[]vectorToArray2(ArrayList<Integer> v) {

Integer[] newText =(Integer[])v.toArray(new Integer[0]);

return newText;

}

// toArray(T[]contents)调用方式三

public staticInteger[] vectorToArray3(ArrayList<Integer> v) {

Integer[] newText = new Integer[v.size()];

Integer[] newStrings =(Integer[])v.toArray(newText);

return newStrings;

}

7) ArrayList示例

// 创建ArrayList

ArrayList list =new ArrayList();

// 将“”

list.add("1");

list.add("2");

list.add("3");

list.add("4");

// 将下面的元素添加到第1个位置

list.add(0, "5");

// 获取第1个元素

System.out.println("thefirst element is: "+ list.get(0));

// 删除“3”

list.remove("3");

// 获取ArrayList的大小

System.out.println("Arraylistsize=: "+ list.size());

// 判断list中是否包含"3"

System.out.println("ArrayListcontains 3 is: "+ list.contains(3));

// 设置第2个元素为10

list.set(1,"10");

// 通过Iterator遍历ArrayList

for(Iterator iter= list.iterator(); iter.hasNext(); ) {

System.out.println("next is: "+iter.next());

}

// 将ArrayList转换为数组

String[] arr =(String[])list.toArray(new String[0]);

for (Stringstr:arr)

System.out.println("str: "+ str);

// 清空ArrayList

list.clear();

// 判断ArrayList是否为空

System.out.println("ArrayListis empty: "+ list.isEmpty());

四、 fail-fast总结(一种遍历机制)

1) 概要

我们已经学习了ArrayList。接下来，我们以ArrayList为例，对Iterator的fail-fast机制进行了解。内容包括：：

1 fail-fast简介

2 fail-fast示例

3 fail-fast解决办法

4 fail-fast原理

5 解决fail-fast的原理

2) fail-fast简介

fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。

例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。

在详细介绍fail-fast机制的原理之前，先通过一个示例来认识fail-fast。

3) fail-fast示例

示例代码：(FastFailTest.java)

importjava.util.*;

importjava.util.concurrent.*;

* @desc java集合中Fast-Fail的测试程序。

* fast-fail事件产生的条件：当多个线程对Collection进行操作时，若其中某一个线程通过iterator去遍历集合时，该集合的内容被其他线程所改变；则会抛出ConcurrentModificationException异常。

* fast-fail解决办法：通过util.concurrent集合包下的相应类去处理，则不会产生fast-fail事件。

* 本例中，分别测试ArrayList和CopyOnWriteArrayList这两种情况。ArrayList会产生fast-fail事件，而CopyOnWriteArrayList不会产生fast-fail事件。

* (01)使用ArrayList时，会产生fast-fail事件，抛出ConcurrentModificationException异常；定义如下：

* private static List<String> list = new ArrayList<String>();

* (02)使用时CopyOnWriteArrayList，不会产生fast-fail事件；定义如下：

* private static List<String> list = newCopyOnWriteArrayList<String>();

* @author skywang

public classFastFailTest {

private static List<String> list =new ArrayList<String>();

//private static List<String> list =new CopyOnWriteArrayList<String>();

public static void main(String[] args) {

// 同时启动两个线程对list进行操作！

new ThreadOne().start();

new ThreadTwo().start();

}

private static void printAll() {

System.out.println("");

String value = null;

Iterator iter = list.iterator();

while(iter.hasNext()) {

value = (String)iter.next();

System.out.print(value+",");

}

/**

* 向list中依次添加0,1,2,3,4,5，每添加一个数之后，就通过printAll()遍历整个list

private static class ThreadOne extendsThread {

public void run() {

int i = 0;

while (i<6) {

list.add(String.valueOf(i));

printAll();

i++;

}

/**

* 向list中依次添加10,11,12,13,14,15，每添加一个数之后，就通过printAll()遍历整个list

private static class ThreadTwo extendsThread {

public void run() {

int i = 10;

while (i<16) {

list.add(String.valueOf(i));

printAll();

i++;

}

运行结果：

运行该代码，抛出异常java.util.ConcurrentModificationException！即，产生fail-fast事件！

结果说明：

(01) FastFailTest中通过 new ThreadOne().start() 和 new ThreadTwo().start() 同时启动两个线程去操作list。

ThreadOne线程：向list中依次添加0,1,2,3,4,5。每添加一个数之后，就通过printAll()遍历整个list。

ThreadTwo线程：向list中依次添加10,11,12,13,14,15。每添加一个数之后，就通过printAll()遍历整个list。

(02) 当某一个线程遍历list的过程中，list的内容被另外一个线程所改变了；就会抛出ConcurrentModificationException异常，产生fail-fast事件。

4) fail-fast解决办法

fail-fast机制，是一种错误检测机制。它只能被用来检测错误，因为JDK并不保证fail-fast机制一定会发生。若在多线程环境下使用fail-fast机制的集合，建议使用“java.util.concurrent包下的类”去取代“java.util包下的类”。

所以，本例中只需要将ArrayList替换成java.util.concurrent包下对应的类即可。

即，将代码

private staticList<String> list = new ArrayList<String>();

替换为

private staticList<String> list = new CopyOnWriteArrayList<String>();

则可以解决该办法。

5) fail-fast原理

产生fail-fast事件，是通过抛出ConcurrentModificationException异常来触发的。

那么，ArrayList是如何抛出ConcurrentModificationException异常的呢?

我们知道，ConcurrentModificationException是在操作Iterator时抛出的异常。我们先看看Iterator的源码。ArrayList的Iterator是在父类AbstractList.java中实现的。代码如下：

从中，我们可以发现在调用 next() 和 remove()时，都会执行 checkForComodification()。若“modCount 不等于 expectedModCount”，则抛出ConcurrentModificationException异常，产生fail-fast事件。

要搞明白 fail-fast机制，我们就要需要理解什么时候“modCount 不等于 expectedModCount”！

从Itr类中，我们知道 expectedModCount 在创建Itr对象时，被赋值为 modCount。通过Itr，我们知道：expectedModCount不可能被修改为不等于 modCount。所以，需要考证的就是modCount何时会被修改。

接下来，我们查看ArrayList的源码，来看看modCount是如何被修改的。

从中，我们发现：无论是add()、remove()，还是clear()，只要涉及到修改集合中的元素个数时，都会改变modCount的值。

接下来，我们再系统的梳理一下fail-fast是怎么产生的。步骤如下：

(01) 新建了一个ArrayList，名称为arrayList。

(02) 向arrayList中添加内容。

(03) 新建一个“线程a”，并在“线程a”中通过Iterator反复的读取arrayList的值。

(04) 新建一个“线程b”，在“线程b”中删除arrayList中的一个“节点A”。

(05) 这时，就会产生有趣的事件了。

在某一时刻，“线程a”创建了arrayList的Iterator。此时“节点A”仍然存在于arrayList中，创建arrayList时，expectedModCount = modCount(假设它们此时的值为N)。

在“线程a”在遍历arrayList过程中的某一时刻，“线程b”执行了，并且“线程b”删除了arrayList中的“节点A”。“线程b”执行remove()进行删除操作时，在remove()中执行了“modCount++”，此时modCount变成了N+1！

“线程a”接着遍历，当它执行到next()函数时，调用checkForComodification()比较“expectedModCount”和“modCount”的大小；而“expectedModCount=N”，“modCount=N+1”,这样，便抛出ConcurrentModificationException异常，产生fail-fast事件。

至此，我们就完全了解了fail-fast是如何产生的！

即，当多个线程对同一个集合进行操作的时候，某线程访问集合的过程中，该集合的内容被其他线程所改变(即其它线程通过add、remove、clear等方法，改变了modCount的值)；这时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。

6) 解决fail-fast的原理

上面，说明了“解决fail-fast机制的办法”，也知道了“fail-fast产生的根本原因”。接下来，我们再进一步谈谈java.util.concurrent包中是如何解决fail-fast事件的。

还是以和ArrayList对应的CopyOnWriteArrayList进行说明。我们先看看CopyOnWriteArrayList的源码：查看JDK

从中，我们可以看出:

(01) 和ArrayList继承于AbstractList不同，CopyOnWriteArrayList没有继承于AbstractList，它仅仅只是实现了List接口。

(02) ArrayList的iterator()函数返回的Iterator是在AbstractList中实现的；而CopyOnWriteArrayList是自己实现Iterator。

(03) ArrayList的Iterator实现类中调用next()时，会“调用checkForComodification()比较‘expectedModCount’和‘modCount’的大小”；但是，CopyOnWriteArrayList的Iterator实现类中，没有所谓的checkForComodification()，更不会抛出ConcurrentModificationException异常！

五、 LinkedList类

1) 概要

我们已经学习了ArrayList，并了解了fail-fast机制。这一章我们接着学习List的实现类——LinkedList。

和学习ArrayList一样，接下来呢，我们先对LinkedList有个整体认识，然后再学习它的源码；最后再通过实例来学会使用LinkedList。内容包括：

第1部分 LinkedList介绍

第2部分 LinkedList数据结构

第3部分 LinkedList源码解析(基于JDK1.6.0_45)

第4部分 LinkedList遍历方式

第5部分 LinkedList示例

2) LinkedList介绍

LinkedList简介

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。

LinkedList 实现 List 接口，能对它进行队列操作。

LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。

LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。

LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

LinkedList 是非同步的。

// 默认构造函数

LinkedList()

// 创建一个LinkedList，保护Collection中的全部元素。

LinkedList(Collection<?extends E> collection)

LinkedList的API

boolean add(E object)

void add(int location, E object)

boolean addAll(Collection<? extends E>collection)

boolean addAll(int location, Collection<?extends E> collection)

void addFirst(E object)

void addLast(E object)

void clear()

Object clone()

boolean contains(Object object)

Iterator<E> descendingIterator()

E element()

E get(int location)

E getFirst()

E getLast()

int indexOf(Object object)

int lastIndexOf(Object object)

ListIterator<E> listIterator(int location)

boolean offer(E o)

boolean offerFirst(E e)

boolean offerLast(E e)

E peek()

E peekFirst()

E peekLast()

E poll()

E pollFirst()

E pollLast()

E pop()

void push(E e)

E remove()

E remove(int location)

boolean remove(Object object)

E removeFirst()

boolean removeFirstOccurrence(Object o)

E removeLast()

boolean removeLastOccurrence(Object o)

E set(int location, E object)

int size()

<T> T[] toArray(T[] contents)

Object[] toArray()

AbstractSequentialList简介

在介绍LinkedList的源码之前，先介绍一下AbstractSequentialList。毕竟，LinkedList是AbstractSequentialList的子类。

AbstractSequentialList实现了get(int index)、set(int index, E element)、add(int index, Eelement) 和 remove(int index)这些函数。这些接口都是随机访问List的，LinkedList是双向链表；既然它继承于AbstractSequentialList，就相当于已经实现了“get(intindex)这些接口”。

此外，我们若需要通过AbstractSequentialList自己实现一个列表，只需要扩展此类，并提供 listIterator() 和 size() 方法的实现即可。若要实现不可修改的列表，则需要实现列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法即可。

3) LinkedList数据结构

LinkedList的继承关系

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.AbstractSequentialList<E>

java.util.LinkedList<E>

public classLinkedList<E>

extends AbstractSequentialList<E>

implements List<E>, Deque<E>,Cloneable, java.io.Serializable {}

LinkedList的本质是双向链表。

(01) LinkedList继承于AbstractSequentialList，并且实现了Dequeue接口。

(02) LinkedList包含两个重要的成员：header 和 size。

　　header是双向链表的表头，它是双向链表节点所对应的类Entry的实例。Entry中包含成员变量： previous, next, element。其中，previous是该节点的上一个节点，next是该节点的下一个节点，element是该节点所包含的值。

　　size是双向链表中节点的个数。

4) LinkedList源码解析

为了更了解LinkedList的原理，下面对LinkedList源码代码作出分析。

在阅读源码之前，我们先对LinkedList的整体实现进行大致说明：

LinkedList实际上是通过双向链表去实现的。既然是双向链表，那么它的顺序访问会非常高效，而随机访问效率比较低。

既然LinkedList是通过双向链表的，但是它也实现了List接口{也就是说，它实现了get(int location)、remove(int location)等“根据索引值来获取、删除节点的函数”}。LinkedList是如何实现List的这些接口的，如何将“双向链表和索引值联系起来的”？

实际原理非常简单，它就是通过一个计数索引值来实现的。例如，当我们调用get(int location)时，首先会比较“location”和“双向链表长度的1/2”；若前者大，则从链表头开始往后查找，直到location位置；否则，从链表末尾开始先前查找，直到location位置。

这就是“双线链表和索引值联系起来”的方法。

好了，接下来开始阅读源码(只要理解双向链表，那么LinkedList的源码很容易理解的)。

总结：

(01) LinkedList 实际上是通过双向链表去实现的。

它包含一个非常重要的内部类：Entry。Entry是双向链表节点所对应的数据结构，它包括的属性有：当前节点所包含的值，上一个节点，下一个节点。

(02) 从LinkedList的实现方式中可以发现，它不存在LinkedList容量不足的问题。

(03) LinkedList的克隆函数，即是将全部元素克隆到一个新的LinkedList对象中。

(04) LinkedList实现java.io.Serializable。当写入到输出流时，先写入“容量”，再依次写入“每一个节点保护的值”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。

(05) 由于LinkedList实现了Deque，而Deque接口定义了在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。

总结起来如下表格：

第一个元素（头部）最后一个元素（尾部）

抛出异常特殊值抛出异常特殊值

插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e)

移除 removeFirst() pollFirst() removeLast() pollLast()

检查 getFirst() peekFirst() getLast() peekLast()

(06) LinkedList可以作为FIFO(先进先出)的队列，作为FIFO的队列时，下表的方法等价：

队列方法等效方法

add(e) addLast(e)

offer(e) offerLast(e)

remove() removeFirst()

poll() pollFirst()

element() getFirst()

peek() peekFirst()

(07) LinkedList可以作为LIFO(后进先出)的栈，作为LIFO的栈时，下表的方法等价：

栈方法等效方法

push(e) addFirst(e)

pop() removeFirst()

peek() peekFirst()

5) LinkedList遍历方式

LinkedList支持多种遍历方式。建议不要采用随机访问的方式去遍历LinkedList，而采用逐个遍历的方式。

(01) 第一种，通过迭代器遍历。即通过Iterator去遍历。

for(Iteratoriter = list.iterator(); iter.hasNext();) iter.next();

(02) 通过快速随机访问遍历LinkedList

int size =list.size();

for (int i=0;i<size; i++) {

list.get(i);

}

(03) 通过另外一种for循环来遍历LinkedList

for (Integerinteg:list);

(04) 通过pollFirst()来遍历LinkedList

while(list.pollFirst()!= null);

(05) 通过pollLast()来遍历LinkedList

while(list.pollLast()!= null);

(06) 通过removeFirst()来遍历LinkedList

try {

while(list.removeFirst() != null)

;

} catch(NoSuchElementException e) {

}

(07) 通过removeLast()来遍历LinkedList

try {

while(list.removeLast() != null)

;

} catch(NoSuchElementException e) {}

测试这些遍历方式效率如下：

执行结果：

iteratorLinkedListThruIterator：8 ms

iteratorLinkedListThruForeach：3724 ms

iteratorThroughFor2：5 ms

iteratorThroughPollFirst：8 ms

iteratorThroughPollLast：6 ms

iteratorThroughRemoveFirst：2 ms

iteratorThroughRemoveLast：2 ms

由此可见，遍历LinkedList时，使用removeFist()或removeLast()效率最高。但用它们遍历时，会删除原始数据；若单纯只读取，而不删除，应该使用第3种遍历方式。

无论如何，千万不要通过随机访问去遍历LinkedList！

6) LinkedList示例

importjava.util.List;

importjava.util.Iterator;

importjava.util.LinkedList;

importjava.util.NoSuchElementException;

* @desc LinkedList测试程序。

* @author skywang

* @email kuiwu-wang@163.com

public class LinkedListTest{

public static void main(String[] args) {

// 测试LinkedList的API

testLinkedListAPIs() ;

// 将LinkedList当作 LIFO(后进先出)的堆栈

useLinkedListAsLIFO();

// 将LinkedList当作 FIFO(先进先出)的队列

useLinkedListAsFIFO();

}

* 测试LinkedList中部分API

private static void testLinkedListAPIs() {

String val = null;

//LinkedList llist;

//llist.offer("10");

// 新建一个LinkedList

LinkedList llist = new LinkedList();

//---- 添加操作 ----

// 依次添加1,2,3

llist.add("1");

llist.add("2");

llist.add("3");

// 将“4”添加到第一个位置

llist.add(1, "4");

System.out.println("\nTest\"addFirst(), removeFirst(), getFirst()\"");

// (01) 将“10”添加到第一个位置。失败的话，抛出异常！

llist.addFirst("10");