Java集合1：Collection集合接口

 

 

1.集合接口继承图

 

 

2. java.io 接口 Serializable

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

 

3. java.lang 接口 Cloneable

 

此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。

如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，则会导致抛出 CloneNotSupportedException 异常。

按照惯例，实现此接口的类应该使用公共方法重写 Object.clone（它是受保护的）

 

4. java.util 接口 RandomAccess

 

 

List 实现所使用的标记接口，用来表明其支持快速（通常是固定时间）随机访问。此接口的主要目的是允许一般的算法更改其行为，从而在将其应用到随机或连续访问列表时能提供良好的性能。

将操作随机访问列表的最佳算法（如 ArrayList）应用到连续访问列表（如 LinkedList）时，可产生二次项的行为。如果将某个算法应用到连续访问列表，那么在应用可能提供较差性能的算法前，鼓励使用一般的列表算法检查给定列表是否为此接口的一个 instanceof，如果需要保证可接受的性能，还可以更改其行为。

现在已经认识到，随机和连续访问之间的区别通常是模糊的。例如，如果列表很大时，某些 List 实现提供渐进的线性访问时间，但实际上是固定的访问时间。这样的 List 实现通常应该实现此接口。实际经验证明，如果是下列情况，则 List 实现应该实现此接口，即对于典型的类实例而言，此循环：

     for (int i=0, n=list.size(); i < n; i++)
         list.get(i);
 

的运行速度要快于以下循环：

     for (Iterator i=list.iterator(); i.hasNext(); )
         i.next();

 

 

 

5.java.lang 接口 Iterable<T>

 

实现这个接口允许对象成为 "foreach" 语句的目标。

方法摘要
Iterator<T>	iterator()            返回一个在一组 T 类型的元素上进行迭代的迭代器。

 

6.java.util 接口 Iterator<E>

 

对 collection 进行迭代的迭代器。迭代器取代了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同：

• 迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的 collection 移除元素。
• 方法名称得到了改进。

 

方法摘要
boolean	hasNext()            如果仍有元素可以迭代，则返回 true。
E	next()            返回迭代的下一个元素。
void	remove()            从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

 

7.java.util 接口 Collection<E>

 Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

 

方法摘要
boolean	add(E e)            确保此 collection 包含指定的元素（可选操作）。如果此 collection 由于调用而发生更改，则返回 true。（如果此 collection 不允许有重复元素，并且已经包含了指定的元素，则返回 false。）
boolean	addAll(Collection<? extends E> c)            将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void	clear()            移除此 collection 中的所有元素（可选操作）。
boolean	contains(Object o)            如果此 collection 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)            如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	equals(Object o)            比较此 collection 与指定对象是否相等。
int	hashCode()            返回此 collection 的哈希码值。
boolean	isEmpty()            如果此 collection 不包含元素，则返回 true。
Iterator<E>	iterator()            返回在此 collection 的元素上进行迭代的迭代器。
boolean	remove(Object o)            从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean	removeAll(Collection<?> c)            移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean	retainAll(Collection<?> c)            仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int	size()            返回此 collection 中的元素数。
Object[]	toArray()            返回包含此 collection 中所有元素的数组。
<T> T[]	toArray(T[] a)            返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

 

8. java.util 接口 ListIterator<E>

 系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。ListIterator 没有当前元素；它的光标位置 始终位于调用 previous() 所返回的元素和调用 next() 所返回的元素之间。长度为 n 的列表的迭代器有 n+1 个可能的指针位置

 

方法摘要
void	add(E e)            将指定的元素插入列表（可选操作）。
boolean	hasNext()            以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回true）。
boolean	hasPrevious()            如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E	next()            返回列表中的下一个元素。
int	nextIndex()            返回对 next 的后续调用所返回元素的索引。
E	previous()            返回列表中的前一个元素。
int	previousIndex()            返回对 previous 的后续调用所返回元素的索引。
void	remove()            从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
void	set(E e)            用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

 

 

 9.java.util 接口 List<E>

 有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。

 

方法摘要
boolean	add(E e)            向列表的尾部添加指定的元素（可选操作）。
void	add(int index, E element)            在列表的指定位置插入指定元素（可选操作）。
boolean	addAll(Collection<? extends E> c)            添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
boolean	addAll(int index, Collection<? extends E> c)            将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
void	clear()            从列表中移除所有元素（可选操作）。
boolean	contains(Object o)            如果列表包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)            如果列表包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o)            比较指定的对象与列表是否相等。
E	get(int index)            返回列表中指定位置的元素。
int	hashCode()            返回列表的哈希码值。
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)            从列表中移除指定 collection 中包含的其所有元素（可选操作）。
boolean	retainAll(Collection<?> c)            仅在列表中保留指定 collection 中所包含的元素（可选操作）。
E	set(int index, E element)            用指定元素替换列表中指定位置的元素（可选操作）。
int	size()            返回列表中的元素数。
List<E>	subList(int fromIndex, int toIndex)            返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
Object[]	toArray()            返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
<T> T[]	toArray(T[] a)            返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

 

 

 10.java.util 接口 Set<E>

 一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。

 

方法摘要
boolean	add(E e)            如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
boolean	addAll(Collection<? extends E> c)            如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
void	clear()            移除此 set 中的所有元素（可选操作）。
boolean	contains(Object o)            如果 set 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)            如果此 set 包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o)            比较指定对象与此 set 的相等性。
int	hashCode()            返回 set 的哈希码值。
boolean	isEmpty()            如果 set 不包含元素，则返回 true。
Iterator<E>	iterator()            返回在此 set 中的元素上进行迭代的迭代器。
boolean	remove(Object o)            如果 set 中存在指定的元素，则将其移除（可选操作）。
boolean	removeAll(Collection<?> c)            移除 set 中那些包含在指定 collection 中的元素（可选操作）。
boolean	retainAll(Collection<?> c)            仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
int	size()            返回 set 中的元素数（其容量）。
Object[]	toArray()            返回一个包含 set 中所有元素的数组。
<T> T[]	toArray(T[] a)            返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

 

 

11.java.util 接口 SortedSet<E>

进一步提供关于元素的总体排序 的 Set。这些元素使用其自然顺序进行排序，或者根据通常在创建有序 set 时提供的 Comparator 进行排序。该 set 的迭代器将按元素升序遍历 set。提供了一些附加的操作来利用这种排序。

 

方法摘要
Comparator<? super E>	comparator()            返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
E	first()            返回此 set 中当前第一个（最低）元素。
SortedSet<E>	headSet(E toElement)            返回此 set 的部分视图，其元素严格小于 toElement。
E	last()            返回此 set 中当前最后一个（最高）元素。
SortedSet<E>	subSet(E fromElement, E toElement)            返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
SortedSet<E>	tailSet(E fromElement)            返回此 set 的部分视图，其元素大于等于 fromElement。

 

 

12.java.util 接口 NavigableSet<E>

扩展的 SortedSet，具有了为给定搜索目标报告最接近匹配项的导航方法。

方法 lower、floor、ceiling 和 higher 分别返回小于、小于等于、大于等于、大于给定元素的元素，如果不存在这样的元素，则返回 null。可以按升序或降序访问和遍历 NavigableSet。

 

方法摘要
E	ceiling(E e)            返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
Iterator<E>	descendingIterator()            以降序返回在此 set 的元素上进行迭代的迭代器。
NavigableSet<E>	descendingSet()            返回此 set 中所包含元素的逆序视图。
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)            返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
Iterator<E>	iterator()            以升序返回在此 set 的元素上进行迭代的迭代器。
E	lower(E e)            返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
E	pollFirst()            获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
E	pollLast()            获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
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。

 

 

13.java.util 接口 Queue<E>

在处理元素前用于保存元素的 collection。除了基本的 Collection 操作外，队列还提供其他的插入、提取和检查操作。

队列通常（但并非一定）以 FIFO（先进先出）的方式排序各个元素。不过优先级队列和 LIFO 队列（或堆栈）例外，前者根据提供的比较器或元素的自然顺序对元素进行排序，后者按 LIFO（后进先出）的方式对元素进行排序。无论使用哪种排序方式，队列的头 都是调用 remove() 或 poll()所移除的元素。在 FIFO 队列中，所有的新元素都插入队列的末尾。其他种类的队列可能使用不同的元素放置规则。每个 Queue 实现必须指定其顺序属性。

 

方法摘要
boolean	add(E e)            将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，如果当前没有可用的空间，则抛出IllegalStateException。
E	element()            获取，但是不移除此队列的头。NoSuchElementException - 如果此队列为空
boolean	offer(E e)            将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。
E	peek()            获取但不移除此队列的头；如果此队列为空，则返回 null。
E	poll()            获取并移除此队列的头，如果此队列为空，则返回 null。
E	remove()            获取并移除此队列的头。NoSuchElementException - 如果此队列为空

 

 

14.java.util.concurrent 接口 BlockingQueue<E>

支持两个附加操作的 Queue，这两个操作是：获取元素时等待队列变为非空，以及存储元素时等待空间变得可用。

BlockingQueue 方法以四种形式出现，对于不能立即满足但可能在将来某一时刻可以满足的操作，这四种形式的处理方式不同：第一种是抛出一个异常，第二种是返回一个特殊值（null 或 false，具体取决于操作），第三种是在操作可以成功前，无限期地阻塞当前线程，第四种是在放弃前只在给定的最大时间限制内阻塞。下表中总结了这些方法：

 

	抛出异常	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除	remove()	poll()	take()	poll(time, unit)
检查	element()	peek()	不可用	不可用

方法摘要
boolean	add(E e)            将指定元素插入此队列中（如果立即可行且不会违反容量限制），成功时返回 true，如果当前没有可用的空间，则抛出IllegalStateException。
boolean	contains(Object o)            如果此队列包含指定元素，则返回 true。
int	drainTo(Collection<? super E> c)            移除此队列中所有可用的元素，并将它们添加到给定 collection 中。
int	drainTo(Collection<? super E> c, int maxElements)            最多从此队列中移除给定数量的可用元素，并将这些元素添加到给定 collection 中。
boolean	offer(E e)            将指定元素插入此队列中（如果立即可行且不会违反容量限制），成功时返回 true，如果当前没有可用的空间，则返回false。
boolean	offer(E e, long timeout, TimeUnit unit)            将指定元素插入此队列中，在到达指定的等待时间前等待可用的空间（如果有必要）。
E	poll(long timeout, TimeUnit unit)            获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。
void	put(E e)            将指定元素插入此队列中，将等待可用的空间（如果有必要）。
int	remainingCapacity()            返回在无阻塞的理想情况下（不存在内存或资源约束）此队列能接受的附加元素数量；如果没有内部限制，则返回Integer.MAX_VALUE。
boolean	remove(Object o)            从此队列中移除指定元素的单个实例（如果存在）。
E	take()            获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。

 

15.java.util 接口 Deque<E>

一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

此接口定义在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。插入操作的后一种形式是专为使用有容量限制的 Deque 实现设计的；在大多数实现中，插入操作不能失败。

下表总结了上述 12 种方法：

 

	第一个元素（头部）		最后一个元素（尾部）
	抛出异常	特殊值	抛出异常	特殊值
插入	addFirst(e)	offerFirst(e)	addLast(e)	offerLast(e)
移除	removeFirst()	pollFirst()	removeLast()	pollLast()
检查	getFirst()	peekFirst()	getLast()	peekLast()

此接口扩展了 Queue 接口。在将双端队列用作队列时，将得到 FIFO（先进先出）行为。将元素添加到双端队列的末尾，从双端队列的开头移除元素。从 Queue 接口继承的方法完全等效于 Deque 方法，如下表所示：

 

Queue 方法	等效 Deque 方法
add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

双端队列也可用作 LIFO（后进先出）堆栈。应优先使用此接口而不是遗留 Stack 类。在将双端队列用作堆栈时，元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法完全等效于 Deque 方法，如下表所示：

 

堆栈方法	等效 Deque 方法
push(e)	addFirst(e)
pop()	removeFirst()
peek()	peekFirst()

方法摘要
boolean	add(E e)            将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
void	addFirst(E e)            将指定元素插入此双端队列的开头（如果可以直接这样做而不违反容量限制）。
void	addLast(E e)            将指定元素插入此双端队列的末尾（如果可以直接这样做而不违反容量限制）。
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)            将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
E	remove()            获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
boolean	remove(Object o)            从此双端队列中移除第一次出现的指定元素。
E	removeFirst()            获取并移除此双端队列第一个元素。
boolean	removeFirstOccurrence(Object o)            从此双端队列移除第一次出现的指定元素。
E	removeLast()            获取并移除此双端队列的最后一个元素。
boolean	removeLastOccurrence(Object o)            从此双端队列移除最后一次出现的指定元素。
int	size()            返回此双端队列的元素数。

 

16.java.util.concurrent 接口 BlockingDeque<E>

支持两个附加操作的 Queue，这两个操作是：获取元素时等待双端队列变为非空；存储元素时等待双端队列中的空间变得可用。

BlockingDeque 方法有四种形式，使用不同的方式处理无法立即满足但在将来某一时刻可能满足的操作：第一种方式抛出异常；第二种返回一个特殊值（null 或 false，具体取决于操作）；第三种无限期阻塞当前线程，直至操作成功；第四种只阻塞给定的最大时间，然后放弃。下表中总结了这些方法：

 

第一个元素（头部）
	抛出异常	特殊值	阻塞	超时期
插入	addFirst(e)	offerFirst(e)	putFirst(e)	offerFirst(e, time, unit)
移除	removeFirst()	pollFirst()	takeFirst()	pollFirst(time, unit)
检查	getFirst()	peekFirst()	不适用	不适用
最后一个元素（尾部）
	抛出异常	特殊值	阻塞	超时期
插入	addLast(e)	offerLast(e)	putLast(e)	offerLast(e, time, unit)
移除	removeLast()	pollLast()	takeLast()	pollLast(time, unit)
检查	getLast()	peekLast()	不适用	不适用

像所有 BlockingQueue 一样，BlockingDeque 是线程安全的，但不允许 null 元素，并且可能有（也可能没有）容量限制。

BlockingDeque 实现可以直接用作 FIFO BlockingQueue。继承自 BlockingQueue 接口的方法精确地等效于下表中描述的 BlockingDeque 方法：

 

BlockingQueue 方法	等效的 BlockingDeque 方法
插入
add(e)	addLast(e)
offer(e)	offerLast(e)
put(e)	putLast(e)
offer(e, time, unit)	offerLast(e, time, unit)
移除
remove()	removeFirst()
poll()	pollFirst()
take()	takeFirst()
poll(time, unit)	pollFirst(time, unit)
检查
element()	getFirst()
peek()	peekFirst()

方法摘要
boolean	add(E e)            Inserts the 如果立即可行且不违反容量限制，则将指定的元素插入此双端队列表示的队列中（即此双端队列的尾部），并在成功时返回 true；如果当前没有空间可用，则抛出 IllegalStateException。
void	addFirst(E e)            如果立即可行且不违反容量限制，则将指定的元素插入此双端队列的开头；如果当前没有空间可用，则抛出IllegalStateException。
void	addLast(E e)            如果立即可行且不违反容量限制，则将指定的元素插入此双端队列的末尾；如果当前没有空间可用，则抛出IllegalStateException。
boolean	contains(Object o)            如果此双端队列包含指定的元素，则返回 true。
E	element()            获取但不移除此双端队列表示的队列的头部（即此双端队列的第一个元素）。
Iterator<E>	iterator()            返回在此双端队列中的元素上以恰当顺序进行迭代的迭代器。
boolean	offer(E e)            如果立即可行且不违反容量限制，则将指定的元素插入此双端队列表示的队列中（即此双端队列的尾部），并在成功时返回 true；如果当前没有空间可用，则返回 false。
boolean	offer(E e, long timeout, TimeUnit unit)            将指定的元素插入此双端队列表示的队列中（即此双端队列的尾部），必要时将在指定的等待时间内一直等待可用空间。
boolean	offerFirst(E e)            如果立即可行且不违反容量限制，则将指定的元素插入此双端队列的开头，并在成功时返回 true；如果当前没有空间可用，则返回 false。
boolean	offerFirst(E e, long timeout, TimeUnit unit)            将指定的元素插入此双端队列的开头，必要时将在指定的等待时间内等待可用空间。
boolean	offerLast(E e)            如果立即可行且不违反容量限制，则将指定的元素插入此双端队列的末尾，并在成功时返回 true；如果当前没有空间可用，则返回 false。
boolean	offerLast(E e, long timeout, TimeUnit unit)            将指定的元素插入此双端队列的末尾，必要时将在指定的等待时间内等待可用空间。
E	peek()            获取但不移除此双端队列表示的队列的头部（即此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
E	poll()            获取并移除此双端队列表示的队列的头部（即此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
E	poll(long timeout, TimeUnit unit)            获取并移除此双端队列表示的队列的头部（即此双端队列的第一个元素），如有必要将在指定的等待时间内等待可用元素。
E	pollFirst(long timeout, TimeUnit unit)            获取并移除此双端队列的第一个元素，必要时将在指定的等待时间等待可用元素。
E	pollLast(long timeout, TimeUnit unit)            获取并移除此双端队列的最后一个元素，必要时将在指定的等待时间内等待可用元素。
void	push(E e)            将元素推入此双端队列表示的栈。
void	put(E e)            将指定的元素插入此双端队列表示的队列中（即此双端队列的尾部），必要时将一直等待可用空间。
void	putFirst(E e)            将指定的元素插入此双端队列的开头，必要时将一直等待可用空间。
void	putLast(E e)            将指定的元素插入此双端队列的末尾，必要时将一直等待可用空间。
E	remove()            获取并移除此双端队列表示的队列的头部（即此双端队列的第一个元素）。
boolean	remove(Object o)            从此双端队列移除第一次出现的指定元素。
boolean	removeFirstOccurrence(Object o)            从此双端队列移除第一次出现的指定元素。
boolean	removeLastOccurrence(Object o)            从此双端队列移除最后一次出现的指定元素。
int	size()            返回此双端队列中的元素数。
E	take()            获取并移除此双端队列表示的队列的头部（即此双端队列的第一个元素），必要时将一直等待可用元素。
E	takeFirst()            获取并移除此双端队列的第一个元素，必要时将一直等待可用元素。
E	takeLast()            获取并移除此双端队列的最后一个元素，必要时将一直等待可用元素。