集合框架源码分析一(接口篇)

一。Iterable接口

public interface Iterable<T> {

    /**
     * 实现此接口的所有集合都可以使用foreach循环
     * 由于Collection接口扩展自Iterable接口，
     * 标准类库的任何集合都可以使用"for each"循环
     * @return an Iterator.
     */
    Iterator<T> iterator();
}

二。interface Iterator<E>

public interface Iterator<E> {
    /**
     * 返回true如果迭代还有更多的元素
     * 换而言之，如果调用next()方法返回一个元素而不是抛出一个异常则返回true
     */
    boolean hasNext();


    /**
     * 返回迭代器中的下一个元素
     * 如果迭代器中没有更多的元素则抛出NoSuchElementException
     */
    E next();


    /**
     * remove方法将移除上一次调用next方法时返回的元素，如果想移除特定位置的元素
     * 需要先逃过该元素
     *
     * 如果没有调用next方法就调用remove方法将抛出IllegalStateException
     */
    void remove();
}

三。interface Collection<E>

public interface Collection<E> extends Iterable<E> {

    /**
     * 返回集合元素的个数，如果集合有元素超过Integer.MAX_VALUE
     * 返回Integer.MAX_VALUE
     */
    int size();


    /**
     * 如果集合不含元素则返回true
     * @return <tt>true</tt> if this collection contains no elements
     */
    boolean isEmpty();


    /**
     * 如果集合中含有参数o则返回true。
     * 正常来说返回结果如下,
     * 当且仅当集合中至少有一个元素e
     * o==null ? e==null : o.equals(e)
     * o的类型与集合元素类型不相容则抛出ClassCastException
     * 如果o为null，并且集合不允许空值则抛出NullPointerException
     */
    boolean contains(Object o);


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


    /**
     * 返回一个对象数组，包含集合中的所有元素
     * 即使知道集合所包含的具体的数据类型也不能进行
     * 强制类型转换
     * 比如：String[] values = (String[])collect.toArray;  //错误
     * 可遍历时一一转换
     *
     */
    Object[] toArray();


    /**
     * 返回一个数组，包含集合中的所有元素 
     * 数组元素的类型为指定数组类型
     *
     * 检查数组参数是否大于集合的容量。如果大于的话，便将该集合所有元素添加到数组
     * 中，并加上一个null结束符。如果等于集合长度，则将集合所有元素复制到数组但不
     * 添加null。如果小于的话，则以给定数组参数的类型新建一个数组，并将该集合各个
     * 元素填入数组。创建数组方法为
     * Array.newInstance(a.getClass().getComponentType(), size);
     */
    <T> T[] toArray(T[] a);


    /**
     * 将一个指定的元素添加到集合中，如果集合发生了改变则返回true。
     * 特殊的，一些集合拒接添加null，一些集合不会添加相同的元素，
     * 一些特殊类型的元素也不能添加到有些集合
     *
     * 如果集合不支持此方法则抛出UnsupportedOperationException
     * 如果指定元素类型阻止其被添加入集合则抛出ClassCastException
     * 如果指定元素为空，并且集合不支持添加null元素则抛出NullPointerException
     * 如果指定元素的一些特性拒绝其被加入集合则抛出IllegalArgumentException
     * 如果由于插入限制使e不能被添加则抛出IllegalStateException，在并发操作时可能
     * 会抛出此异常
     */
    boolean add(E e);


    /**
     * 如果o在集合中存在，则删除此元素
     * 如果有元素被移除，则返回true
     *
     * 如果指定元素类型与集合元素类型不兼容则抛出ClassCastException
     * 如果指定元素为空，并且集合不支持添加null元素则抛出NullPointerException
     * 如果集合不支持此方法则抛出UnsupportedOperationException
     */
    boolean remove(Object o);


    /**
     * 如果集合包含指定集合c中的所有元素则返回true
     *
     * 如果c中一个或多个元素类型与集合元素类型不相容则抛出ClassCastException
     * 如果如果指定集合c中包含一个或多个null元素，并且集合不支持添加null
     * 或者如果指定的集合c为null则抛出NullPointerException
     */
    boolean containsAll(Collection<?> c);


    /**
     * 把指定集合c中所有元素添加到集合中
     * 如果在添加元素过程中c已经被修改了，则称此操作是undefined，会抛出异常
     *
     * 如果集合不支持此方法则抛出UnsupportedOperationException
     * 如果指定集合元素类型阻止其被添加入集合则抛出ClassCastException
     * 如果如果指定集合c中包含一个或多个null元素，并且集合不支持添加null
     * 或者如果指定的集合c为null则抛出NullPointerException
     * 如果指定集合元素的一些特性拒绝其被加入集合则抛出IllegalArgumentException
     * 如果由于插入限制，指定集合中有一部分元素没有被添加到集合中则抛出
     * IllegalStateException，并发操作时可能发生
     */
    boolean addAll(Collection<? extends E> c);


    /**
     * 移除既包含在本集合中也包含在指定集合c中的所有元素
     * 如果集合发生改变则返回true
     * 
     * 如果集合不支持此方法则抛出UnsupportedOperationException
     * 如果集合中元素类型与给定集合c元素类型不相容则抛出ClassCastException
     * 如果如果指定集合c中包含一个或多个null元素，并且集合不支持null
     * 或者如果指定的集合c为null则抛出NullPointerException
     */
    boolean removeAll(Collection<?> c);


    /**
     * 移除集合中所有不包含在指定集合c中的元素
     * 
     * 如果集合不支持此方法则抛出UnsupportedOperationException
     * 如果集合中元素类型与给定集合c元素类型不相容则抛出ClassCastException
     * 如果指定集合c中包含一个或多个null元素，并且集合不支持null
     * 或者如果指定的集合c为null则抛出NullPointerException
     */
    boolean retainAll(Collection<?> c);


    /**
     * 移除集合中所有元素，此方法返回后isEmpty() = true
     *
     * 如果集合不支持此方法则抛出UnsupportedOperationException
     */
    void clear();

    /**
     * 重写Object euqals方法
     *
     * 不同的集合equals方法不同
     */
    boolean equals(Object o);


    /**
     * 重写equals方法，也需要重写hashCode方法
     */
    int hashCode();
}

四。interface List<E>

public interface List<E> extends Collection<E> {

    /**
     * 同Collection接口
     */
    int size();


    /**
     * 同Collection接口
     */
    boolean isEmpty();

    /**
     * 同Collection接口
     */
    boolean contains(Object o);

    /**
     * 返回列表或队列的迭代器
     */
    Iterator<E> iterator();

    /**
     * 同Collection接口
     */
    Object[] toArray();


    /**
     * 同Collection接口
      * 示例： String[] y = x.toArray(new String[0])
     * 如果指定数组类型与list元素类型不相容则抛出ArrayStoreException
     * 如果指定数组a为null则抛出NullPointerException
     */
    <T> T[] toArray(T[] a);


    // Modification Operations

    /**
     * 将一个元素添加到list的最后
      * 其他同Collection接口
     */
    boolean add(E e);

    /**
     * 如果指定对象o在集合中存在，则移除它，如果存在多个o则移除第一个
     * 其他同Collection接口
     */
    boolean remove(Object o);


    /**
     * 如果集合中包含指定集合c中的所有元素则返回true
     * 其他同Collection接口
     */
    boolean containsAll(Collection<?> c);

    /**
     * 同Collection接口
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * 在给定位置index插入指定集合c的第一个元素，然后依次插入后面的元素
      * 当在添加过程中指定集合c发生改变时，则认为此操作是undefined，将抛出异常
      *
     * 如果此集合不支持此方法则抛出UnsupportedOperationException
     * 如果指定集合元素的类型阻止其被加入List则抛出ClassCastException
     * 如果指定集合包含一个或多个null元素，并且List不允许null元素，或集合c为空
      *             则抛出NullPointerException
     * 如果集合c的一些元素特性阻止其被添加入List抛出IllegalArgumentException
     * 如果index<0 || index>size() 则抛出IndexOutOfBoundsException
     */
    boolean addAll(int index, Collection<? extends E> c);

    /**
     * 同Collection接口
     */
    boolean removeAll(Collection<?> c);

    /**
     * 同Collection接口
     */
    boolean retainAll(Collection<?> c);

    /**
     * 同Collection接口
     */
    void clear();

    /**
     * 重写Object的equals方法。
      * o与List相等的原则为：
      * 首先Obejct对象要是一个List，即实现了List接口
      * 其次2个集合在同样的位置包含同样的元素 
     */
    boolean equals(Object o);

    /**
     * 重写equals方法必须重写hashCode方法
      * List hashCode的计算公式为：
      * int hashCode = 1;
     *  Iterator<E> i = list.iterator();
     *  while (i.hasNext()) {
     *      E obj = i.next();
     *      hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
     *  }
     */
    int hashCode();


    // Positional Access Operations

    /**
     * 返回List中指定位置的元素
      * 如果index<0 || index>size() 则抛出IndexOutOfBoundsException
     */
    E get(int index);


    /**
     * 用element替换List中指定位置的元素
      *
     * 如果List，比如Set，不支持此操作则抛出UnsupportedOperationException
     * 如果element类型使其不能被添加则抛出ClassCastException
     * 如果给定的参数E为空并且List不允许空元素则抛出NullPointerException
     * 如果index<0 || index>size() 则抛出IndexOutOfBoundsException
     */
    E set(int index, E element);


    /**
     * 在指定位置插入一个元素element，并把随后的元素向右移
      * 异常抛出同上面的set方法
     */
    void add(int index, E element);


    /**
     * 移除List指定位置的元素，并把随后的元素向左移
     */
    E remove(int index);


    // Search Operations

    /**
     * 如果List中含有与O相等的元素，则返回第一个的位置
      * 否则返回-1表示集合中不含此元素
      *
     * 如果o对象类型与List元素类型不相容则抛出ClassCastException
     * 如果给定的参数E为空并且List不允许空元素则抛出NullPointerException
     */
    int indexOf(Object o);

    /**
     * 如果List中含有与O相等的元素，则返回最后一个的位置
      * 否则返回-1表示集合中不含此元素
     */
    int lastIndexOf(Object o);


    // List Iterators

    /**
     * 返回一个listIterator
     * 特点：适用于对List进行遍历，包含一个add(E e)方法，在遍历时可在指定位置
      * 添加元素，包含previous()方法，hasPrevious()方法用于反向遍历
      * 下面将具体讲解listIterator接口
     */
    ListIterator<E> listIterator();

    /**
     * 返回一个listIterator，在指定的位置开始迭代
      * 如果index<0 || index>size() 则抛出IndexOutOfBoundsException
     */
    ListIterator<E> listIterator(int index);

    // View

    /**
     * 获取List的子范围，子范围包含fromIndex但不包含toIndex
     * 你可以将任何操作作用于子范围，并且它们能够自动反应到List的情况
      * 比如：l.subList(10,19).clear(),子范围的各个元素将自动从l中删除。
     */
    List<E> subList(int fromIndex, int toIndex);
}

五。interface ListIterator<E>

public interface ListIterator<E> extends Iterator<E> {
    // Query Operations

    /**
     * 正向遍历时，如果迭代器还有更多的元素则返回true 
     * 换而言之，如果调用next()方法返回一个元素而不是抛出一个异常则返回true
     *
     */
    boolean hasNext();


    /**
     * 返回List的下一个元素，当遍历List时此方法将被反复调用，
     * 也可以与previous方法混合调用 
     * 如果迭代器没有下一个元素则抛出NoSuchElementException
     */
    E next();


    /**
     * 反方向遍历时，如果迭代器含有更多的元素则返回true
     * 换而言之，如果调用previous方法返回一个元素而不是抛出一个异常则返回true
     */
    boolean hasPrevious();


    /**
     * 返回List的前一个元素，当反向遍历时此方法将被反复调用，
     * 也可以与next方法混合调用 
     * 如果迭代器没有上一个元素则抛出NoSuchElementException
     */
    E previous();


    /**
     * 返回下次调用next()方法时返回的元素的索引，如果返回的是最后一个	     
     * 元素则返回List的长度
     */
    int nextIndex();


    /**
     * 返回下次调用previous()方法时返回的元素的索引,如果
     * 迭代器刚好越过第一个元素，位于集合最开始的位置则返回-1
     */
    int previousIndex();


    // Modification Operations

    /**
     * 移除最近一次调用next或者previous方法时返回的元素
     * 在调用next或者previous方法后，此方法仅能被调用一次
      * 此方法仅能在没有调用ListIterator.add时调用
      *
     * 如果List不支持此方法则抛出UnsupportedOperationException 
     * 如果next或者previous没有被调用，或者next或previous已经被调用，
      * 但是同时已经调用了add或remove方法，再调用此方法时将抛出
      * IllegalStateException
     */
    void remove();


    /**
     * 以一个新的元素取代上一次调用next或previous方法时返回的元素
     * 此方法仅能在调用next或previous方法后没有调用ListIterator.remove
     * 或ListIterator.add情况下被调用
      *
     * 如果e类型与List元素类型不相容则抛出ClassCastException
     * 如果List不支持此方法则抛出UnsupportedOperationException
     * 如果元素的一些特性使其不能被添加入List则抛出IllegalArgumentException
     * 如果next或者previous没有被调用，或者next或previous已经被调用，
      * 但是同时已经调用了add或remove方法，再调用此方法时将抛出
      * IllegalStateException
     */
    void set(E e);


    /**
     * 将元素e插入到调用next方法返回的元素之后，或者调用previous方法返回的元素
     * 之前
      *
     * 如果e类型与List元素类型不相容则抛出ClassCastException
     * 如果List不支持此方法则抛出UnsupportedOperationException
     * 如果元素的一些特性使其不能被添加入List则抛出IllegalArgumentException
     */
    void add(E e);
}

六。interface Set<E>

public interface Set<E> extends Collection<E> {
    // Query Operations

    /**
     * 返回集合元素的个数，如果集合有元素超过Integer.MAX_VALUE
     * 返回Integer.MAX_VALUE
     */
    int size();


    /**
     * 如果Set不包含元素则返回true
     */
    boolean isEmpty();


    /**
     * 同List接口
     */
    boolean contains(Object o);


    /**
     * 同List接口
      * 其返回数组的元素的位置不定
     */
    Iterator<E> iterator();

    /** 
     * 同List接口
      * 其返回数组的元素的位置不定
     */
    <T> T[] toArray(T[] a);


    // Modification Operations

    /**
     * 如果Set中已经含有此元素，Set不改变并且返回false
     * 此规定确保Set中不含有重复的元素  
     *
     * 抛出异常同List接口     
     */
    boolean add(E e);


    /**
     * 如果集合中存在此元素o则移除此元素
     */
    boolean remove(Object o);


    // Bulk Operations

    /**
     * 如果Set中含有所有c中的元素，则返回true
     */
    boolean containsAll(Collection<?> c);

    /**
     * 把知道集合c中的所有除了在Set中已经存在的元素添加到Set中
      * 如果c也是一个Set则是求2个集合的并集
      * 如果在添加元素的过程中发现C已经被修改了，则此操作是undefined
     */ 
    boolean addAll(Collection<? extends E> c);

    /**
     * 移除集合中所有不包含在指定集合c中的元素
      * 如果c也是一个Set则是求2个集合的差集
     */
    boolean retainAll(Collection<?> c);

    /**
     * 移除所有既包含在c中也包含在Set中的元素
     */
    boolean removeAll(Collection<?> c);

    /**
     * 移除Set中所有元素，此方法返回后isEmpty()=true
     */
    void clear();


    // Comparison and hashing

    /**
     * Set中的equals方法
      * 当且仅当满足以下条件时返回true：
     * 首先o是一个Set，即实现了Set接口
      * 其次两个Set长度相等并且o中所有元素都包含在Set中，Set中的所有元素也都包含
      * 在o中
     */
    boolean equals(Object o);

    /**
     * 重写equals方法需要重写hashCode方法
      * Set的hashCode值为所有元素的hashCode值之和，如果元素为null，hashCode
     * 为0
     */
    int hashCode();
}

七。interface Queue<E>

public interface Queue<E> extends Collection<E> {
    /**
     * 如果queue中有足够的容量，向queue中添加一个元素
      *
     * 如果queue中没有足够的容量则抛出IllegalStateException
     * 如果e的类型使其不能被添加入queue则抛出ClassCastException
     * 如果指定元素为null并且queue不支持null元素则抛出NullPointerException
     * 如果e的某些特征使其不能被添加入queue则抛出IllegalArgumentException
     */
    boolean add(E e);


    /**
     * 如果queue中有足够的容量，向queue中添加一个元素
      * 对于一个用大小限制的queue，此方法更加合适
     */
    boolean offer(E e);


    /**
     * 移除头节点并返回。
      * 当queue为空时抛出NoSuchElementException
     */
    E remove();


    /**
     * 移除头节点并返回
      * 当queue为空时返回null
     */
    E poll();


    /**
     * 获取头节点并返回
      * 当queue为空时抛出NoSuchElementException
     */
    E element();


    /**
     * 获取头节点并返回
      * 当queue为空时返回null
     */
    E peek();
}

八。interface SortedSet<E>

public interface SortedSet<E> extends Set<E> {
    /**
     * comparator用于对集合元素进行排序，
     * 如果Set使用自然顺序排列其元素，则返回null
     */
    Comparator<? super E> comparator();

    /**
     * 返回一个从fromElement(包含)到toElement(不包含)的子范围
     * 如果fromElement与toElement相等则返回的Set是空集
     * 子范围支持Set的所有操作，并且对子范围的操作将影响到Set
     *
     * 如果使用Set的comparator，fromElement和toElement不能进行互相比较
     * fromElement或toElement的类型与Set元素类型不相容则抛出ClassCastException
     * 如果fromElement或toElement为null，并且Set不支持null元素则抛出空指针异常
     * 如果fromElement比toElement大，这个大是使用comparator比较的结果，
     * 或者Set限制只能访问某范围，而fromElement或toElement位于此范围之外则
     * 抛出IllegalArgumentException
     */
    SortedSet<E> subSet(E fromElement, E toElement);

    /**
     * 返回Set中使用比较器或自然顺序，元素大小严格小于toElement的元素集
     * 同样子范围支持Set的所有操作，并会反映到集合
     * 异常抛出同上
     */
    SortedSet<E> headSet(E toElement);

    /**
     * 返回Set中使用比较器或自然顺序，元素大小大于等于fromElement的元素集
     * 同样子范围支持Set的所有操作，并会反映到集合
     * 异常抛出同上
     */
    SortedSet<E> tailSet(E fromElement);

    /**
     * 返回集合的第一个元素，即最小元素
     * 如果集合为空则抛出NoSuchElementException
     */
    E first();

    /**
     * 返回集合最后一个元素，即最大元素
     * 如果集合为空则抛出NoSuchElementException
     */
    E last();
}

九。interface Map<K,V>

public interface Map<K,V> {
    // Query Operations

    /**
     * 返回map中key-value映像的个数
     * 如果map中元素个数超过Integer.MAX_VALUE，返回Integer.MAX_VALUE
     */
    int size();

    /**
     * 如果map中不含key-value映像则返回true
     */
    boolean isEmpty();

    /**
     * 如果Map中含有一个映射的key值等于给定key则返回true
     *
     * 如果给定key值的类型与Map不相容则抛出ClassCastException
     * 如果给定key为null，并且Map不允许null key则抛出NullPointerException
     */
    boolean containsKey(Object key);

    /**
     * map中key值唯一，但value值可能相同，
     * 如果有一个或多个value与指定value值相等则返回true
     * 同样可能抛出ClassCastException和NullPointerException异常
     */
    boolean containsValue(Object value);

    /**
     * 返回与此key值对应的value值，如果map中不含此key则返回null
     * 这里有一个问题，如果map支持null value，那么返回null无法判断map中是否含有此
     * key值，这里可以用containsKey方法来判断
     * 同样可能抛出ClassCastException和NullPointerException异常
     */
    V get(Object key);

    // Modification Operations

    /**
     * 向map中添加一键值对。如果map中已经含有此key值，则替换原来的value为
     * 给定的value值，判断是否含有key值可使用m.containsKey方法，此方法返回true则
     * key值已经存在，返回false则不存在。
     * 如果m.containsKey返回true，则put方法返回原来的value，否则返回null
     *
     * 如果map不支持此方法则抛出UnsupportedOperationException
     * 如果给定key或value值类型阻止其被存入map则抛出ClassCastException
     * 如果给定key或value为null，并且map允许null key或null value则抛出
     *                           NullPointerException
     * 如果给定key或value的某属性使其不能被存入map则抛出IllegalArgumentException
     */
    V put(K key, V value);

    /**
     * 根据给定key值移除键值对，
     * 返回移除的键值对的value值，如果key值不存在返回null.
     * 如果map支持null value，那么返回null无法判断map中是否含有此
     * key值，这里可以用containsKey方法来判断
     */
    V remove(Object key);


    // Bulk Operations

    /**
     * 将m中所有键值对添加到Map，
     * 此方法等同于在循环中一组一组的添加键值对
     * 如果在添加过程中发现m已经被修改，则称此操作时undefined，可能抛出异常
     */
    void putAll(Map<? extends K, ? extends V> m);

    /**
     * 移除map中所有键值对，此方法返回时isEmpty() = true
     */
    void clear();


    // Views

    /**
     * 返回映射表中所有键的视图集
     * 对map的修改回反应到Set当中，相反，对Set中key进行移除操作，比如
     * Iterator.remove,Set.remove ,removeAll,retainAll,clear等操作时被移除的键
     * 和它相关联的值也将从map中被移除，但是此Set不支持任何添加操作
     * 如果在遍历Set时，发现map已经被修改，则称遍历的结果是undefined
     */
    Set<K> keySet();


    /**
     * 返回映射表中所有值的视图集。
     * 其他特性同上
     * 
     */
    Collection<V> values();


    /**
     * 返回Map.entry对象的视图集，即映射表中的键值对.
     * 你可以从该集合中移除有关元素，同时，这些元素也将从映射表中被移除
     * 但你不能向其中添加任何元素
     * 可以获取Set<Map.Entry<K, V>>的迭代器来遍历map
     */
    Set<Map.Entry<K, V>> entrySet();

    /**
     * 此接口是映射表的入口(键值对)。entrySet方法返回一个map的集合视图，此视图的
     * 元素就是Entry<K,V>,只能通过视图的iterator获取一个map entry的引用
     */
    interface Entry<K,V> {
    	/**
	 * 返回Entry中存储的key值
         * 如果遍历Set<Map.Entry<K, V>>时发现此entry已经被移除则抛出IllegalStateException
	 */
	K getKey();

    	/**
	 * 返回Entry中存储的value值
         * 如果遍历Set<Map.Entry<K, V>>时发现此entry已经被移除则抛出IllegalStateException
	 */
	V getValue();

    	/**
	 * 用给定的value替换此entry对应的value值，如果此键值对已经被移除
         * 则此方法的调用是undefined，此方法返回的是上一个value
         *
         * 如果此value的类型阻止其被存入map则抛出ClassCastException
         * 如果指定value值为null，并且map不允许null值则抛出NullPointerException
         * 如果指定value的一些属性阻止其被存入map则抛出IllegalArgumentException
         * 如果遍历Set<Map.Entry<K, V>>时发现此entry已经被移除则抛出IllegalStateException
         */
	V setValue(V value);

	/**
	 * 比较两个entry是否相等
         * 比较的原则是：
         * 首先o是否是一个Map.entry对象
         * 其次此entry是否对应同一个映射，即键key和value是否相等
         */
	boolean equals(Object o);

	/**
	 * 重新equals方法需要重新hashCode方法。
         * Entry的hashCode值的计算方法为：
         *  (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
	 *  (e.getValue()==null ? 0 : e.getValue().hashCode())
         * 即key的hashCode与value的hashCode按位相与
	 */
	int hashCode();
    }

    // Comparison and hashing

    /**
     * 比较两个Map是否相等
     * 比较原则：
     * 首先o是否是一个Map，即是否实现Map接口
     * 其次Map是否含有相同的键值对，因为map是无序的所以对位置无要求
     * 更加正式的来说m1.entrySet().equals(m2.entrySet())返回true则此方法返回true
     */
    boolean equals(Object o);

    /**
     * 返回Map的hashCode值
     * 计算公式：
     * 为map.entrySet返回的集合的各个entry元素的hashCode之和
     */
    int hashCode();
}

十。interface SortedMap<K,V>

public interface SortedMap<K,V> extends Map<K,V> {
    /**
     * 返回一个比较器用于比较key值大小，
     * 如果key使用自然顺序排列则返回null
     */
    Comparator<? super K> comparator();


    /**
     * 返回一个从fromKey(包含)到toKey(不包含)的子范围
     * 如果fromKey与toKey相等则返回的Map是空集
     * 子范围支持Map的所有操作，并且对子范围的操作将影响到Set
     *
     * 如果使用Map的comparator，fromKey和toKey不能进行互相比较
     * fromKey或toKey的类型与Set元素类型不相容则抛出ClassCastException
     * 如果fromKey或toKey为null，并且Set不支持null元素则抛出空指针异常
     * 如果fromKey比toKey大，这个大是使用comparator比较的结果，
     * 或者Set限制只能访问某范围，而fromKey或toKey位于此范围之外则
     * 抛出IllegalArgumentException
     *
     */
    SortedMap<K,V> subMap(K fromKey, K toKey);


    /**
     * 返回Map中使用比较器或自然顺序，元素大小严格小于toKey的元素集
     * 同样子范围支持Map的所有操作，并会反映到集合
     * 异常抛出同上
     */
    SortedMap<K,V> headMap(K toKey);


    /**
     * 返回Map中使用比较器或自然顺序，元素大小大于等于fromKey的元素集
     * 同样子范围支持Map的所有操作，并会反映到集合
     * 异常抛出同上
     */
    SortedMap<K,V> tailMap(K fromKey);


    /**
     * 返回集合的第一个元素，即最小元素
     * 如果集合为空则抛出NoSuchElementException
     */
    K firstKey();


    /**
     * 返回集合的第最后一个元素，即最大元素
     * 如果集合为空则抛出NoSuchElementException
     */
    K lastKey();


    /**
     * 返回包含在Map中的所有的key的子视图，
     * 用set的iterator返回的key是按升序排列的，其他属性与Map的keySet方法类似
     */
    Set<K> keySet();


    /**
     * 返回包含在Map中的所有的value的子视图，
     * 用Collection的iterator返回的value是按升序排列的，与key是一致的
     * 其他属性与Map的values方法类似
     */
    Collection<V> values();


    /**
     * 返回Map中键值对的视图，
     * Set的iterator返回的元素是键递增的。
     * 其他属性同Map的entrySet方法
     */
    Set<Map.Entry<K, V>> entrySet();
}

十一。interface RandomAccess

/**
 * 此接口是一个记号，它看是否有List实现了此接口来指明是否此List支持快速随机访问
 * ArrayList和Vector都实现了RandomAccess 接口。
 * 可以使用instanceOf关键字来判断是否某集合实现了此接口
 */
public interface RandomAccess {
}

十二。双端队列Deque

/**
 * 
 * 双端队列，一个线性集合，负责在队列两端插入和移除元素.
 */
public interface Deque<E> extends Queue<E> {
    /**
     * 
     * 将指定元素插入到双端队列的开头(如果这样做不违反容量限制)
     * 如果队列有容量限制，使用offerFirst方法会更好，因为
     * offerFirst在插入元素失败时返回一个null而不是抛出一个异常终止程序
     */
    void addFirst(E e);

    /**
     *  将指定元素插入到双端队列的结尾(如果这样做不违反容量限制)
     *  如果队列有容量限制，请使用offerLast方法
     */
    void addLast(E e);

    boolean offerFirst(E e);
    boolean offerLast(E e);

    /**
     * 
     * 移除双端队列的第一个元素，此方法在队列为空时
     * 将抛出一个异常
     */
    E removeFirst();

    /**
     * 移除双端队列的最后一个元素，此方法在队列为空时
     * 将抛出一个异常
     */
    E removeLast();

    /**
     * 移除双端队列的第一个元素，此方法在队列为空时
     * 将返回null
     */
    E pollFirst();

    /**
     * 移除双端队列最后一个元素，此方法在队列为空时
     * 将返回null
     */
    E pollLast();

    /**
     * 获取双端队列的第一个元素，此方法在队列为空时
     * 将抛出一个异常
     */
    E getFirst();

    /**
     * 获取双端队列的最后一个元素，此方法在队列为空时
     * 将抛出一个异常
     */
    E getLast();

    /**
     * 获取双端队列的第一个元素，此方法在队列为空时
     * 将返回null
     */
    E peekFirst();

    /**
     * 获取双端队列的最后一个元素，此方法在队列为空时
     * 将返回null
     */
    E peekLast();

    /**
     * 
     *  找到o在队列中第一次出现的位置，并移除它
     *  如果队列不包含此元素，do nothing
     */
    boolean removeFirstOccurrence(Object o);

    /**
     * 
     * 找到o在队列中最后一次出现的位置，并移除它
     */
    boolean removeLastOccurrence(Object o);
    
    

    // *** 下面是队列queue的一些方法 ***

    /**
     * 
     * 向双端队列 尾部添加一个元素,同addLast
     */
    boolean add(E e);

    /**
     * 向双端队列 尾部添加一个元素,同offerLast
     */
    boolean offer(E e);

    /**
     * 移除双端队列第一个元素，同removeFirst
     */
    E remove();

    /**
     *  移除双端队列第一个元素，同pollFirst
     */
    E poll();

    /**
     * 获取双端队列第一个元素，同getFirst
     */
    E element();

    /**
     * 获取双端队列第一个元素，同peekFirst
     */
    E peek();


    // *** 下面是栈的一些方法 ***

    /**
     * 向双端队列头部添加一个元素，同addFirst
     */
    void push(E e);

    /**
     * 移除双端队列第一个元素，并返回它,同removeFirst
     */
    E pop();


    // *** 集合的一些方法 ***

    /**
     * 从此双端队列中移除第一次出现的指定元素。如果此双端队列不包含该元素，则不作更改
     */
    boolean remove(Object o);

    /**
     * 如果双端队列包含此元素则返回true
     */
    boolean contains(Object o);

    /**
     * 队列元素个数
     */
    public int size();

    /**
     * 返回双端队列的迭代器
     */
    Iterator<E> iterator();

    /**
     * 返回一个逆序遍历的迭代器
     */
    Iterator<E> descendingIterator();

}

附上一张集合框架的接口关系图