<蓝桥杯>几个要掌握的API

1.Stack栈

方法摘要
boolean	empty()           测试堆栈是否为空。
E	peek()           查看堆栈顶部的对象，但不从堆栈中移除它。
E	pop()           移除堆栈顶部的对象，并作为此函数的值返回该对象。
E	push(E item)           把项压入堆栈顶部。
int	search(Object o)           返回对象在堆栈中的位置，以 1 为基数。

 

从类 java.util.Vector 继承的方法

add, add,addAll, addAll, addElement, capacity, clear, clone, contains,containsAll, copyInto,elementAt, elements,ensureCapacity, equals,firstElement, get, hashCode, indexOf, indexOf, insertElementAt, isEmpty, lastElement, lastIndexOf, lastIndexOf, remove, remove, removeAll,removeAllElements, removeElement,removeElementAt, removeRange,retainAll, set, setElementAt, setSize, size, subList, toArray,toArray, toString, trimToSize

 

从类 java.util.AbstractList 继承的方法
iterator, listIterator,listIterator

 

从类 java.lang.Object 继承的方法
finalize, getClass,notify, notifyAll, wait, wait, wait

从接口 java.util.List 继承的方法
iterator, listIterator,listIterator

2.Vector向量

public class Vector<E>
   
   
    
    extends 
    
    AbstractList<E>
   
   
   
   
    
    implements 
    
    List<E>, 
    
    RandomAccess, 
    
    Cloneable, 
    
    Serializable
   
   

Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建Vector 后进行添加或移除项的操作。

每个向量会试图通过维护 capacity 和 capacityIncrement 来优化存储管理。capacity 始终至少应与向量的大小相等；这个值通常比后者大些，因为随着将组件添加到向量中，其存储将按capacityIncrement 的大小增加存储块。应用程序可以在插入大量组件前增加向量的容量；这样就减少了增加的重分配的量。

由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失败的：如果在迭代器创建后的任意时间从结构上修改了向量（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。Vector 的 elements 方法返回的 Enumeration不是 快速失败的。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。

Vector()           构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。

Vector(Collection<? extendsE> c)           构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。

Vector(int initialCapacity)           使用指定的初始容量和等于零的容量增量构造一个空向量。

Vector(int initialCapacity, int capacityIncrement)           使用指定的初始容量和容量增量构造一个空的向量。

 

方法摘要
boolean	add(E e)           将指定元素添加到此向量的末尾。
void	add(int index, E element)           在此向量的指定位置插入指定的元素。
boolean	addAll(Collection<? extendsE> c)           将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。
boolean	addAll(int index, Collection<? extends E> c)           在指定位置将指定 Collection 中的所有元素插入到此向量中。
void	addElement(E obj)           将指定的组件添加到此向量的末尾，将其大小增加 1。
int	capacity()           返回此向量的当前容量。
void	clear()           从此向量中移除所有元素。
Object	clone()           返回向量的一个副本。
boolean	contains(Object o)           如果此向量包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)           如果此向量包含指定 Collection 中的所有元素，则返回 true。
void	copyInto(Object[] anArray)           将此向量的组件复制到指定的数组中。
E	elementAt(int index)           返回指定索引处的组件。
Enumeration<E>	elements()           返回此向量的组件的枚举。
void	ensureCapacity(int minCapacity)           增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
boolean	equals(Object o)           比较指定对象与此向量的相等性。
E	firstElement()           返回此向量的第一个组件（位于索引 0) 处的项）。
E	get(int index)           返回向量中指定位置的元素。
int	hashCode()           返回此向量的哈希码值。
int	indexOf(Object o)           返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。
int	indexOf(Object o, int index)           返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。
void	insertElementAt(E obj, int index)           将指定对象作为此向量中的组件插入到指定的 index 处。
boolean	isEmpty()           测试此向量是否不包含组件。
E	lastElement()           返回此向量的最后一个组件。
int	lastIndexOf(Object o)           返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。
int	lastIndexOf(Object o, int index)           返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。
E	remove(int index)           移除此向量中指定位置的元素。
boolean	remove(Object o)           移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。
boolean	removeAll(Collection<?> c)           从此向量中移除包含在指定 Collection 中的所有元素。
void	removeAllElements()           从此向量中移除全部组件，并将其大小设置为零。
boolean	removeElement(Object obj)           从此向量中移除变量的第一个（索引最小的）匹配项。
void	removeElementAt(int index)           删除指定索引处的组件。
protected  void	removeRange(int fromIndex, int toIndex)           从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。
boolean	retainAll(Collection<?> c)           在此向量中仅保留包含在指定 Collection 中的元素。
E	set(int index, E element)           用指定的元素替换此向量中指定位置处的元素。
void	setElementAt(E obj, int index)           将此向量指定 index 处的组件设置为指定的对象。
void	setSize(int newSize)           设置此向量的大小。
int	size()           返回此向量中的组件数。
List<E>	subList(int fromIndex, int toIndex)           返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。
Object[]	toArray()           返回一个数组，包含此向量中以恰当顺序存放的所有元素。
<T> T[]	toArray(T[] a)           返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。
String	toString()           返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。
void	trimToSize()           对此向量的容量进行微调，使其等于向量的当前大小。

 

从类 java.util.AbstractList 继承的方法
iterator, listIterator,listIterator

 

从类 java.lang.Object 继承的方法
finalize, getClass,notify, notifyAll, wait, wait, wait

 

从接口 java.util.List 继承的方法
iterator, listIterator,listIterator

3.Map

接口 Map<K,V>

类型参数：

K - 此映射所维护的键的类型

V - 映射值的类型

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

方法摘要
void	clear()           从此映射中移除所有映射关系（可选操作）。
boolean	containsKey(Object key)           如果此映射包含指定键的映射关系，则返回 true。
boolean	containsValue(Object value)           如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>>	entrySet()           返回此映射中包含的映射关系的 Set 视图。
boolean	equals(Object o)           比较指定的对象与此映射是否相等。
V	get(Object key)           返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int	hashCode()           返回此映射的哈希码值。
boolean	isEmpty()           如果此映射未包含键-值映射关系，则返回 true。
Set<K>	keySet()           返回此映射中包含的键的 Set 视图。
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. List链表

与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。List 接口在 iterator、add、remove、equals 和 hashCode 方法的协定上加了一些其他约定，试图添加不合格的元素会抛出未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询不合格的元素是否存在可能会抛出异常，也可能简单地返回 false；某些实现会采用前一种行为，而某些则采用后者。概括地说，试图对不合格元素执行操作时，如果完成该操作后不会导致在列表中插入不合格的元素，则该操作可能抛出一个异常，也可能成功，这取决于实现的选择。此接口的规范中将这样的异常标记为“可选”。

方法摘要
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)           返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

5. Set 集合

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

对这些构造方法的其他规定是（不要奇怪），所有构造方法必须创建一个不包含重复元素的 set（正如上面所定义的）。

注：如果将可变对象用作 set 元素，那么必须极其小心。如果对象是 set 中某个元素，以一种影响 equals 比较的方式改变对象的值，那么 set 的行为就是不确定的。此项禁止的一个特殊情况是不允许某个 set 包含其自身作为元素。

某些 set 实现对其所包含的元素有所限制。例如，某些实现禁止 null 元素，而某些则对其元素的类型所有限制。试图添加不合格的元素会抛出未经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询不合格的元素是否存在可能会抛出异常，也可能简单地返回 false；某些实现会采用前一种行为，而某些则采用后者。概括地说，试图对不合格元素执行操作时，如果完成该操作后不会导致在 set 中插入不合格的元素，则该操作可能抛出一个异常，也可能成功，这取决于实现的选择。此接口的规范中将这样的异常标记为“可选”。 

方法摘要
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 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

6. Queue<E>队列

在处理元素前用于保存元素的 collection。除了基本的 Collection 操作外，队列还提供其他的插入、提取和检查操作。每个方法都存在两种形式：一种抛出异常（操作失败时），另一种返回一个特殊值（null 或 false，具体取决于操作）。插入操作的后一种形式是用于专门为有容量限制的 Queue 实现设计的；在大多数实现中，插入操作不会失败。

	抛出异常	返回特殊值
插入	add(e)	offer(e)
移除	remove()	poll()
检查	element()	peek()

如果可能，offer 方法可插入一个元素，否则返回 false。这与 Collection.add 方法不同，该方法只能通过抛出未经检查的异常使添加元素失败。offer 方法设计用于正常的失败情况，而不是出现异常的情况，例如在容量固定（有界）的队列中。

remove() 和 poll() 方法可移除和返回队列的头。到底从队列中移除哪个元素是队列排序策略的功能，而该策略在各种实现中是不同的。remove() 和 poll() 方法仅在队列为空时其行为有所不同：remove() 方法抛出一个异常，而 poll() 方法则返回 null。

element() 和 peek() 返回，但不移除，队列的头。

Queue 接口并未定义阻塞队列的方法，而这在并发编程中是很常见的。BlockingQueue 接口定义了那些等待元素出现或等待队列中有可用空间的方法，这些方法扩展了此接口。

Queue 实现通常不允许插入 null 元素，尽管某些实现（如 LinkedList）并不禁止插入 null。即使在允许 null 的实现中，也不应该将 null 插入到 Queue 中，因为 null 也用作 poll 方法的一个特殊返回值，表明队列不包含元素。

Queue 实现通常未定义 equals 和 hashCode 方法的基于元素的版本，而是从 Object 类继承了基于身份的版本，因为对于具有相同元素但有不同排序属性的队列而言，基于元素的相等性并非总是定义良好的。 

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

从接口 java.util.Collection 继承的方法
addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray

7.

类 PriorityQueue<E>优先队列

优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法。优先级队列不允许使用 null 元素。依靠自然顺序的优先级队列还不允许插入不可比较的对象（这样做可能导致 ClassCastException）。

此队列的头 是按指定排序方式确定的最小 元素。如果多个元素都是最小值，则头是其中一个元素——选择方法是任意的。队列获取操作 poll、remove、peek 和 element 访问处于队列头的元素。

优先级队列是无界的，但是有一个内部容量，控制着用于存储队列元素的数组大小。它通常至少等于队列的大小。随着不断向优先级队列添加元素，其容量会自动增加。无需指定容量增加策略的细节。

此类及其迭代器实现了 Collection 和 Iterator 接口的所有可选 方法。方法 iterator() 中提供的迭代器不 保证以任何特定的顺序遍历优先级队列中的元素。如果需要按顺序遍历，请考虑使用 Arrays.sort(pq.toArray())。

注意，此实现不是同步的。如果多个线程中的任意线程修改了队列，则这些线程不应同时访问 PriorityQueue 实例。相反，请使用线程安全的 PriorityBlockingQueue 类。

实现注意事项：此实现为排队和出队方法（offer、poll、remove() 和 add）提供 O(log(n)) 时间；为 remove(Object) 和 contains(Object) 方法提供线性时间；为获取方法（peek、element 和 size）提供固定时间。 

构造方法摘要
PriorityQueue()           使用默认的初始容量（11）创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
PriorityQueue(Collection<? extends E> c)           创建包含指定 collection 中元素的 PriorityQueue。
PriorityQueue(int initialCapacity)           使用指定的初始容量创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
PriorityQueue(int initialCapacity, Comparator<? super E> comparator)           使用指定的初始容量创建一个 PriorityQueue，并根据指定的比较器对元素进行排序。
PriorityQueue(PriorityQueue<? extends E> c)           创建包含指定优先级队列元素的 PriorityQueue。
PriorityQueue(SortedSet<? extends E> c)           创建包含指定有序 set 元素的 PriorityQueue。

 

方法摘要
boolean	add(E e)           将指定的元素插入此优先级队列。
void	clear()           从此优先级队列中移除所有元素。
Comparator<? super E>	comparator()           返回用来对此队列中的元素进行排序的比较器；如果此队列根据其元素的自然顺序进行排序，则返回 null。
boolean	contains(Object o)           如果此队列包含指定的元素，则返回 true。
Iterator<E>	iterator()           返回在此队列中的元素上进行迭代的迭代器。
boolean	offer(E e)           将指定的元素插入此优先级队列。
E	peek()           获取但不移除此队列的头；如果此队列为空，则返回 null。
E	poll()           获取并移除此队列的头，如果此队列为空，则返回 null。
boolean	remove(Object o)           从此队列中移除指定元素的单个实例（如果存在）。
int	size()           返回此 collection 中的元素数。
Object[]	toArray()           返回一个包含此队列所有元素的数组。
<T> T[]	toArray(T[] a)           返回一个包含此队列所有元素的数组；返回数组的运行时类型是指定数组的类型。

 

从类 java.util.AbstractQueue 继承的方法
addAll, element, remove

 

从类 java.util.AbstractCollection 继承的方法
containsAll, isEmpty, removeAll, retainAll, toString

 

从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

 

从接口 java.util.Collection 继承的方法
containsAll, equals, hashCode, isEmpty, removeAll, retainAll