集合框架源码分析篇一（接口篇）-网络销售属于什么行业-程序博客网

Java代码

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

Java代码

public interface Iterator<E> {
/**
* 返回true如果迭代还有更多的元素
* 换而言之，如果调用next()方法返回一个元素而不是抛出一个异常则返回true
*/
boolean hasNext();
/**
* 返回迭代器中的下一个元素
* 如果迭代器中没有更多的元素则抛出NoSuchElementException
*/
E next();
/**
* remove方法将移除上一次调用next方法时返回的元素，如果想移除特定位置的元素
* 需要先逃过该元素
*
* 如果没有调用next方法就调用remove方法将抛出IllegalStateException
*/
void remove();
}

Java代码

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();
}

Java代码

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);
}

Java代码

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);
}

Java代码

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();
}

Java代码

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();
}

Java代码

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();
}

Java代码

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();
}

Java代码

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();
}

Java代码

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

Java代码

/**
*
* 双端队列，一个线性集合，负责在队列两端插入和移除元素.
*/
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();
}