Java集合方法总结

集合和数组的区别：

• 数组长度固定，集合长度不固定
• 数组可以存储基本类型和引用类型，集合只能存储引用类型

接口 Collection

	方法名称	详细信息
1	add(E e)	确保此 collection 包含指定的元素（可选操作）。
2	addAll(Collection<? extends E> c)	将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
3	clear()	移除此 collection 中的所有元素（可选操作）。
4	contains(Object o)	如果此 collection 包含指定的元素，则返回 true。
5	containsAll(Collection<?> c)	如果此 collection 包含指定 collection 中的所有元素，则返回 true。
6	equals(Object o)	比较此 collection 与指定对象是否相等。
7	hashCode()	返回此 collection 的哈希码值。
8	isEmpty()	如果此 collection 不包含元素，则返回 true。
9	iterator()	返回在此 collection 的元素上进行迭代的迭代器。
10	remove(Object o)	从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
11	removeAll(Collection<?> c)	移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
12	retainAll(Collection<?> c)	仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
13	size()	返回此 collection 中的元素数。
14	toArray()	返回包含此 collection 中所有元素的数组。
15	toArray(T[] a)	返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

//遍历元素（重点）
//使用增强for（因为无下标）
for(Object object : collection){ }
//使用迭代器
//haNext(); 有没有下一个元素
//next(); 获取下一个元素
//remove(); 删除当前元素
Iterator it = collection.iterator();
while(it.hasNext()){
  String object = (String)it.next(); //强转
  // 可以使用it.remove(); 进行移除元素
  // collection.remove(); 不能用collection其他方法 会报并发修改异常
}

接口 List（有序，可重）

	方法名称	详细信息
1	add(E e)	向列表的尾部添加指定的元素（可选操作）。
2	add(int index, E element)	在列表的指定位置插入指定元素（可选操作）。
3	addAll(Collection<? extends E> c)	添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
4	addAll(int index, Collection<? extends E> c)	将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
5	clear()	从列表中移除所有元素（可选操作）。
6	contains(Object o)	如果列表包含指定的元素，则返回 true。
7	containsAll(Collection<?> c)	如果列表包含指定 collection 的所有元素，则返回 true。
8	equals(Object o)	比较指定的对象与列表是否相等。
9	get(int index)	返回列表中指定位置的元素。
10	hashCode()	返回列表的哈希码值。
11	indexOf(Object o)	返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
12	isEmpty()	如果列表不包含元素，则返回 true。
13	iterator()	返回按适当顺序在列表的元素上进行迭代的迭代器。
14	lastIndexOf(Object o)	返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
15	listIterator()	返回此列表元素的列表迭代器（按适当顺序）。
16	listIterator(int index)	返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
17	remove(int index)	移除列表中指定位置的元素（可选操作）。
18	remove(Object o)	从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
19	removeAll(Collection<?> c)	从列表中移除指定 collection 中包含的其所有元素（可选操作）。
20	retainAll(Collection<?> c)	仅在列表中保留指定 collection 中所包含的元素（可选操作）。
21	set(int index, E element)	用指定元素替换列表中指定位置的元素（可选操作）。
22	size()	返回列表中的元素数。
23	subList(int fromIndex, int toIndex)	返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
24	toArray()	返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
25	toArray(T[] a)	返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

接口 ListIterator

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

//遍历
//使用for遍历
for(int i = 0; i < lise.size(); i++){
  sout(list.get(i)); 
}
//使用增强for
for(Object list: collection){ }
//使用迭代器
Iterator it = collection.iterator();
while(it.hasNext()){
  String object = (String)it.next(); //强转
  // 可以使用it.remove(); 进行移除元素
  // collection.remove(); 不能用collection其他方法 会报并发修改异常
}
//使用列表迭代器 💡（注意和迭代器区别）
ListIterator li = list.listIterator();
while(li.hasNext()){
  System.out.println(li.nextIndex() + ":" + li.next()); //从前往后遍历
}
while(li.hasPrevious()){
  System.out.println(li.previousIndex() + ":" + li.previous()); //从后往前遍历
}

类 ArrayList

• 数组结构实现，查询快，增删慢
• JDK1.2版本，运行效率快，线程不安全

	方法名称	详细信息
1	add(E e)	将指定的元素添加到此列表的尾部。
2	add(int index, E element)	将指定的元素插入此列表中的指定位置。
3	addAll(Collection<? extends E> c)	按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
4	addAll(int index, Collection<? extends E> c)	从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
5	clear()	移除此列表中的所有元素。
6	clone()	返回此 ArrayList 实例的浅表副本。
7	contains(Object o)	如果此列表中包含指定的元素，则返回 true。
8	ensureCapacity(int minCapacity)	如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
9	get(int index)	返回此列表中指定位置上的元素。
10	indexOf(Object o)	返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
11	isEmpty()	如果此列表中没有元素，则返回 true
2	lastIndexOf(Object o)	返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
13	remove(int index)	移除此列表中指定位置上的元素。
14	remove(Object o)	移除此列表中首次出现的指定元素（如果存在）。
15	removeRange(int fromIndex, int toIndex)	移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素
16	set(int index, E element)	用指定的元素替代此列表中指定位置上的元素。
17	size()	返回此列表中的元素数。
18	toArray()	按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
19	toArray(T[] a)	按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
20	trimToSize()	将此 ArrayList 实例的容量调整为列表的当前大小。

DEFAULT_CAPACITY = 10; //默认容量 
//注意：如果没有向集合中添加任何元素时，容量0，添加一个后，容量为10 
//每次扩容是原来的1.5倍 
elementData 存放元素的数组 
size 实际元素个数

//重写equals(this == obj) 方法
public boolean equals(Object obj){
  //1 判断是不是同一个对象
  if(this == obj){
    return true;
  }
  //2 判断是否为空
  if(obj == null){
    return false;
  }
  //3 判断是否是Student类型
  if(obj instanceof Student){
    Student == (Student)obj;
    //4 比较属性
    if(this.name.equals(s.getName()) && this.age == s.getAge()){
      return true;
    }
  }
  //5 不满足条件返回false
  return false;
}

类 LinkedList

• 双向链表结构实现，增删快，查询慢

	方法名称	详细信息
1	add(E e)	将指定元素添加到此列表的结尾。
2	add(int index, E element)	在此列表中指定的位置插入指定的元素。
3	addAll(Collection<? extends E> c)	添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
4	addAll(int index, Collection<? extends E> c)	将指定 collection 中的所有元素从指定位置开始插入此列表。
5	addFirst(E e)	将指定元素插入此列表的开头。
6	addLast(E e)	将指定元素添加到此列表的结尾。
7	clear()	从此列表中移除所有元素。
8	clone()	返回此 LinkedList 的浅表副本。
9	contains(Object o)	如果此列表包含指定元素，则返回 true。
10	descendingIterator()	返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
11	element()	获取但不移除此列表的头（第一个元素）。
12	get(int index)	返回此列表中指定位置处的元素。
13	getFirst()	返回此列表的第一个元素。
14	getLast()	返回此列表的最后一个元素。
15	indexOf(Object o)	返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
16	lastIndexOf(Object o)	返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
17	listIterator(int index)	返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。
18	offer(E e)	将指定元素添加到此列表的末尾（最后一个元素）。
19	offerFirst(E e)	在此列表的开头插入指定的元素。
20	offerLast(E e)	在此列表末尾插入指定的元素。
21	peek()	获取但不移除此列表的头（第一个元素）。
22	peekFirst()	获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
23	peekLast()	获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
24	poll()	获取并移除此列表的头（第一个元素）
25	pollFirst()	获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
26	pollLast()	获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
27	pop()	从此列表所表示的堆栈处弹出一个元素。
28	push(E e)	将元素推入此列表所表示的堆栈。
29	remove()	获取并移除此列表的头（第一个元素）。
30	remove(int index)	移除此列表中指定位置处的元素。
31	remove(Object o)	从此列表中移除首次出现的指定元素（如果存在）。
32	removeFirst()	移除并返回此列表的第一个元素。
33	removeFirstOccurrence(Object o)	从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
34	removeLast()	移除并返回此列表的最后一个元素。
35	removeLastOccurrence(Object o)	从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
36	set(int index, E element)	将此列表中指定位置的元素替换为指定的元素。
37	size()	返回此列表的元素数。
38	toArray()	返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。
39	toArray(T[] a)	返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。

# 类 Vector

• 数组结构实现，查询快，增删慢
• JDK1.0版本，运行效率慢，线程安全

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

//遍历
//枚举器遍历
Enumeration en = vector.elements();
while(en.hasMoreElements()){
  String o = (String)en.nextElement();
  sout(o);
}

接口 Set（无序无重）

	方法名称	详细信息
1	add(E e)	如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
2	addAll(Collection<? extends E> c)	如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
3	clear()	移除此 set 中的所有元素（可选操作）。
4	contains(Object o)	如果 set 包含指定的元素，则返回 true。
5	containsAll(Collection<?> c)	如果此 set 包含指定 collection 的所有元素，则返回 true。
6	equals(Object o)	比较指定对象与此 set 的相等性。
7	hashCode()	返回 set 的哈希码值。
8	isEmpty()	如果 set 不包含元素，则返回 true。
9	iterator()	返回在此 set 中的元素上进行迭代的迭代器。
10	remove(Object o)	如果 set 中存在指定的元素，则将其移除（可选操作）。
11	removeAll(Collection<?> c)	移除 set 中那些包含在指定 collection 中的元素（可选操作）。
12	retainAll(Collection<?> c)	仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
13	size()	返回 set 中的元素数（其容量）。
14	toArray()	返回一个包含 set 中所有元素的数组。
15	toArray(T[] a)	返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

类 HashSet

存储结构：哈希表（数组+链表+红黑树）

存储过程（重复依据）

1. 根据hashCode计算保存的位置，如果位置为空，直接保存，若不为空，进行第二步
2. 再执行equals方法，如果equals为true，则认为是重复，否则形成链表

特点

• 基于HashCode计算元素存放位置
  • 利用31这个质数，减少散列冲突
    • 31提高执行效率 31 * i = (i << 5) - i转为移位操作
  • 当存入元素的哈希码相同时，会调用equals进行确认，如果结果为true，则拒绝后者存入

	方法名称	详细信息
1	add(E e)	如果此 set 中尚未包含指定元素，则添加指定元素。
2	clear()	从此 set 中移除所有元素。
3	clone()	返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。
4	contains(Object o)	如果此 set 包含指定元素，则返回 true。
5	isEmpty()	如果此 set 不包含任何元素，则返回 true。
6	iterator()	返回对此 set 中元素进行迭代的迭代器。
7	remove(Object o)	如果指定元素存在于此 set 中，则将其移除。
8	size()	返回此 set 中的元素的数量（set 的容量）。

类 TreeSet

特点

• 基于排列顺序实现元素不重复
• 实现SortedSet接口，对集合元素自动排序
• 元素对象的类型必须实现Comparable接口，指定排序规则
• 通过CompareTo方法确定是否为重复元素

存储结构：红黑树

	方法名称	详细信息
1	add(E e)	将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
2	addAll(Collection<? extends E> c)	将指定 collection 中的所有元素添加到此 set 中。
3	ceiling(E e)	返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
4	clear()	移除此 set 中的所有元素。
5	clone()	返回 TreeSet 实例的浅表副本。
6	comparator()	返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
7	contains(Object o)	如果此 set 包含指定的元素，则返回 true。
8	descendingIterator()	返回在此 set 元素上按降序进行迭代的迭代器。
9	descendingSet()	返回此 set 中所包含元素的逆序视图。
10	first()	返回此 set 中当前第一个（最低）元素。
11	floor(E e)	返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
12	headSet(E toElement)	返回此 set 的部分视图，其元素严格小于 toElement。
13	headSet(E toElement, boolean inclusive)	返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。
14	higher(E e)	返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
15	isEmpty()	如果此 set 不包含任何元素，则返回 true。
16	iterator()	返回在此 set 中的元素上按升序进行迭代的迭代器。
17	last()	返回此 set 中当前最后一个（最高）元素。
18	lower(E e)	返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
19	pollFirst()	获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
20	pollLast()	获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
21	remove(Object o)	将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
22	size()	返回 set 中的元素数（set 的容量）。
23	subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)	返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
24	subSet(E fromElement, E toElement)	返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
25	tailSet(E fromElement)	返回此 set 的部分视图，其元素大于等于 fromElement。
26	tailSet(E fromElement, boolean inclusive)	返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。

# 接口 Map

Map接口的特点：

1. 用于存储任意键值对（key - value）
2. 键：无序、无下标、不允许重复（唯一）
3. 值：无序、无下标、允许重复

	方法名称	详细信息
1	clear()	从此映射中移除所有映射关系（可选操作）。
2	containsKey(Object key)	如果此映射包含指定键的映射关系，则返回 true。
3	containsValue(Object value)	如果此映射将一个或多个键映射到指定值，则返回 true。
4	entrySet()	返回此映射中包含的映射关系的 Set 视图。
5	equals(Object o)	比较指定的对象与此映射是否相等。
6	get(Object key)	返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
7	hashCode()	返回此映射的哈希码值。
8	isEmpty()	如果此映射未包含键-值映射关系，则返回 true。
9	keySet()	返回此映射中包含的键的 Set 视图。
10	put(K key, V value)	将指定的值与此映射中的指定键关联（可选操作）。
11	putAll(Map<? extends K,? extends V> m)	从指定映射中将所有映射关系复制到此映射中（可选操作）。
12	remove(Object key)	如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
13	size()	返回此映射中的键-值映射关系数。
14	values()	返回此映射中包含的值的 Collection 视图。

//创建Map集合
Map<String, String> map = new HashMap<>();
// 1. 添加元素
map.put("cn", "中国");
map.put("uk", "英国");
map.put("cn", "zhongguo"); // 会替换第一个 
// 2. 删除
map.remove("uk");
// 3. 遍历
// 3.1 使用KeySet()
//Set<String> keyset = map.keySet(); // 所有Key的set集合
for(String key : map.keyset){
  sout(key + "---" + map.get(key));
}
// 3.2 使用entrySet()
//Set<Map.Entry<String, String>> entries = map.entrySet();
for(Map.Entry<String, String> entry : map.entries){
  sout(entry.getKey() + "---" + entry.getValue();
}

类 HashMap

JDK1.2版本，线程不安全，运行效率快，允许用null作为key或者value

原码分析总结：

1. HashMap刚创建时，table是null，节省空间，当添加第一个元素时，table容量调整为16
2. 当元素个数大于阈值（16*0.75 = 12）时，会进行扩容，扩容后的大小为原来的两倍，目的是减少调整元素的个数
3. jdk1.8 当每个链表长度 >8 ，并且数组元素个数 ≥64时，会调整成红黑树，目的是提高效率
4. jdk1.8 当链表长度 <6 时 调整成链表
5. jdk1.8 以前，链表时头插入，之后为尾插入

	方法名称	详细信息
1	clear()	从此映射中移除所有映射关系。
2	clone()	返回此 HashMap 实例的浅表副本：并不复制键和值本身。
3	containsKey(Object key)	如果此映射包含对于指定键的映射关系，则返回 true。
4	containsValue(Object value)	如果此映射将一个或多个键映射到指定值，则返回 true。
5	entrySet()	返回此映射所包含的映射关系的 Set 视图。
6	get(Object key)	返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
7	isEmpty()	如果此映射不包含键-值映射关系，则返回 true。
8	keySet()	返回此映射中所包含的键的 Set 视图。
9	put(K key, V value)	在此映射中关联指定值与指定键。
10	putAll(Map<? extends K,? extends V> m)	将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。
11	remove(Object key)	从此映射中移除指定键的映射关系（如果存在）。
12	size()	返回此映射中的键-值映射关系数。
13	values()	返回此映射所包含的值的 Collection 视图。

类 Hashtable

方法名称	详细信息
clear()	将此哈希表清空，使其不包含任何键。
clone()	创建此哈希表的浅表副本。
contains(Object value)	测试此映射表中是否存在与指定值关联的键。
containsKey(Object key)	测试指定对象是否为此哈希表中的键。
containsValue(Object value)	如果此 Hashtable 将一个或多个键映射到此值，则返回 true。
elements()	返回此哈希表中的值的枚举。
entrySet()	返回此映射中包含的键的 Set 视图。
equals(Object o)	按照 Map 接口的定义，比较指定 Object 与此 Map 是否相等。
get(Object key)	返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null. 更确切地讲，如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射，则此方法返回 v；否则，返回 null。
hashCode()	按照 Map 接口的定义，返回此 Map 的哈希码值。
isEmpty()	测试此哈希表是否没有键映射到值。
keys()	返回此哈希表中的键的枚举。
keySet()	返回此映射中包含的键的 Set 视图。
put(K key, V value)	将指定 key 映射到此哈希表中的指定 value。
putAll(Map<? extends K,? extends V> t)	将指定映射的所有映射关系复制到此哈希表中，这些映射关系将替换此哈希表拥有的、针对当前指定映射中所有键的所有映射关系。
rehash()	增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。
remove(Object key)	从哈希表中移除该键及其相应的值。
size()	返回此哈希表中的键的数量。
toString()	返回此 Hashtable 对象的字符串表示形式，其形式为 ASCII 字符 ", " （逗号加空格）分隔开的、括在括号中的一组条目。
values()	返回此映射中包含的键的 Collection 视图。

# 类 TreeMap

	方法名称	详细信息
1	ceilingEntry(K key)	返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。
2	ceilingKey(K key)	返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
3	clear()	从此映射中移除所有映射关系。
4	clone()	返回此 TreeMap 实例的浅表副本。
5	comparator()	返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
6	containsKey(Object key)	如果此映射包含指定键的映射关系，则返回 true。
7	containsValue(Object value)	如果此映射为指定值映射一个或多个键，则返回 true。
8	descendingKeySet()	返回此映射中所包含键的逆序 NavigableSet 视图。
9	descendingMap()	返回此映射中所包含映射关系的逆序视图。
10	entrySet()	返回此映射中包含的映射关系的 Set 视图。
11	firstEntry()	返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
12	firstKey()	返回此映射中当前第一个（最低）键。
13	floorEntry(K key)	返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。
14	floorKey(K key)	返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。
15	get(Object key)	返回指定键所映射的值，如果对于该键而言，此映射不包含任何映射关系，则返回 null。
16	headMap(K toKey)	返回此映射的部分视图，其键值严格小于 toKey。
17	headMap(K toKey, boolean inclusive)	返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。
18	higherEntry(K key)	返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。
19	higherKey(K key)	返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
20	keySet()	返回此映射包含的键的 Set 视图。
21	lastEntry()	返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
22	lastKey()	返回映射中当前最后一个（最高）键。
23	lowerEntry(K key)	返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。
24	lowerKey(K key)	返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。
25	navigableKeySet()	返回此映射中所包含键的 NavigableSet 视图。
26	pollFirstEntry()	移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
27	pollLastEntry()	移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
28	put(K key, V value)	将指定值与此映射中的指定键进行关联。
29	putAll(Map<? extends K,? extends V> map)	将指定映射中的所有映射关系复制到此映射中。
30	remove(Object key)	如果此 TreeMap 中存在该键的映射关系，则将其删除。
31	size()	返回此映射中的键-值映射关系数。
32	subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)	返回此映射的部分视图，其键的范围从 fromKey 到 toKey。
33	subMap(K fromKey, K toKey)	返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。
34	tailMap(K fromKey)	返回此映射的部分视图，其键大于等于 fromKey。
35	tailMap(K fromKey, boolean inclusive)	返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。
36	values()	返回此映射包含的值的 Collection 视图。

类 Collections

方法名称	详细信息
addAll(Collection<? super T> c, T… elements)	将所有指定元素添加到指定 collection 中。
asLifoQueue(Deque deque)	以后进先出 (Lifo) Queue 的形式返回某个 Deque 的视图。
binarySearch(List<? extends Comparable<? super T>> list, T key)	使用二分搜索法搜索指定列表，以获得指定对象。
binarySearch(List<? extends T> list, T key, Comparator<? super T> c)	使用二分搜索法搜索指定列表，以获得指定对象。
checkedCollection(Collection c, Class type)	返回指定 collection 的一个动态类型安全视图。
checkedList(List list, Class type)	返回指定列表的一个动态类型安全视图。
checkedMap(Map<K,V> m, Class keyType, Class valueType)	返回指定映射的一个动态类型安全视图。
checkedSet(Set s, Class type)	返回指定 set 的一个动态类型安全视图。
checkedSortedMap(SortedMap<K,V> m, Class keyType, Class valueType)	返回指定有序映射的一个动态类型安全视图。
checkedSortedSet(SortedSet s, Class type)	返回指定有序 set 的一个动态类型安全视图
copy(List<? super T> dest, List<? extends T> src)	将所有元素从一个列表复制到另一个列表。
disjoint(Collection< ?> c1, Collection<?> c2)	如果两个指定 collection 中没有相同的元素，则返回 true。
emptyList()	返回空的列表（不可变的）。
emptyMap()	返回空的映射（不可变的）。
emptySet()	返回空的 set（不可变的）。
enumeration(Collection< T> c)	返回一个指定 collection 上的枚举。
fill(List<? super T> list, T obj)	使用指定元素替换指定列表中的所有元素。
frequency(Collection<?> c, Object o)	返回指定 collection 中等于指定对象的元素数。
indexOfSubList(List< ?> source, List<?> target)	返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
lastIndexOfSubList(List< ?> source, List<?> target)	返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
list(Enumeration< T> e)	返回一个数组列表，它按返回顺序包含指定枚举返回的元素。
max(Collection<? extends T> coll)	根据元素的自然顺序，返回给定 collection 的最大元素。
max(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器产生的顺序，返回给定 collection 的最大元素。
min(Collection<? extends T> coll)	根据元素的自然顺序 返回给定 collection 的最小元素。
min(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器产生的顺序，返回给定 collection 的最小元素。
nCopies(int n, T o)	返回由指定对象的 n 个副本组成的不可变列表。
newSetFromMap(Map<E,Boolean> map)	返回指定映射支持的 set。
replaceAll(List list, T oldVal, T newVal)	使用另一个值替换列表中出现的所有某一指定值。
reverse(List<?> list)	反转指定列表中元素的顺序。
reverseOrder()	返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
reverseOrder(Comparator cmp)	返回一个比较器，它强行逆转指定比较器的顺序。
rotate(List<?> list, int distance)	根据指定的距离轮换指定列表中的元素。
shuffle(List<?> list)	使用默认随机源对指定列表进行置换。
shuffle(List<?> list, Random rnd)	使用指定的随机源对指定列表进行置换。
singleton(T o)	返回一个只包含指定对象的不可变 set。
singletonList(T o)	返回一个只包含指定对象的不可变列表。
singletonMap(K key, V value)	返回一个不可变的映射，它只将指定键映射到指定值。
sort(List list)	根据元素的自然顺序 对指定列表按升序进行排序。
sort(List list, Comparator<? super T> c)	根据指定比较器产生的顺序对指定列表进行排序。
swap(List<?> list, int i, int j)	在指定列表的指定位置处交换元素。
synchronizedCollection(Collection c)	返回指定 collection 支持的同步（线程安全的）collection。
synchronizedList(List list)	返回指定列表支持的同步（线程安全的）列表。
synchronizedMap(Map<K,V> m)	返回由指定映射支持的同步（线程安全的）映射。
synchronizedSet(Set s)	返回指定 set 支持的同步（线程安全的）set。
synchronizedSortedMap(SortedMap<K,V> m)	返回指定有序映射支持的同步（线程安全的）有序映射。
synchronizedSortedSet(SortedSet s)	返回指定有序 set 支持的同步（线程安全的）有序 set。
unmodifiableCollection(Collection<? extends T> c)	返回指定 collection 的不可修改视图。
unmodifiableList(List<? extends T> list)	返回指定列表的不可修改视图。
unmodifiableMap(Map<? extends K,? extends V> m)	返回指定映射的不可修改视图。
unmodifiableSet(Set<? extends T> s)	返回指定 set 的不可修改视图。
unmodifiableSortedMap(SortedMap<K,? extends V> m)	返回指定有序映射的不可修改视图。
unmodifiableSortedSet(SortedSet s)	返回指定有序 set 的不可修改视图。