集合框架源码分析二（抽象类篇）

一。AbstractCollection

public abstract class AbstractCollection<E> implements Collection<E> {
    /**
     * 唯一构造方法
     */
    protected AbstractCollection() {
    }

    // Query Operations

    /**
     *
     * 返回集合中元素的迭代器
     */
    public abstract Iterator<E> iterator();

    public abstract int size();

    public boolean isEmpty() {
	return size() == 0;   //size=0则此方法返回true
    }

    public boolean contains(Object o) {
	Iterator<E> e = iterator();   //获取此集合的迭代器
	if (o==null) {               
	    while (e.hasNext())      
		if (e.next()==null)   //如果此集合允许null元素，找到则返回true
		    return true;
	} else {
	    while (e.hasNext())
		if (o.equals(e.next()))
		    return true;
	}
	return false;
    }

    /**
     * 此方法是同步的，即使在遍历集合的过程中发现集合已经改变，任然可以返回
     * 正确的结果
     *
     * 此方法等同于:
     *
     * List<E> list = new ArrayList<E>(size());
     * for (E e : this)
     *     list.add(e);
     * return list.toArray();
     */
    public Object[] toArray() {
	Object[] r = new Object[size()]; //新建一个对象数组，长度为集合的长度
        Iterator<E> it = iterator();
	for (int i = 0; i < r.length; i++) {    //遍历赋值
	    if (! it.hasNext())	// 遍历过程中，集合中有元素被移除，长度减少
		return Arrays.copyOf(r, i);  //则仅返回长度为i的数组，i=当前集合长度
	    r[i] = it.next();
	}
        //如果遍历完后发现集合还有更多的元素，即在遍历时有元素被添加进集合，调用
        //finishToArray方法添加剩余的元素
	return it.hasNext() ? finishToArray(r, it) : r;
    }

   
    public <T> T[] toArray(T[] a) {
        int size = size();      //当前集合长度
        T[] r = a.length >= size ? a :  //如果a的长度大于等于size，把a赋给r，否则新建一个元素类型为a元素类型，size长度的数组
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);
        Iterator<E> it = iterator();

	for (int i = 0; i < r.length; i++) {
	    if (! it.hasNext()) { 遍历过程中，集合中有元素被移除，长度减少.或遍历集合结束
		if (a != r)   //表明是新建的数组
		    return Arrays.copyOf(r, i);
		r[i] = null; // 表明是a，则多加一个null结束符
		return r;
	    }
	    r[i] = (T)it.next();
	}
	return it.hasNext() ? finishToArray(r, it) : r;
    }

    /**
     * 当it还有更多的元素，重新分配数组。并把剩余元素添加进数组
     */
   	private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
		int i = r.length;         //原来数组长度存入i中
		while (it.hasNext()) {
			int cap = r.length;   
			if (i == cap) {   //表明未重新分配数组长度
				int newCap = ((cap / 2) + 1) * 3;   //新数组长度的计算公式，大约扩充1.5倍
				if (newCap <= cap) { // 如果分配后发生了整型溢出
					if (cap == Integer.MAX_VALUE)
						throw new OutOfMemoryError("Required array size too large");
					newCap = Integer.MAX_VALUE;    
				}
				r = Arrays.copyOf(r, newCap); //新建一个长度为newCap的数组，并把r中数据存入
			}
			r[i++] = (T) it.next();   //添加集合剩余元素到新数组
		}
		// 修剪多余的长度
		return (i == r.length) ? r : Arrays.copyOf(r, i);
	}

    // Modification Operations

    /**
     * 调用此方法总是抛出一个异常，需要子类去重写此方法
     */
    public boolean add(E e) {
	throw new UnsupportedOperationException();
    }

    /**
     * 此方法会首先在集合中查找指定元素o，如果找到就移除它
     * 移除的是第一个找到的匹配的值
     */
    public boolean remove(Object o) {
	Iterator<E> e = iterator();
	if (o==null) {       //集合支持null元素
	    while (e.hasNext()) {
		if (e.next()==null) {
		    e.remove();     
		    return true;
		}
	    }
	} else {
	    while (e.hasNext()) {
		if (o.equals(e.next())) {
		    e.remove();
		    return true;
		}
	    }
	}
	return false;
    }


    // Bulk Operations

   
    public boolean containsAll(Collection<?> c) {
	Iterator<?> e = c.iterator();
	while (e.hasNext())
	    if (!contains(e.next()))  //如果c中有一个元素不在本集合中则返回false
		return false;
	return true;
    }

    /**
     * 此方法将抛出一个UnsupportedOperationException，除非子类重写了add方法
     */
    public boolean addAll(Collection<? extends E> c) {
	boolean modified = false;
	Iterator<? extends E> e = c.iterator();
	while (e.hasNext()) {
		if (add(e.next()))   //如果有一个元素添加失败就返回false
			modified = true;
	}
	return modified;
    }


    public boolean removeAll(Collection<?> c) {
	boolean modified = false;
	Iterator<?> e = iterator();
	while (e.hasNext()) {
		if (c.contains(e.next())) { //如果c中元素也保含在本集合中则移除它
			e.remove();
			modified = true;
		}
	}
	return modified;
	}

   public boolean retainAll(Collection<?> c) {
		boolean modified = false;
		Iterator<E> e = iterator();
		while (e.hasNext()) {
			if (!c.contains(e.next())) {  //遍历集合元素，如果元素不包含在c中，则移除此元素
				e.remove();               //取的是交集
				modified = true;
			}
		}
		return modified;
	}


    public void clear() {
	Iterator<E> e = iterator();
	while (e.hasNext()) {    //依次调用next和remove方法
	    e.next();
	    e.remove();
	}
    }


    //  String conversion

   /**
	 * 重写toString方法,返回格式：[e.toString, e2.toString, ...]
	 * */
	public String toString() {
		Iterator<E> i = iterator();
		if (!i.hasNext())   //如果集合为空返回[]
			return "[]";
		StringBuilder sb = new StringBuilder();
		sb.append('[');
		for (;;) {
			E e = i.next();
			sb.append(e == this ? "(this Collection)" : e);
			if (!i.hasNext())
				return sb.append(']').toString();
			sb.append(", ");
		}
	}

}

二。AbstractList<E>

public abstract class AbstractList<E> extends AbstractCollection<E> implements
		List<E> {
	/**
	 * 唯一构造方法
	 */
	protected AbstractList() {
	}

	/**
	 * 添加指定元素到List的最后
	 * 此方法将抛出一个UnsupportedOperationException除非List的子类重写了add(int,E)方法
	 * 
	 */
	public boolean add(E e) {
		add(size(), e);	//如果List子类没有重写此方法会抛出一个异常
		return true;
	}

	abstract public E get(int index);

	/**
	 * 总是抛出一个UnsupportedOperationException，除非子类重写了此方法
	 */
	public E set(int index, E element) {
		throw new UnsupportedOperationException();
	}

	/**
	 * 总是抛出一个UnsupportedOperationException，除非子类重写了此方法
	 */
	public void add(int index, E element) {
		throw new UnsupportedOperationException();
	}

	/**
	 * 总是抛出一个UnsupportedOperationException，除非子类重写了此方法
	 */
	public E remove(int index) {
		throw new UnsupportedOperationException();
	}

	// Search Operations
	
	public int indexOf(Object o) {
		ListIterator<E> e = listIterator();   //使用listIterator
		if (o == null) {
			while (e.hasNext())
				if (e.next() == null)
					return e.previousIndex();
		} else {
			while (e.hasNext())
				if (o.equals(e.next()))
					return e.previousIndex();
		}
		return -1;   //返回-1表示遍历到了集合最后都没有找到指定元素o
	}


	public int lastIndexOf(Object o) {
		ListIterator<E> e = listIterator(size());
		if (o == null) {
			while (e.hasPrevious())       //从后面开始遍历
				if (e.previous() == null)
					return e.nextIndex();
		} else {
			while (e.hasPrevious())
				if (o.equals(e.previous()))
					return e.nextIndex();
		}
		return -1;
	}

	// Bulk Operations

	public void clear() {
		removeRange(0, size());   //清空指定范围的元素
	}

	
	public boolean addAll(int index, Collection<? extends E> c) {
		boolean modified = false;
		Iterator<? extends E> e = c.iterator();
		while (e.hasNext()) {
			add(index++, e.next());  //把c中元素添加到指定位置,此add方法由子类实现
			modified = true;
		}
		return modified;
	}

	// Iterators


	public Iterator<E> iterator() {
		return new Itr();      //返回实现了Iterator接口的类
	}

	
	public ListIterator<E> listIterator() {
		return listIterator(0);   //返回一个listIterator，遍历起点为0
	}

	
	public ListIterator<E> listIterator(final int index) {
		if (index < 0 || index > size())       //index超出集合范围则抛出越界异常
			throw new IndexOutOfBoundsException("Index: " + index);

		return new ListItr(index);
	}
    
	/**
	 * 实现了Iterator接口中的所有方法
	 * */
	private class Itr implements Iterator<E> {
		/**
		 * 游标,随后调用next时返回的元素的索引
		 */
		int cursor = 0;

		/**
		 * 最近一次调用next或previous时返回的元素的索引
		 */
		int lastRet = -1;

		/**
         * 如果他们不相等说明迭代器检查到了并发操作
		 */
		int expectedModCount = modCount;

		public boolean hasNext() {
			return cursor != size();    //根据cursor大小来判断集合是否还有更多的元素
		}

		public E next() {
			checkForComodification();   //检测是否是并发操作
			try {
				E next = get(cursor);  //返回索引为cursor的元素
				lastRet = cursor++;    //调用next时cursor自增了
				return next;
			} catch (IndexOutOfBoundsException e) {  //如果索引超出集合边界则抛出IndexOutOfBoundsException
				checkForComodification();     //如果IndexOutOfBoundsException是由并发操作引起的则抛出NoSuchElementException
				throw new NoSuchElementException();
			}
		}

		public void remove() {
			if (lastRet == -1)   //这是为了判断是否调用了next方法
				throw new IllegalStateException();  //否则抛出IllegalStateException
			checkForComodification();   //同样要检查是否是并发操作

			try {
				AbstractList.this.remove(lastRet);  //迭代器的remove方法即是List的remove方法
				if (lastRet < cursor)  //在不断调用next方法时lastRet必然小于cursor，删除lastRet位置元素后cursor--，lastRet复位
					cursor--;
				lastRet = -1;
				expectedModCount = modCount;   
			} catch (IndexOutOfBoundsException e) {
				throw new ConcurrentModificationException();
			}
		}

		final void checkForComodification() {
			if (modCount != expectedModCount)
				throw new ConcurrentModificationException();
		}
	}

	private class ListItr extends Itr implements ListIterator<E> {
		ListItr(int index) {    //构造函数，传进cursor
			cursor = index;
		}

		public boolean hasPrevious() {    //当前cursor不为0则有前驱
			return cursor != 0;
		}

		public E previous() {  //前驱元素的索引为cursor-1
			checkForComodification();
			try {
				int i = cursor - 1;
				E previous = get(i);
				lastRet = cursor = i;   //lastRet为返回元素的索引
				return previous;
			} catch (IndexOutOfBoundsException e) {
				checkForComodification();
				throw new NoSuchElementException();
			}
		}

		public int nextIndex() {  //下一次调用next返回的元素的索引，即为cursor
			return cursor;
		}

		public int previousIndex() { //下一次调用previous方法返回的元素的索引
			return cursor - 1;
		}

		public void set(E e) {
			if (lastRet == -1)	//表明没有调用next或previous方法
				throw new IllegalStateException();
			checkForComodification();

			try {
				AbstractList.this.set(lastRet, e);    //lastRet为修改元素的索引
				expectedModCount = modCount;
			} catch (IndexOutOfBoundsException ex) {
				throw new ConcurrentModificationException();
			}
		}

		public void add(E e) {
			checkForComodification();

			try {
				AbstractList.this.add(cursor++, e);   //将元素e插入到调用next方法返回的元素之后，或者调用previous方法返回的元素之前
				lastRet = -1;		//重置lastRet
				expectedModCount = modCount;
			} catch (IndexOutOfBoundsException ex) {
				throw new ConcurrentModificationException();
			}
		}
	}

	/**
	 * new RandomAccessSubList<E>与new SubList<E>的区别是返回的子集合是否实现了RandomAccess
	 * 返回的是一个新的subList类，该类继承自AbstractList，实现了AbstractList的所有行为
	 */
	public List<E> subList(int fromIndex, int toIndex) {
		return (this instanceof RandomAccess ? new RandomAccessSubList<E>(this,
				fromIndex, toIndex) : new SubList<E>(this, fromIndex, toIndex));
	}

	// Comparison and hashing

	
	public boolean equals(Object o) {
		if (o == this)			 //o为本集合返回true
			return true; 
		if (!(o instanceof List))   //如果o没有实现List接口直接返回false
			return false;

		ListIterator<E> e1 = listIterator();
		ListIterator e2 = ((List) o).listIterator();
		while (e1.hasNext() && e2.hasNext()) {   //按位序依次遍历比较
			E o1 = e1.next();
			Object o2 = e2.next();
			if (!(o1 == null ? o2 == null : o1.equals(o2))) //比较o1与o2，不相等则返回flase
				return false;
		}
		//检查长度是否相等
		return !(e1.hasNext() || e2.hasNext());   
	}

	
	public int hashCode() {
		int hashCode = 1;
		Iterator<E> i = iterator();
		while (i.hasNext()) {
			E obj = i.next();
			//List hashCode的 计算公式
			hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode());
		}
		return hashCode;
	}

	/**
	 * 
	 * 移除指定范围的元素，左移随后的元素，并减少它们的索引
	 * 如果toIndex=fromIndex,此操作无影响
	 * 
	 */
	protected void removeRange(int fromIndex, int toIndex) {
		ListIterator<E> it = listIterator(fromIndex);	//是迭代器定位到fromIndex位置
		for (int i = 0, n = toIndex - fromIndex; i < n; i++) {   //移除toIndex - fromIndex个数元素
			it.next();
			it.remove();
		}
	}

	/**
	 * 此变量是用来检查iterator中的同步，在所有的对List的结构性操作中
	 * 此modCount的值都会加1，比如add()、remove()、addAll()、clear()等
	 */
	protected transient int modCount = 0;
}


/**
 * 主要功能用于获取集合完整结构的子范围，
 * 该类继承自AbstractList，拥有AbstractList中的所有操作
 * 对子范围进行操作会影响AbstractList，因为AbstractList被作为参数传进
 * 了SubList<E>，对SubList的操作其实是对AbstractList的操作
 * */
class SubList<E> extends AbstractList<E> {
	private AbstractList<E> l;
	private int offset;
	private int size;
	private int expectedModCount;

	SubList(AbstractList<E> list, int fromIndex, int toIndex) {   //初始化
		if (fromIndex < 0)
			throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
		if (toIndex > list.size())
			throw new IndexOutOfBoundsException("toIndex = " + toIndex);
		if (fromIndex > toIndex)
			throw new IllegalArgumentException("fromIndex(" + fromIndex
					+ ") > toIndex(" + toIndex + ")");
		l = list;
		offset = fromIndex;   //起始索引
		size = toIndex - fromIndex;  //子集长度
		expectedModCount = l.modCount;  //用于检查是否发生了并发操作
	}

	public E set(int index, E element) {
		rangeCheck(index);		//检查索引是否合法，即是否在0到size之间，不包含size
		checkForComodification();   
		return l.set(index + offset, element);  //对子集的操作其实是对原来集合的操作
	}

	public E get(int index) {
		rangeCheck(index);
		checkForComodification();
		return l.get(index + offset);
	}

	public int size() {
		checkForComodification();
		return size;
	}

	public void add(int index, E element) {
		if (index < 0 || index > size)   //可以等于size，表示添加 到最后
			throw new IndexOutOfBoundsException();
		checkForComodification();
		l.add(index + offset, element);
		expectedModCount = l.modCount;
		size++;
		modCount++;			//调用add方法集合结构发生改变时modCount++
	}

	public E remove(int index) {
		rangeCheck(index);
		checkForComodification();
		E result = l.remove(index + offset);
		expectedModCount = l.modCount;
		size--;
		modCount++;		// 调用remove方法集合结构发生改变时modCount++
		return result;
	}

	protected void removeRange(int fromIndex, int toIndex) {
		checkForComodification();
		l.removeRange(fromIndex + offset, toIndex + offset);
		expectedModCount = l.modCount;
		size -= (toIndex - fromIndex);	//size相应减少
		modCount++;			// 调用removeRange方法集合结构发生改变时modCount++
	}

	public boolean addAll(Collection<? extends E> c) {
		return addAll(size, c);		//在最后位置添加元素
	}

	public boolean addAll(int index, Collection<? extends E> c) {  //在指定位置添加元素
		if (index < 0 || index > size)
			throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
					+ size);
		int cSize = c.size();
		if (cSize == 0)
			return false;

		checkForComodification();
		l.addAll(offset + index, c);
		expectedModCount = l.modCount;
		size += cSize;	//size相应增加
		modCount++;		// 调用addAll方法使集合结构发生改变时modCount++
		return true;
	}

	public Iterator<E> iterator() {
		return listIterator();
	}

	public ListIterator<E> listIterator(final int index) {
		checkForComodification();
		if (index < 0 || index > size)
			throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
					+ size);

		/**
		 * 使用的还是父集合的listIterator方法
		 * 操作的实际是父元素
		 * */
		return new ListIterator<E>() {
			private ListIterator<E> i = l.listIterator(index + offset); //定位迭代器

			public boolean hasNext() {
				return nextIndex() < size;
			}

			public E next() {
				if (hasNext())
					return i.next();
				else
					throw new NoSuchElementException();
			}

			public boolean hasPrevious() {
				return previousIndex() >= 0;
			}

			public E previous() {
				if (hasPrevious())
					return i.previous();
				else
					throw new NoSuchElementException();
			}

			public int nextIndex() {	
				return i.nextIndex() - offset;
			}

			public int previousIndex() {
				return i.previousIndex() - offset;
			}

			public void remove() {
				i.remove();
				expectedModCount = l.modCount;
				size--;
				modCount++;  // 调用迭代器的remove方法使集合结构发生改变时modCount++
			}

			public void set(E e) {
				i.set(e);
			}

			public void add(E e) {
				i.add(e);
				expectedModCount = l.modCount;
				size++;
				modCount++; // 调用迭代器的add方法使集合结构发生改变时modCount++
			}
		};
	}

	public List<E> subList(int fromIndex, int toIndex) {  //subList的subList方法
		return new SubList<E>(this, fromIndex, toIndex);
	}

	private void rangeCheck(int index) {
		if (index < 0 || index >= size)
			throw new IndexOutOfBoundsException("Index: " + index + ",Size: "
					+ size);
	}

	private void checkForComodification() {
		if (l.modCount != expectedModCount)
			throw new ConcurrentModificationException();
	}
}

/**
 * 支持随机访问的RandomAccessSubList类需要实现RandomAccess接口和重写subList方法
 * 其他同SubList<E>类
 * */
class RandomAccessSubList<E> extends SubList<E> implements RandomAccess {
	RandomAccessSubList(AbstractList<E> list, int fromIndex, int toIndex) {
		super(list, fromIndex, toIndex);	
	}

	public List<E> subList(int fromIndex, int toIndex) {	//需重写其subList方法，也使其实现RandomAccess接口
		return new RandomAccessSubList<E>(this, fromIndex, toIndex);
	}
}

三。AbstractSet

public abstract class AbstractSet<E> extends AbstractCollection<E> implements
		Set<E> {
	/**
	 * 唯一构造器
	 */
	protected AbstractSet() {
	}

	// Comparison and hashing

	/**
	 *
	 */
	public boolean equals(Object o) {
		if (o == this)   //o就是本集合返回true
			return true;

		if (!(o instanceof Set))  //o不是一个Set，即没有实现Set接口，肯定返回false
			return false;
		Collection c = (Collection) o;	//这句话可能抛出ClassCastException
		if (c.size() != size())		//长度不等则返回false
			return false;
		try {
			return containsAll(c);	//如果c中元素都包含在本集合中则返回true
		} catch (ClassCastException unused) {
			return false;
		} catch (NullPointerException unused) {	  //o为空抛出NullPointerException
			return false;
		}
	}

	/**
	 * Set的hashCode值为所有元素的hashCode值之和
	 */
	public int hashCode() {
		int h = 0;
		Iterator<E> i = iterator();
		while (i.hasNext()) {
			E obj = i.next();
			if (obj != null)
				h += obj.hashCode();
		}
		return h;
	}

	/**
	 * 
	 * 移除Set中所有包含在c中的元素
	 * 此方法的实现原则是：如果Set含有更少的元素，就遍历set，依次检查每个迭代返回的
	 * 元素，看它是否包含在指定集合c中，如果包含就调用迭代器的remove方法移除它。
	 * 如果指定集合c含有更少的元素，就遍历c，调用Set的remove方法移除通过迭代器返回的元素
	 */
	public boolean removeAll(Collection<?> c) {
		boolean modified = false;

		if (size() > c.size()) {
			for (Iterator<?> i = c.iterator(); i.hasNext();)
				modified |= remove(i.next());   // |=表明只要一次remove方法返回true，modified就位true
		} else {
			for (Iterator<?> i = iterator(); i.hasNext();) {
				if (c.contains(i.next())) {
					i.remove();
					modified = true;
				}
			}
		}
		return modified;
	}

}

四。AbstractQueue

public abstract class AbstractQueue<E> extends AbstractCollection<E> implements
		Queue<E> {

	/**
	 * Constructor for use by subclasses.
	 */
	protected AbstractQueue() {
	}

	/**
	 * 此内部实现为offer方法，由其子类实现。
	 * 如果queue中有足够的容量则向其中插入e，否则抛出IllegalStateException
	 */
	public boolean add(E e) {
		if (offer(e))
			return true;
		else
			throw new IllegalStateException("Queue full");
	}

	/**
	 * 此内部实现为poll()方法，由其子类实现。
	 * poll方法返回不为空则表示移除头结点成功
	 * 否则抛出NoSuchElementException
	 */
	public E remove() {
		E x = poll();
		if (x != null)  //x为空则表示queue为空
			return x;
		else
			throw new NoSuchElementException();
	}

	/**
	 * 返回其头结点，但并不移除它
	 * 此方法内部由peek()实现，peek由其子类实现
	 * peek方法返回不为空则表示返回头结点成功，
	 * 否则抛出NoSuchElementException
	 */
	public E element() {
		E x = peek();
		if (x != null) //x为空则表示queue为空
			return x;
		else
			throw new NoSuchElementException();
	}

	/**
	 * 移除queue中所有元素
	 * 依次调用poll方法移除头结点
	 */
	public void clear() {
		while (poll() != null)
			;
	}

	/**
	 * 重写addAll方法
	 */
	public boolean addAll(Collection<? extends E> c) {
		if (c == null)	//queue不支持null元素
			throw new NullPointerException();
		if (c == this)
			throw new IllegalArgumentException();
		boolean modified = false;
		Iterator<? extends E> e = c.iterator();
		while (e.hasNext()) {
			if (add(e.next()))	//调用的是AbstractQueue的add方法，调用此方法可能抛出异常
				modified = true;
		}
		return modified;
	}

}

五。AbstractSequentialList

/**
 * 实现部分基础方法，使子类LinkedList不必再去实现
 * 实现了get,set,add,remove,addAll,iterator,listIterator方法
 * */
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
    /**
     * Sole constructor.  (For invocation by subclass constructors, typically
     * implicit.)
     */
    protected AbstractSequentialList() {
    }

    /**
     * 获取指定位置的元素 
     */
    public E get(int index) {
        try {
            return listIterator(index).next();  //此迭代器由子类LinkedList实现
        } catch (NoSuchElementException exc) {
            throw new IndexOutOfBoundsException("Index: "+index);
        }
    }

    /**
     * 替换指定位置的元素，返回原来的元素
     */
    public E set(int index, E element) {
	try {
	    ListIterator<E> e = listIterator(index);   //此迭代器由子类LinkedList实现
	    E oldVal = e.next();
	    e.set(element);
	    return oldVal;
	} catch (NoSuchElementException exc) {
	    throw new IndexOutOfBoundsException("Index: "+index);
	}
    }

    /**
     * 在指定位置添加一元素，原来的元素以及其随后的元素后移一个位置
     */
    public void add(int index, E element) {
	try {
	    listIterator(index).add(element);   //此迭代器由子类LinkedList实现
	} catch (NoSuchElementException exc) {
	    throw new IndexOutOfBoundsException("Index: "+index);
	}
    }

    /**
     * 
     * 移除List指定位置的元素，把它后面的元素向左移
     * 返回移除的元素
     */
    public E remove(int index) {
	try {
	    ListIterator<E> e = listIterator(index);   //此迭代器由子类LinkedList实现
	    E outCast = e.next();
	    e.remove();
	    return outCast;
	} catch (NoSuchElementException exc) {
	    throw new IndexOutOfBoundsException("Index: "+index);
	}
    }


    // Bulk Operations

    /**
     * 
     * 在指定位置添加指定集合c中的所有元素，
     * 把当前位置的元素及其随后的元素向后移
     */
    public boolean addAll(int index, Collection<? extends E> c) {
	try {
	    boolean modified = false;
	    ListIterator<E> e1 = listIterator(index);   //获取指定位置的List迭代器，调用next会返回index位置的元素
	    Iterator<? extends E> e2 = c.iterator();
	    while (e2.hasNext()) {	//遍历c
		e1.add(e2.next());	//在指定位置添加
		modified = true;
	    }
	    return modified;
	} catch (NoSuchElementException exc) {
	    throw new IndexOutOfBoundsException("Index: "+index);
	}
    }


    // Iterators

    /**
     * 返回的是AbstractList的new ListItr(0)
     * 但由于用父类的引用指向子类的对象，只能调用Iterator中的方法。
     * 我觉得这里直接调用AbstractList的iterator()方法就可以了
     * 这个地方AbstractList中实现的迭代器中的get(index)方法是由LinkedList实现的
     */
    public Iterator<E> iterator() {
        return listIterator();
    }

    /**
     * 如果要获取ListIterator，则由子类LinkedList实现
     */
    public abstract ListIterator<E> listIterator(int index);
}

六。AbstractMap

public abstract class AbstractMap<K, V> implements Map<K, V> {
	/**
	 * Sole constructor. (For invocation by subclass constructors, typically
	 * implicit.)
	 */
	protected AbstractMap() {
	}

	// Query Operations
    /**
     *  entrySet返回一个Entry类型的Set集合，
     *  此Entry对象保存key，value值，并实现了一些基本方法
     *  比如getKey，getValue，setValue,equals和hashCode方法
     */
	public int size() {		//Set<Map.Entry<Key,Value>>的长度
		return entrySet().size();
	}

	
	public boolean isEmpty() {
		return size() == 0;		//size为0集合为空
	}

	/**
	 * 检查map是否包含指定value
	 */
	public boolean containsValue(Object value) {
		Iterator<Entry<K, V>> i = entrySet().iterator();//返回Set<Map.Entry<Key,Value>>集合的迭代器
		if (value == null) {
			while (i.hasNext()) {	//迭代
				Entry<K, V> e = i.next();
				if (e.getValue() == null)  	//找到给定的value则返回true
					return true;
			}
		} else {
			while (i.hasNext()) {
				Entry<K, V> e = i.next();
				if (value.equals(e.getValue()))
					return true;
			}
		}
		return false;
	}

	/**
	 * 检查map中是否包含指定key，类似containsValue方法
	 */
	public boolean containsKey(Object key) {
		Iterator<Map.Entry<K, V>> i = entrySet().iterator();
		if (key == null) {
			while (i.hasNext()) {
				Entry<K, V> e = i.next();
				if (e.getKey() == null)
					return true;
			}
		} else {
			while (i.hasNext()) {
				Entry<K, V> e = i.next();
				if (key.equals(e.getKey()))
					return true;
			}
		}
		return false;
	}

	/**
	 * 查找包含此key值的Entry对象，返回entry的value值
	 */
	public V get(Object key) {
		Iterator<Entry<K, V>> i = entrySet().iterator();
		if (key == null) {
			while (i.hasNext()) {
				Entry<K, V> e = i.next();
				if (e.getKey() == null)
					return e.getValue();
			}
		} else {
			while (i.hasNext()) {
				Entry<K, V> e = i.next();
				if (key.equals(e.getKey()))
					return e.getValue();
			}
		}
		return null;
	}

	// Modification Operations

	/**
	 * 此方法需由AbstractMap的子类实现
	 */
	public V put(K key, V value) {
		throw new UnsupportedOperationException();
	}

	/**
	 * 通过key值查找对应Entry，移除此Entry，并返回它的value值
	 */
	public V remove(Object key) {
		Iterator<Entry<K, V>> i = entrySet().iterator();
		Entry<K, V> correctEntry = null;
		if (key == null) {
			while (correctEntry == null && i.hasNext()) {
				Entry<K, V> e = i.next();
				if (e.getKey() == null)
					correctEntry = e;	//保存找到的Entry对象
			}
		} else {
			while (correctEntry == null && i.hasNext()) {
				Entry<K, V> e = i.next();
				if (key.equals(e.getKey()))
					correctEntry = e;
			}
		}

		V oldValue = null;
		if (correctEntry != null) {
			oldValue = correctEntry.getValue();
			i.remove();		//移除
		}
		return oldValue;
	}

	// Bulk Operations

	/**
	 * 添加指定m中的所有键值对到本Map
	 */
	public void putAll(Map<? extends K, ? extends V> m) {
		for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
			put(e.getKey(), e.getValue());
	}

	/**
	 * Set的clear方法
	 */
	public void clear() {
		entrySet().clear();
	}

	// Views

	/**
	 * 此变量不是持久化的，并且用volatile修饰表明
	 * 对这俩个变量的操作时线程安全的
	 */
	transient volatile Set<K> keySet = null;
	transient volatile Collection<V> values = null;

	/**
	 * 返回一个Set的子类
	 * 
	 * 此Set集合只在第一次调用keySet()时被创建，此后返回的都是同一个Set。
	 * 此方法不是线程安全的，大量线程多次调用此方法返回的可能不是同一个Set（可能是重新new的）
	 */
	public Set<K> keySet() {
		if (keySet == null) {	//在new的过程中，又调用了此方法可能又重新new了一个keySet
			keySet = new AbstractSet<K>() {		//需要实现iterator()与size()方法
				public Iterator<K> iterator() {
					return new Iterator<K>() {
						private Iterator<Entry<K, V>> i = entrySet().iterator(); //其实是调用entrySet的迭代器。由Set的子类实现

						public boolean hasNext() {
							return i.hasNext();
						}

						public K next() {
							return i.next().getKey();
						}

						public void remove() {
							i.remove();
						}
					};
				}

				public int size() {
					return AbstractMap.this.size();
				}

				public boolean contains(Object k) {		//重写AbstractCollection的contains方法
					return AbstractMap.this.containsKey(k);		//为map的containsKey方法
				}
			};
		}
		return keySet;
	}

	/**
	 * 与上面keySet()方法类似,不过返回的是Collection的子类
	 * 
	 */
	public Collection<V> values() {
		if (values == null) {
			values = new AbstractCollection<V>() {
				public Iterator<V> iterator() {
					return new Iterator<V>() {
						private Iterator<Entry<K, V>> i = entrySet().iterator();

						public boolean hasNext() {
							return i.hasNext();
						}

						public V next() {
							return i.next().getValue();
						}

						public void remove() {
							i.remove();
						}
					};
				}

				public int size() {
					return AbstractMap.this.size();
				}

				public boolean contains(Object v) {	//重写父类contains为Map.containsValue(v)
					return AbstractMap.this.containsValue(v);
				}
			};
		}
		return values;
	}

	public abstract Set<Entry<K, V>> entrySet();   //此方法由其子类实现，如HashMap，HashTable等

	// Comparison and hashing

	/**
	 * 
	 * 比较俩个map是否相等，如果给定对象o是一个Map，即实现了Map接口，并且
	 * 2个map含有同样的键值对，则它们相等。
	 * 更正式的来说，返回结果为m1.entrySet().equals(m2.entrySet())
	 */
	public boolean equals(Object o) {
		if (o == this)		//如果是本map
			return true;

		if (!(o instanceof Map))  //是否实现了Map接口
			return false;
		Map<K, V> m = (Map<K, V>) o;
		if (m.size() != size())		//键值对个数是否相等
			return false;

		try {
			Iterator<Entry<K, V>> i = entrySet().iterator();
			while (i.hasNext()) {
				Entry<K, V> e = i.next();
				K key = e.getKey();
				V value = e.getValue();
				if (value == null) {
					if (!(m.get(key) == null && m.containsKey(key)))	//如果m中有这个key并且相应value值为空则返回true
						return false;
				} else {
					if (!value.equals(m.get(key)))	//m中根据key值找到的value与此value相等则返回ture
						return false;
				}
			}
		} catch (ClassCastException unused) {
			return false;
		} catch (NullPointerException unused) {
			return false;
		}

		return true;		
	}

	/**
	 * 
	 * entrySet中各个Entry的hashCode之和
	 */
	public int hashCode() {
		int h = 0;
		Iterator<Entry<K, V>> i = entrySet().iterator();
		while (i.hasNext())
			h += i.next().hashCode();	//Entry的hashCode
		return h;
	}

	/**
	 * map的toString方法，返回类似{key1=value1, key2=value2, ....}
	 */
	public String toString() {
		Iterator<Entry<K, V>> i = entrySet().iterator();
		if (!i.hasNext())
			return "{}";

		StringBuilder sb = new StringBuilder();
		sb.append('{');
		for (;;) {
			Entry<K, V> e = i.next();
			K key = e.getKey();
			V value = e.getValue();
			sb.append(key == this ? "(this Map)" : key);
			sb.append('=');
			sb.append(value == this ? "(this Map)" : value);
			if (!i.hasNext())
				return sb.append('}').toString();
			sb.append(", ");
		}
	}

	/**
	 *
	 * 返回Map的浅拷贝对象，不拷贝key和value
	 */
	protected Object clone() throws CloneNotSupportedException {
		AbstractMap<K, V> result = (AbstractMap<K, V>) super.clone();
		result.keySet = null;
		result.values = null;
		return result;
	}

	/**
	 * 
	 * 此方法非常实用，主要用于SimpleImmutableEntry与SimpleEntry中
	 * 测试2个对象是否相等，是否为空.
	 * 
	 */
	private static boolean eq(Object o1, Object o2) {
		return o1 == null ? o2 == null : o1.equals(o2);
	}


	/**
	 *
	 * 实现了Entry接口的类，用于保存key和value，并提供一些基础方法用于获取
	 * key与value。可以使用setValue改变value的值
	 * 
	 * @since 1.6
	 */
	public static class SimpleEntry<K, V> implements Entry<K, V>,
			java.io.Serializable {
		private static final long serialVersionUID = -8499721149061103585L;

		private final K key;
		private V value;

		/**
		 * 构造方法一，提供key和value
		 */
		public SimpleEntry(K key, V value) {
			this.key = key;
			this.value = value;
		}

		/**
		 * 构造方法二，直接提供一个Entry对象
		 */
		public SimpleEntry(Entry<? extends K, ? extends V> entry) {
			this.key = entry.getKey();
			this.value = entry.getValue();
		}

		/**
		 * 获取保存的key
		 */
		public K getKey() {
			return key;
		}

		/**
		 * 获取保存的value
		 */
		public V getValue() {
			return value;
		}

		/**
		 * 改变此entry对象的value值
		 */
		public V setValue(V value) {
			V oldValue = this.value;
			this.value = value;
			return oldValue;
		}

		/**
		 * 
		 * 2个Entry对象判断相等的方法
		 * (e1.getKey() == null ? e2.getKey() == null : e1.getKey().equals(e2.getKey()))
		 * 		&& (e1.getValue() == null ? e2.getValue() == null : e1.getValue()
		 * 				.equals(e2.getValue()))
		 */
		public boolean equals(Object o) {
			if (!(o instanceof Map.Entry))	//判断o是否实现了Map.Entry接口
				return false;
			Map.Entry e = (Map.Entry) o;
			return eq(key, e.getKey()) && eq(value, e.getValue());
		}

		/**
		 * key的hashCode与value的hashCode异或
		 */
		public int hashCode() {
			return (key == null ? 0 : key.hashCode())
					^ (value == null ? 0 : value.hashCode());
		}

		/**
		 * Entry的toString方法
		 */
		public String toString() {	
			return key + "=" + value;
		}

	}

	/**
	 * 与SimpleEntry对象基本类似，只是SimpleImmutableEntry不支持setValue方法
	 */
	public static class SimpleImmutableEntry<K, V> implements Entry<K, V>,
			java.io.Serializable {
		private static final long serialVersionUID = 7138329143949025153L;

		private final K key;
		private final V value;

		
		public SimpleImmutableEntry(K key, V value) {
			this.key = key;
			this.value = value;
		}

		
		public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
			this.key = entry.getKey();
			this.value = entry.getValue();
		}

		
		public K getKey() {
			return key;
		}

		
		public V getValue() {
			return value;
		}

		
		public V setValue(V value) {
			throw new UnsupportedOperationException();
		}

		
		public boolean equals(Object o) {
			if (!(o instanceof Map.Entry))
				return false;
			Map.Entry e = (Map.Entry) o;
			return eq(key, e.getKey()) && eq(value, e.getValue());
		}

		
		public int hashCode() {
			return (key == null ? 0 : key.hashCode())
					^ (value == null ? 0 : value.hashCode());
		}

		public String toString() {
			return key + "=" + value;
		}

	}

}