JAVA中的集合

1. Java集合框架

1.1 Java集合框架中的接口

Java集合框架为不同类型的集合定义了大量接口，如图：

集合有两个基本的接口即Collection和Map。

collection在java集合中，算是顶级接口，它继承了iterable接口，不能实例化，只能实例化其子类。之所以需要这样一个接口，是因为java作为面向对象，总是避免不了处理多个对象的情况，要处理多个对象，首先需要容器存储，这个容器就是集合。为什么有了数组，还需要集合，因为数组的功能单一，长度不可变，而有些集合实现类则是对数组操作的封装。

1.2 Java库中的具体集合

在下表中，除了以Map结尾的类之外，其他类都实现了Collection接口，而以Map结尾的类实现了Map接口。

集合类型	描述
ArrayList	可以动态增长和缩减的一个索引序列
LinkedList	可以在任何位置高效插入和删除的一个有序序列
ArrayDeque	实现为循环数组的一个双端队列
HashSet	没有重复元素的一个无序集合
TreeSet	一个有序集
EnumSet	一个包含枚举类型值的集
LinkedHashSet	一个可以记住元素插入次序的集
PriorityQueue	允许高效删除最小元素的一个集合
HashMap	存储键/值关联的一个数据结构
TreeMap	键有序的一个映射
EnumMap	键属于枚举类型的一个映射
LinkedHashMap	可以记住键/值项添加次序的一个映射
WeakHashMap	值不会再别处使用时就可以被垃圾回收的一个映射
IdentityHashMap	用 == 而不是用 equals 比较键的一个映射

具体集合类之间的关系如下：

2. Iterator接口

2.1 Iterator

Iterator接口包含四个方法：

public interface Iterator<E> {
    E next();			//取元素
    boolean hasNext();	//判断是否还有元素
    void remove();		//删除上次调用next方法时返回的元素
    default void forEachRemaining(Consumer<? super E> action);	//遍历元素，并实现参数给的操作。
}

以下是一个使用迭代器遍历集合的实例：

Collection<String> c = ……;
Iterator<String> iter = c.iterator();
while (iter.hasNext()) {
    String element = iter.next();
    do someting with element
}

通过反复调用next方法，可以逐个访问集合中的所有元素，但如果到达了集合的末尾，next方法将抛出一个NoSuchElementException。所以在调用next方法之前需要调用hasNext方法判断集合中是否还有元素。

用for each循环可以更加简练地表示同样的循环操作：

for (String element : c) {
    do something with element
}

for each循环可以处理任何实现了Iterable接口的对象，这个接口只包含了一个抽象方法：

public interface Iterable<E> {
    Iterator<E> iterator();
    ……
}

Collection接口扩展了Iterable接口，所以对于标准类库中的所有集合都可以使用for each循环

另一种循环的方法是调用Iterator接口中的forEachRemaing方法并提供一个lambda表达式。迭代器的每一个元素都会调用这个lambda表达式，直到遍历完毕。

iterator.forEachRemaining(element -> do something with element);

**注意：**迭代器的位置是处于两元素之间的。

2.2 ListIterator

ListIterator是列表的迭代器，允许程序员在任一方向上遍历列表，在迭代期间修改列表，并获取迭代器在列表中的当前位置。

构造方法

构造器	描述
ListIterator<E> listIterator()	返回一个列表迭代器，用来访问列表中的元素
ListIterator<E> listIterator(int index)	返回一个列表迭代器，用来访问列表中的元素，第一个调用这个迭代器的next会返回给定索引的元素。

方法摘要

变量和类型	方法	描述
void	add(int i, E e)	在给定位置添加一个元素。
boolean	hasNext()	如果此列表迭代器在向前遍历列表时具有更多元素，则返回 true 。
boolean	hasPrevious()	如果此列表迭代器在反向遍历列表时具有更多元素，则返回 true 。
E	next()	返回列表中的下一个元素并前进光标位置。
int	nextIndex()	返回后续调用next将返回的元素的索引。
E	previous()	返回列表中的上一个元素并向后移动光标位置。
int	previousIndex()	返回后续调用 previous()将返回的元素的索引。
void	remove()	从列表中删除 next()或 previous() （可选操作）返回的最后一个元素。
void	set(E e)	用指定的元素替换next()或 previous()返回的最后一个元素（可选操作）。

2.3 Iterator和ListIterator的异同

相同点

都是迭代器，当需要对集合中元素进行遍历不需要干涉其遍历过程时，这两种迭代器都可以使用。

不同点

1.使用范围不同，Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型。

2.ListIterator有add方法，可以向List中添加对象，而Iterator不能。

3.ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator不可以。

4.ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

5.都可实现删除操作，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。

3. Collection接口

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

Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是 java.util.List 与 java.util.Set。

Collection接口包含了两个基本方法：

public interface Collection<E> {
    boolean add(E element);
    Iterator<E> iterator();
    ……
}

其它的方法包括：

int size();
boolean isEmpty();
boolean contains(Object obj);
boolean containsAll(Collention<?> c);
boolean equals(Object other);
boolean addAll(Collection<? extends E> from);
boolean remove(Object obj);
boolean removeAll(Collection<?> c);
void clear();
boolean retainAll(Collection<?> c);
Object[] toArray();
<T> T[] toArray(T[] arrayToFill);

List接口

List是一个有序集合。元素会增加到容器中的特定位置。可以采用两种方式访问元素：使用迭代器访问，或者使用一个整数索引来访问（随机访问）。

List接口定义了多个用于随机访问的方法：

void add(int index, E element);
void remove(int index);
E get(int index);
E set(int index, E elment);

3.1 ArrayList

ArrayList是数组列表，它是用数组存储元素的，这个数组可以动态创建，如果元素个数超过了数组的容量，那么就创建一个更大的新数组，并将当前数组中的元素都复制到新数组中。

ArrayList的特点是查找快，插入和删除慢（因为每插入一个元素都需要先将后面的所以元素依次往后移动一个位置，删除同理）。

构造方法摘要

构造器	描述
ArrayList()	构造一个初始容量为10的空列表。
ArrayList(int initialCapacity)	构造具有指定初始容量的空列表。
ArrayList(Collection<? extends E> c)	按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。

方法摘要

变量和类型	方法	描述
void	add(int index, E element)	将指定元素插入此列表中的指定位置。
boolean	add(E e)	将指定的元素追加到此列表的末尾。
boolean	addAll(int index, Collection<? extends E> c)	从指定位置开始，将指定集合中的所有元素插入此列表。
boolean	addAll(Collection<? extends E> c)	将指定集合中的所有元素按指定集合的Iterator返回的顺序附加到此列表的末尾。
void	clear()	从此列表中删除所有元素。
Object	clone()	返回此 ArrayList实例的浅表副本。
boolean	contains(Object o)	如果此列表包含指定的元素，则返回 true 。
void	ensureCapacity(int minCapacity)	如有必要，增加此 ArrayList实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。
void	forEach(Consumer<? super E> action)	对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。
E	get(int index)	返回此列表中指定位置的元素。
int	indexOf(Object o)	返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
boolean	isEmpty()	如果此列表不包含任何元素，则返回 true 。
Iterator<E>	iterator()	以适当的顺序返回此列表中元素的迭代器。
int	lastIndexOf(Object o)	返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
ListIterator<E>	listIterator()	返回此列表中元素的列表迭代器（按适当顺序）。
ListIterator<E>	listIterator(int index)	从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。
E	remove(int index)	删除此列表中指定位置的元素。
boolean	remove(Object o)	从该列表中删除指定元素的第一个匹配项（如果存在）。
boolean	removeAll(Collection<?> c)	从此列表中删除指定集合中包含的所有元素。
boolean	removeIf(Predicate<? super E> filter)	删除此集合中满足给定谓词的所有元素。
protected void	removeRange(int fromIndex, int toIndex)	从此列表中删除索引介于 fromIndex （含）和 toIndex （独占）之间的所有元素。
boolean	retainAll(Collection<?> c)	仅保留此列表中包含在指定集合中的元素。
E	set(int index, E element)	用指定的元素替换此列表中指定位置的元素。
int	size()	返回此列表中的元素数。
Spliterator<E>	spliterator()	在此列表中的元素上创建late-binding和故障快速 Spliterator 。
List<E>	subList(int fromIndex, int toIndex)	返回指定的 fromIndex （包含）和 toIndex （不包括）之间的此列表部分的视图。
Object[]	toArray()	以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
<T> T[]	toArray(T[] a)	以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。
void	trimToSize()	将此 ArrayList实例的容量调整为列表的当前大小。

Vector和ArrayList的区别

Vector也是可动态变化的数组，不同的是，Vector类的所有方法都是同步的。可以安全地从两个线程访问一个Vector对象。当然同步操作也会占用时间。所以如果只从一个线程使用数组，就使用ArrayList，因为ArrayList方法是不同步的。

3.2 LinkedList

LinkedList使用链表实现的列表，数组是在连续的存储位置上存放对象引用，而链表则是将每个对象存放在单独的链接（结点）中。每个链接还存放着序列中下一个链接的引用。

在Java中，所有链表实际上都是双向链接的(doubly linked)------即每个链接还存放着其前驱的引用。

LinkedList的特点是，插入和删除快，查找慢。

构造方法摘要

构造器	描述
*LinkedList()	构造一个空列表。
*LinkedList(Collection<? extends E> c)	按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。

方法摘要

变量和类型	方法	描述
void	add(int index, E element)	将指定元素插入此列表中的指定位置。
boolean	*add(E e)	将指定的元素追加到此列表的末尾。
boolean	addAll(int index, Collection<? extends E> c)	从指定位置开始，将指定集合中的所有元素插入此列表。
boolean	addAll(Collection<? extends E> c)	将指定集合中的所有元素按指定集合的迭代器返回的顺序附加到此列表的末尾。
void	*addFirst(E e)	在此列表的开头插入指定的元素。
void	*addLast(E e)	将指定的元素追加到此列表的末尾。
void	clear()	从此列表中删除所有元素。
Object	clone()	返回此 LinkedList的浅表副本。
boolean	contains(Object o)	如果此列表包含指定的元素，则返回 true 。
Iterator<E>	descendingIterator()	以相反的顺序返回此双端队列中元素的迭代器。
E	element()	检索但不删除此列表的头部（第一个元素）。
E	get(int index)	返回此列表中指定位置的元素。
E	*getFirst()	返回此列表中的第一个元素。
E	*getLast()	返回此列表中的最后一个元素。
int	indexOf(Object o)	返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
int	lastIndexOf(Object o)	返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
ListIterator<E>	listIterator(int index)	从列表中的指定位置开始，返回此列表中元素的列表迭代器（按正确顺序）。
boolean	offer(E e)	将指定的元素添加为此列表的尾部（最后一个元素）。
boolean	offerFirst(E e)	在此列表的前面插入指定的元素。
boolean	offerLast(E e)	在此列表的末尾插入指定的元素。
E	peek()	检索但不删除此列表的头部（第一个元素）。
E	peekFirst()	检索但不删除此列表的第一个元素，如果此列表为空，则返回 null 。
E	peekLast()	检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null 。
E	poll()	检索并删除此列表的头部（第一个元素）。
E	pollFirst()	检索并删除此列表的第一个元素，如果此列表为空，则返回 null 。
E	pollLast()	检索并删除此列表的最后一个元素，如果此列表为空，则返回 null 。
E	pop()	弹出此列表所代表的堆栈中的元素。
void	push(E e)	将元素推送到此列表所表示的堆栈上。
E	remove()	检索并删除此列表的头部（第一个元素）。
E	remove(int index)	删除此列表中指定位置的元素。
boolean	remove(Object o)	从该列表中删除指定元素的第一个匹配项（如果存在）。
E	*removeFirst()	从此列表中删除并返回第一个元素。
boolean	removeFirstOccurrence(Object o)	删除此列表中第一次出现的指定元素（从头到尾遍历列表时）。
E	*removeLast()	从此列表中删除并返回最后一个元素。
boolean	removeLastOccurrence(Object o)	删除此列表中最后一次出现的指定元素（从头到尾遍历列表时）。
E	set(int index, E element)	用指定的元素替换此列表中指定位置的元素。
int	size()	返回此列表中的元素数。
Spliterator<E>	spliterator()	在此列表中的元素上创建late-binding和故障快速 Spliterator 。
Object[]	toArray()	以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
<T> T[]	toArray(T[] a)	以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。

Set接口

链表和数组允许指定元素的次序，但如果想要查看某个元素却不记得位置，就需要访问所有元素，直到找到为止。

下面这些数据结构能够快速查找元素，其缺点是无法控制元素出现的次序。

3.2HashSet

散列表是一种可以快速查找对象的数据结构。

散列表位每个对象计算一个整数，称为散列码。散列码是由对象的实例字段得出的正数。准确来说，有不同数据的对象将产生不同的散列码。

在Java中，散列表用链表数组实现。每个列表被称为桶，所得到的结果就是保存这个元素的桶的索引,如图：

查找表中元素的方法：需要先计算散列码，然后与桶的总数取余，所得到的结果就是保存这个元素的桶的索引。

eg：某个对象的散列码为76268，且有128个桶，那么这个对象应该在地108号桶中（因为 76268 mod 128 = 108）

有时候会遇到桶已经被填充的情况，这种现象被称为散列冲突(hash collision)。在Java8中，桶满时会从链表变为平衡二叉树。

构造方法

构造器	描述
HsahSet()	构造一个空散列集。
HashSet(Collection<? extends E> elements)	构造一个散列集，并将集合中的所有元素都添加到这个散列集中。
HashSet(int initialCapacity)	构造一个空的具有指定容量（桶数）的散列集。
HashSet(int initialCapacity, float loadFactor)	构造一个又指定容量和装填因子（0.0~1.0之间的一个数，确定散列表填充的百分比，当大于这个百分比时，散列表再进行散列）的空散列集。

方法摘要

变量和类型	方法	描述
boolean	add(E e)	如果指定的元素尚不存在，则将其添加到此集合中。
void	clear()	从该集中删除所有元素。
Object	clone()	返回此 HashSet实例的浅表副本：未克隆元素本身。
boolean	contains(Object o)	如果此set包含指定的元素，则返回 true 。
boolean	isEmpty()	如果此集合不包含任何元素，则返回 true 。
Iterator<E>	iterator()	返回此set中元素的迭代器。
boolean	remove(Object o)	如果存在，则从该集合中移除指定的元素。
int	size()	返回此集合中的元素数（基数）。
Spliterator<E>	spliterator()	在此集合中的元素上创建late-binding和失败快速 Spliterator。
int	hashCode()	返回这个对象的散列码。散列码可以使任何整数，包括整数或负数。

3.3 TreeSet

TreeSet类与散列集十分类似，相较于散列集有所改进的是树集是一个有序集合(sorted collection)，可以任意顺序将元素插入到集合中。在对集合进行遍历时，值将自动地按照排序后的顺序呈现。

正如TreeSet类名所示，排序是用一个树数据结构完成的（红黑树red-black tree）。每次将一个元素添加到树中时，都会将其放置在正确的排序位置上。不过将一个元素添加到树中要比添加到散列表中慢。

从Java6起，TreeSet类实现了NavigableSet接口。这个接口增加了几个查找元素以及反向遍历的便利方法。

一个NavigableSet实现基于一个TreeMap 的元件使用其有序natural ordering ，或由Comparator集合创建时提供，这取决于所使用的构造方法。

TreeSet底层则采用NavigableMap这个接口来保存TreeSet集合，而实际上NavigableMap只是一个接口，实际上TreeSet还是用TreeMap来保存set元素。

构造方法摘要

构造器	描述
*TreeSet()	构造一个新的空树集，根据其元素的自然顺序进行排序。
*TreeSet(Collection<? extends E> c)	构造一个新的树集，其中包含指定集合中的元素，并根据其元素的 自然顺序进行排序 。
*TreeSet(Comparator<? super E> comparator)	构造一个新的空树集，根据指定的比较器进行排序。
*TreeSet(SortedSet<E> s)	构造一个包含相同元素并使用与指定有序集相同排序的新树集。

方法摘要

变量和类型	方法	描述
boolean	add(E e)	如果指定的元素尚不存在，则将其添加到此集合中。
boolean	addAll(Collection<? extends E> c)	将指定集合中的所有元素添加到此集合中。
E	ceiling(E e)	返回此set中大于或等于给定元素的 null元素，如果没有这样的元素，则 null 。
void	clear()	从该集中删除所有元素。
Object	clone()	返回此 TreeSet实例的浅表副本。
boolean	contains(Object o)	如果此set包含指定的元素，则返回 true 。
Iterator<E>	descendingIterator()	以降序返回此集合中元素的迭代器。
NavigableSet<E>	descendingSet()	返回此set中包含的元素的逆序视图。
E	first()	返回此集合中当前的第一个（最低）元素。
E	floor(E e)	返回此set中小于或等于给定元素的最大元素，如果没有这样的元素，则 null 。
SortedSet<E>	headSet(E toElement)	返回此set的部分视图，其元素严格小于 toElement 。
NavigableSet<E>	headSet(E toElement, boolean inclusive)	返回此set的部分视图，其元素小于（或等于，如果 inclusive为true） toElement 。
E	higher(E e)	返回此集合中的最小元素严格大于给定元素，如果没有这样的元素，则 null 。
boolean	isEmpty()	如果此集合不包含任何元素，则返回 true 。
Iterator<E>	iterator()	以升序返回此集合中元素的迭代器。
E	last()	返回此集合中当前的最后一个（最高）元素。
E	lower(E e)	返回此集合中的最大元素严格小于给定元素，如果没有这样的元素，则 null 。
E	pollFirst()	检索并删除第一个（最低）元素，如果此组为空，则返回 null 。
E	pollLast()	检索并删除最后一个（最高）元素，如果此集合为空，则返回 null 。
boolean	remove(Object o)	如果存在，则从该集合中移除指定的元素。
int	size()	返回此集合中的元素数（基数）。
Spliterator<E>	spliterator()	在此集合中的元素上创建late-binding和故障快速 Spliterator 。
NavigableSet<E>	subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)	返回此set的部分视图，其元素范围为 fromElement到 toElement 。
SortedSet<E>	subSet(E fromElement, E toElement)	返回此set的部分视图，其元素范围从 fromElement （含）到 toElement （独占）。
SortedSet<E>	tailSet(E fromElement)	返回此set的部分视图，其元素大于或等于 fromElement 。
NavigableSet<E>	tailSet(E fromElement, boolean inclusive)	返回此set的部分视图，其元素大于（或等于，如果 inclusive为true） fromElement 。

Queue接口

3.4 Queue和Deque

队列允许高效地在尾部添加元素，并在头部删除元素。

双端队列（即deuqe）允许在头部和尾部高效地添加或删除元素，不支持在队列中间添加元素。

Java6中引入了Deque接口，ArrayDeque和LinkedList类实现了这个接口。这两个类都可以提供双端队列，其大小可以根据需要扩展。

Queue接口实现的方法：

方法摘要

变量和类型	方法	描述
boolean	add(E e)	如果可以在不违反容量限制的情况下立即执行此操作，则将指定的元素插入此队列，成功时返回 true ，如果当前没有空间，则抛出 IllegalStateException 。
E	element()	检索但不删除此队列的头部。
boolean	offer(E e)	如果可以在不违反容量限制的情况下立即执行此操作，则将指定的元素插入此队列。
E	peek()	检索但不删除此队列的头部，如果此队列为空，则返回 null 。
E	poll()	检索并删除此队列的头部，如果此队列为空，则返回 null 。
E	remove()	检索并删除此队列的头部。

Deque接口实现的方法：

方法摘要

变量和类型	方法	描述
boolean	add(E e)	将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如果它是立即可行且不会违反容量限制，返回 true成功时和抛出 IllegalStateException如果当前没有空间可用的。
boolean	addAll(Collection<? extends E> c)	在此双端队列的末尾添加指定集合中的所有元素，就像通过在每个 对象上调用 addLast(E)一样，按照集合的迭代器返回它们的顺序。
void	*addFirst(E e)	如果可以在不违反容量限制的情况下立即插入指定元素，则在此双端队列的前面插入指定元素，如果当前没有可用空间，则抛出 IllegalStateException 。
void	*addLast(E e)	如果可以在不违反容量限制的情况下立即插入指定元素，则在此双端队列的末尾插入指定元素，如果当前没有可用空间，则抛出 IllegalStateException 。
boolean	contains(Object o)	如果此双端队列包含指定的元素，则返回 true 。
Iterator<E>	descendingIterator()	以相反的顺序返回此双端队列中元素的迭代器。
E	element()	检索但不删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素）。
E	*getFirst()	检索但不删除此双端队列的第一个元素。
E	*getLast()	检索但不删除此双端队列的最后一个元素。
Iterator<E>	iterator()	以适当的顺序返回此双端队列中元素的迭代器。
boolean	offer(E e)	将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如果它是立即可行且不会违反容量限制，返回 true在成功和 false如果当前没有空间可用。
boolean	*offerFirst(E e)	将指定元素插入此双端队列的前面，除非它违反容量限制。
boolean	*offerLast(E e)	在此双端队列的末尾插入指定的元素，除非它违反容量限制。
E	peek()	检索但不移除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回 null 。
E	*peekFirst()	检索但不删除此双端队列的第一个元素，如果此双端队列为空，则返回 null 。
E	*peekLast()	检索但不删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null 。
E	poll()	检索并删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回 null 。
E	*pollFirst()	检索并删除此双端队列的第一个元素，如果此双端队列为空，则返回 null 。
E	*pollLast()	检索并删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null 。
E	pop()	从此双端队列表示的堆栈中弹出一个元素。
void	push(E e)	如果可以在不违反容量限制的情况下立即执行此操作， IllegalStateException到此双端队列表示的堆栈（换句话说，在此双端队列的头部），如果当前没有可用空间则抛出 IllegalStateException 。
E	remove()	检索并删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素）。
boolean	remove(Object o)	从此双端队列中删除第一次出现的指定元素。
E	*removeFirst()	检索并删除此双端队列的第一个元素。
boolean	removeFirstOccurrence(Object o)	从此双端队列中删除第一次出现的指定元素。
E	*removeLast()	检索并删除此双端队列的最后一个元素。
boolean	removeLastOccurrence(Object o)	从此双端队列中删除最后一次出现的指定元素。
int	size()	返回此双端队列中的元素数。

ArrayDeque类实现的方法：

构造方法摘要

构造器	描述
ArrayDeque()	构造一个空数组deque，其初始容量足以容纳16个元素。
ArrayDeque(int numElements)	构造一个空数组deque，其初始容量足以容纳指定数量的元素。
ArrayDeque(Collection<? extends E> c)	按照集合的迭代器返回的顺序构造一个包含指定集合元素的双端队列。

方法摘要

变量和类型	方法	描述
boolean	add(E e)	在此双端队列的末尾插入指定的元素。
boolean	addAll(Collection<? extends E> c)	在此双端队列的末尾添加指定集合中的所有元素，就好像通过在每个双端子上调用 addLast(E)一样 ，按照集合的迭代器返回它们的顺序。
void	addFirst(E e)	在此双端队列的前面插入指定的元素。
void	addLast(E e)	在此双端队列的末尾插入指定的元素。
void	clear()	从此双端队列中删除所有元素。
ArrayDeque<E>	clone()	返回此双端队列的副本。
boolean	contains(Object o)	如果此双端队列包含指定的元素，则返回 true 。
E	element()	检索但不删除此双端队列表示的队列的头部。
void	forEach(Consumer<? super E> action)	对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。
E	getFirst()	检索但不删除此双端队列的第一个元素。
E	getLast()	检索但不删除此双端队列的最后一个元素。
boolean	isEmpty()	如果此双端队列不包含任何元素，则返回 true 。
Iterator<E>	iterator()	返回此双端队列中元素的迭代器。
boolean	offer(E e)	在此双端队列的末尾插入指定的元素。
boolean	offerFirst(E e)	在此双端队列的前面插入指定的元素。
boolean	offerLast(E e)	在此双端队列的末尾插入指定的元素。
E	peek()	检索但不删除此双端队列表示的队列的头部，如果此双端队列为空，则返回 null 。
E	poll()	检索并删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回 null 。
E	pop()	从此双端队列表示的堆栈中弹出一个元素。
void	push(E e)	将元素推送到此双端队列表示的堆栈上。
E	remove()	检索并删除此双端队列表示的队列的头部。
boolean	remove(Object o)	从此双端队列中删除指定元素的单个实例。
boolean	removeAll(Collection<?> c)	删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。
E	removeFirst()	检索并删除此双端队列的第一个元素。
boolean	removeFirstOccurrence(Object o)	删除此双端队列中第一次出现的指定元素（从头到尾遍历双端队列时）。
boolean	removeIf(Predicate<? super E> filter)	删除此集合中满足给定谓词的所有元素。
E	removeLast()	检索并删除此双端队列的最后一个元素。
boolean	removeLastOccurrence(Object o)	删除此双端队列中最后一次出现的指定元素（从头到尾遍历双端队列时）。
boolean	retainAll(Collection<?> c)	仅保留此集合中包含在指定集合中的元素（可选操作）。
int	size()	返回此双端队列中的元素数。
Spliterator<E>	spliterator()	在此双端队列中的元素上创建late-binding和失败快速 Spliterator 。
Object[]	toArray()	以适当的顺序（从第一个元素到最后一个元素）返回一个包含此双端队列中所有元素的数组。
<T> T[]	toArray(T[] a)	以适当的顺序（从第一个元素到最后一个元素）返回一个包含此双端队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。

3.5 PriorityQueue

优先队列(priority queue)中的元素可以按照任意的顺序插入，但会按照有序的顺序进行检索。所以当调用remove方法时，总会获得当前优先队列中最小的元素。

不过，优先队列并没有对所有元素进行排序。如果只是迭代处理这些元素，并不需要对它们进行排序。

优先队列使用了堆（heap）（有小根堆和大根堆之分）数据结构。堆是一个可以自组织的二叉树，其添加（add）和删除（remove）操作可以让最小的元素移动到根，而不用花费时间对元素进行排序。

优先队列既可以保存实现Comparable接口的类对象，也可以保存构造器中提供的Comparator对象。

构造方法摘要

构造器	描述
*PriorityQueue()	使用默认初始容量（11）创建PriorityQueue ，根据其natural ordering对其元素进行排序 。
*PriorityQueue(int initialCapacity)	创建具有指定初始容量的PriorityQueue ，该容量根据其natural ordering对其元素进行排序。
*PriorityQueue(int initialCapacity, Comparator<? super E> comparator)	创建具有指定初始容量的 PriorityQueue ，该容量根据指定的比较器对其元素进行排序。
PriorityQueue(Collection<? extends E> c)	创建包含指定集合中的元素的 PriorityQueue 。
PriorityQueue(Comparator<? super E> comparator)	创建具有默认初始容量的 PriorityQueue ，其元素根据指定的比较器进行排序。
PriorityQueue(PriorityQueue<? extends E> c)	创建包含指定优先级队列中的元素的 PriorityQueue 。
PriorityQueue(SortedSet<? extends E> c)	创建一个 PriorityQueue其中包含指定有序集合中的元素。

方法摘要

变量和类型	方法	描述
boolean	add(E e)	将指定的元素插入此优先级队列。
void	clear()	从此优先级队列中删除所有元素。
Comparator<? super E>	comparator()	返回用于为了在这个队列中的元素，或比较null如果此队列根据所述排序natural ordering的元素。
boolean	contains(Object o)	如果此队列包含指定的元素，则返回 true 。
void	forEach(Consumer<? super E> action)	对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。
Iterator<E>	iterator()	返回此队列中元素的迭代器。
boolean	offer(E e)	将指定的元素插入此优先级队列。
boolean	remove(Object o)	从此队列中删除指定元素的单个实例（如果存在）。
boolean	removeAll(Collection<?> c)	删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。
boolean	removeIf(Predicate<? super E> filter)	删除此集合中满足给定谓词的所有元素。
boolean	retainAll(Collection<?> c)	仅保留此集合中包含在指定集合中的元素（可选操作）。
Spliterator<E>	spliterator()	在此队列中的元素上创建late-binding和故障快速 Spliterator 。
Object[]	toArray()	返回包含此队列中所有元素的数组。
<T> T[]	toArray(T[] a)	返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。

4.Map接口

4.1 HashMap

如果我们知道某些关键信息，希望查找与之关联的元素，那么就可以使用映射（map）数据结构。

映射用来存放键/值对。如果提供了键就能查找到值。

散列映射对键进行散列，散列或比较函数只应用于键，与键关联的值不进行散列或比较。

与集一样，散列稍微快一些，如果不需要按照有序的顺序访问键，最好选择散列映射。

键必须是唯一的，不能对同一个键存放两个值，如果对同一个键调用两次put方法，第二个值就会取代第一个值。

构造方法摘要

构造器	描述
HashMap()	使用默认初始容量（16）和默认加载因子（0.75）构造一个空 HashMap 。
HashMap(int initialCapacity)	使用指定的初始容量和默认加载因子（0.75）构造一个空 HashMap 。
HashMap(int initialCapacity, float loadFactor)	使用指定的初始容量和加载因子构造一个空 HashMap 。
HashMap(Map<? extends K,? extends V> m)	构造一个新的 HashMap ，其映射与指定的 Map相同。

方法摘要

变量和类型	方法	描述
void	clear()	从此映射中删除所有映射。
Object	clone()	返回此 HashMap实例的浅表副本：未克隆键和值本身。
V	compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)	尝试计算指定键及其当前映射值的映射（如果没有当前映射， null ）。
V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)	如果指定的键尚未与值关联（或映射到 null ），则尝试使用给定的映射函数计算其值并将其输入此映射，除非 null 。
V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)	如果指定键的值存在且为非null，则尝试在给定键及其当前映射值的情况下计算新映射。
boolean	containsKey(Object key)	如果此映射包含指定键的映射，则返回 true 。
boolean	containsValue(Object value)	如果此映射将一个或多个键映射到指定值，则返回 true 。
Set<Map.Entry<K,V>>	entrySet()	返回此映射中包含的映射的Set视图。
V	get(Object key)	返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
boolean	isEmpty()	如果此映射不包含键 - 值映射，则返回 true 。
Set<K>	keySet()	返回此映射中包含的键的Set视图。
V	merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)	如果指定的键尚未与值关联或与null关联，则将其与给定的非空值关联。
V	put(K key, V value)	将指定的值与此映射中的指定键相关联。
void	putAll(Map<? extends K,? extends V> m)	将指定映射中的所有映射复制到此映射。
V	remove(Object key)	从此映射中删除指定键的映射（如果存在）。
int	size()	返回此映射中键 - 值映射的数量。
Collection<V>	values()	返回此映射中包含的值的Collection视图。

4.2 TreeMap

树映射根据键的顺序将元素组织为一个搜索树。

构造方法摘要

构造器	描述
TreeMap()	使用其键的自然顺序构造一个新的空树图。
TreeMap(Comparator<? super K> comparator)	构造一个新的空树图，根据给定的比较器排序。
TreeMap(Map<? extends K,? extends V> m)	构造一个新的树映射，其中包含与给定映射相同的映射，根据其键的 自然顺序排序 。
TreeMap(SortedMap<K,? extends V> m)	构造一个包含相同映射的新树映射，并使用与指定有序映射相同的顺序。

方法摘要

变量和类型	方法	描述
Map.Entry<K,V>	ceilingEntry(K key)	返回与大于或等于给定键的最小键关联的键 - 值映射，如果没有此键，则 null 。
K	ceilingKey(K key)	返回大于或等于给定键的 null键，如果没有这样的键，则 null 。
void	clear()	从此映射中删除所有映射。
Object	clone()	返回此 TreeMap实例的浅表副本。
boolean	containsKey(Object key)	如果此映射包含指定键的映射，则返回 true 。
boolean	containsValue(Object value)	如果此映射将一个或多个键映射到指定值，则返回 true 。
NavigableSet<K>	descendingKeySet()	返回此映射中包含的键的反向顺序NavigableSet视图。
NavigableMap<K,V>	descendingMap()	返回此映射中包含的映射的逆序视图。
Set<Map.Entry<K,V>>	entrySet()	返回此映射中包含的映射的Set视图。
Map.Entry<K,V>	firstEntry()	返回与此映射中的最小键关联的键 - 值映射，如果映射为空，则 null 。
K	firstKey()	返回此映射中当前的第一个（最低）键。
Map.Entry<K,V>	floorEntry(K key)	返回与小于或等于给定键的最大键关联的键 - 值映射，如果没有此键，则 null 。
K	floorKey(K key)	返回小于或等于给定键的最大键，如果没有这样的键，则 null 。
V	get(Object key)	返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
SortedMap<K,V>	headMap(K toKey)	返回此映射的部分视图，其键严格小于 toKey 。
NavigableMap<K,V>	headMap(K toKey, boolean inclusive)	返回此映射的部分视图，其键小于（或等于，如果 inclusive为真） toKey 。
Map.Entry<K,V>	higherEntry(K key)	返回与严格大于给定键的最小键关联的键 - 值映射，如果没有此键，则 null 。
K	higherKey(K key)	返回严格大于给定键的最小键，如果没有这样的键，则返回 null 。
Set<K>	keySet()	返回此映射中包含的键的Set视图。
Map.Entry<K,V>	lastEntry()	返回与此映射中的最大键关联的键 - 值映射，如果映射为空，则 null 。
K	lastKey()	返回此映射中当前的最后一个（最高）键。
Map.Entry<K,V>	lowerEntry(K key)	返回与严格小于给定键的最大键相关联的键 - 值映射，如果没有这样的键，则 null 。
K	lowerKey(K key)	返回严格小于给定键的最大键，如果没有这样键，则返回 null 。
NavigableSet<K>	navigableKeySet()	返回此映射中包含的键的NavigableSet视图。
Map.Entry<K,V>	pollFirstEntry()	删除并返回与此映射中的最小键关联的键 - 值映射，如果映射为空，则 null 。
Map.Entry<K,V>	pollLastEntry()	删除并返回与此映射中的最大键关联的键 - 值映射，如果映射为空，则 null 。
V	put(K key, V value)	将指定的值与此映射中的指定键相关联。
void	putAll(Map<? extends K,? extends V> map)	将指定映射中的所有映射复制到此映射。
V	remove(Object key)	如果存在，则从此TreeMap中删除此键的映射。
int	size()	返回此映射中键 - 值映射的数量。
NavigableMap<K,V>	subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)	返回此映射部分的视图，其键范围为 fromKey至 toKey 。
SortedMap<K,V>	subMap(K fromKey, K toKey)	返回此映射部分的视图，其键的范围从 fromKey （包括 toKey ）到 toKey （独占）。
SortedMap<K,V>	tailMap(K fromKey)	返回此映射的部分视图，其键大于或等于 fromKey 。
NavigableMap<K,V>	tailMap(K fromKey, boolean inclusive)	返回此映射的部分视图，其键大于（或等于，如果 inclusive为真） fromKey 。
Collection<V>	values()	返回此映射中包含的值的Collection视图。