在Java语言中，Java语言的设计者对常用的数据结构和算法做了一些规范（接口）和实现（具体实现接口的类）。所有抽象出来的数据结构和操作（算法）统称为Java集合框架（Java Collection Framework）。
Java程序员在具体应用时，不必考虑数据结构和算法实现细节，只需要用这些类创建出来一些对象，然后直接应用就可以了。这样就大大提高了编程效率。
Java类集框架的优势：
1) 这种框架是高性能的。对基本类集（动态数组，链接表，树和散列表）的实现是高效率的。一般很少需要人工去对这些“数据引擎”编写代码（如果有的话）。
2) 框架允许不同类型的类集以相同的方式和高度互操作方式工作。
3) 类集是容易扩展和/或修改的。为了实现这一目标，类集框架被设计成包含一组标准的接口。对这些接口，提供了几个标准的实现工具（例如LinkedList，HashSet和 TreeSet），通常就是这样使用的。如果你愿意的话，也可以实现你自己的类集。为了方便起见，创建用于各种特殊目的的实现工具。一部分工具可以使你自己的类集 实现更加容易。
4) 增加了允许将标准数组融合到类集框架中的机制。
java集合框架整体结构如下图所示：
- 集合框架概述：
java中集合类集定义在java.util包下，Collection接口是构造类集框架的基础，它声明所有类集将拥有的核心方法。
最常用的接口有：
- List——有序集合
- Set——无序集合
- Map——映射关系的集合数据结构
另外还有Queue接口，它提供了基于队列的集合体系。每种集合都可以理解为用来在内存中存放一组对象的某种”容器“。
- 集合框架详解
Collection接口：
Collection是java集合框架最基本的接口。所有实现Collection接口的类都必须提供两个标准的构造函数，无参的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一 个新的Collection，与传入的Collection有相同的元素。
遍历集合使用迭代器。例如：
Interator it=collection.interator();//得到集合的迭代器 while(it,hasNext()){ Object obj=ir.next();//得到下一个对象 }
Collection派生的常用子接口有List，Set，Queue。
Collections是集合类，提供了很多静态方法来管理集合。
Collection常用方法如下所示：
1 public interface Collection<E> extends Iterable<E> { 2 int size();//返回本类集中元素的个数. 3 boolean isEmpty();//若本类集没有元素则返回true，否则返回false。 4 /* 5 如果本类集包含元素e，并且满足(o==null ?e==null : o.equals(e)) 则返回true，否则返回false。 6 */ 7 boolean contains(Object o); 8 /* 9 返回本类集中所有元素的迭代函数，至于从该函数中取出的元素的顺序依赖于本类集的类型，若为List则按List的顺序取出，若为Set则无序。 10 */ 11 Iterator<E> iterator(); 12 /* 13 返回一个包含了本类集中所有元素的数组，数组类型为：Object[]，因为底层是通过iterator()方法来传值的，所以数组中元素的顺序同样依赖于本类集的类型，若为List则按List的顺序放入数组，若为Set则无序 14 */ 15 Object[] toArray(); 16 /* 17 以泛型的形式来传递返回数组的类型，其他与Object[]toArray()方法类似。 18 */ 19 <T> T[] toArray(T[] a); 20 /* 21 向集合中增加元素，如果该类型集合允许有重复元素（如：ArrayList、LinkedList等）或者不允许有重复元素但新添加的元素不在集合中则返回true，如果该类型集合不允许有重复元素并且新添加的元素已经在集合中则返回false。 22 */ 23 boolean add(E e); 24 /* 25 若本类集中有值与o的值相等的元素，则删除该元素，并返回true，若没有则返回false。当类集类型为List时，有可能有多个元素与o的值相等，此时，只会删除第一个值为o的元素，其他元素位置不变。 26 */ 27 boolean remove(Object o); 28 /* 29 如果本类集包含指定类集c中的所有元素则返回true，否则返回false。 30 */ 31 boolean containsAll(Collection<?> c); 32 /* 33 将一个类集c中的所有元素添加到另一个类集（本类集）。 34 */ 35 boolean addAll(Collection<? extends E> c); 36 /* 37 删除本类集中与指定类集c中的元素相等的所有元素，不管有多少个元素，只要在c中出现了，调用后d中就不会出现。若调用后本类集的元素有改变（即有元素被删除），则返回true，否则返回false。 38 */ 39 boolean removeAll(Collection<?> c); 40 /* 41 保持本类集中在指定类集中出现过的所有元素，即删除本类集中不包含在指定类集c中的所有元素。若调用后本类集的元素有改变（即有元素被删除），则返回true，否则返回false。 42 */ 43 boolean retainAll(Collection<?> c); 44 /* 45 清除本类集中所有元素，调用完该方法后本类集将为空。 46 */ 47 void clear(); 48 /* 49 如果本类集的equals方法是我们自己重写的，则具体两个类集怎样才算equal（是引用相等还是值相等且顺序相同），我们自己决定。如果类集的equals方法不是我们重写的，则当两个类集类型为List（包括ArrayList和LinkedList，元素可以重复）时，必须两个类集的元素个数相等，元素顺序相同，且相同位置的元素对应相等才返回true，否则返回false；当两个类集类型为Set（包括HashSet和TreeSet，元素不能重复）时，只须两个类集的元素个数相等，并且一个类集中的任一个元素在另一个类集中都能找到相同的元素（不必顺序相同，因为Set是无序的），则返回true，否则返回false。 50 */ 51 boolean equals(Object o); 52 /* 53 返回本类集的hash code值，具体算法依赖于类集中元素的值和类型。 54 */ 55 int hashCode(); 56 }
List接口：
List是有序集合，可以对列表中的每个元素的插入位置进行精确的控制，用户可以根据索引进行访问。List允许重复元素，即满足e1.equals(e2);
List除了Collection必备的iterator方法外，还有一个ListIterator方法。与标准的Iterator接口相比，ListIterator多了一些方法，允许添加，删除，修改元素，以及前后遍历。
实现List接口的常用类有：LinkedList,ArrayList,Vector,Stack。
List接口常用方法如下所示：
1 public interface List<E> extends Collection<E> { 2 3 int size(); 4 5 boolean isEmpty(); 6 7 boolean contains(Object o); 8 9 Iterator<E> iterator(); 10 11 Object[] toArray(); 12 13 <T> T[] toArray(T[] a); 14 15 boolean add(E e); 16 17 boolean remove(Object o); 18 19 boolean containsAll(Collection<?> c); 20 21 boolean addAll(Collection<? extends E> c); 22 23 boolean addAll(int index, Collection<? extends E> c); 24 25 boolean removeAll(Collection<?> c); 26 27 boolean retainAll(Collection<?> c); 28 29 void clear(); 30 31 boolean equals(Object o); 32 33 int hashCode(); 34 //以上方法继承自Collection 35 //下面为List接口新增加的方法 36 E get(int index); 37 38 E set(int index, E element); 39 40 void add(int index, E element); 41 42 E remove(int index); 43 44 int indexOf(Object o); 45 46 int lastIndexOf(Object o); 47 48 ListIterator<E> listIterator(); 49 50 ListIterator<E> listIterator(int index); 51 52 List<E> subList(int fromIndex, int toIndex); 53 }
ArrayList类：
ArrayList实现了可变大小的数组，允许所有元素（包括null），允许元素重复，ArrayList没有实现线程同步。
ArrayList使用一个内置的数组来存储元素，每个ArrayList实例都有一个初始容量（Capacity）10，容量可以随着添加新元素而不断增长，公式如下：Capacity=（Capacity*3）/2+1，每次增长容量50%。在插入大量元素前，可以调用ensureCapacity方法来增加ArrayList容量，以提高插入效率。
对数组进行重新分配大小时，会导致性能下降，（当有大量元素时）会浪费大量存储空间。如果我们知道有多少元素，可以通过构造函数指定容量。我们也可以使用trimToSize方法在ArrayList重新分配容量后去掉浪费的存储空间。
LinkedList类：
LinkedList是List接口的链表实现，允许所有元素（包括null），允许元素重复，ArrayList没有实现线程同步。
LinkedList在列表的开头和结尾提供了额外的get，remove和insert方法，这些操作将允许列表用作堆栈（Stack），队列（Queue）或双端队列（Deque）。
LinkedList实现了Queue接口，提供了add，pull等方法供队列操作。
LinkedList没有实现同步，但可以在创建时实现一个同步列表，例如：
List list=Collections.synchronizedList(new LinkedList());
LinkedList方法如下所示：
1 import java.util.AbstractSequentialList; 2 import java.util.Deque; 3 import java.util.List; 4 5 public class LinkedList<E> 6 extends AbstractSequentialList<E> 7 implements List<E>, Deque<E>, Cloneable, java.io.Serializable 8 { 9 boolean add(E e) ; 10 // 将指定元素添加到此列表的结尾。 11 void add(int index, E element) ; 12 // 在此列表中指定的位置插入指定的元素。 13 boolean addAll(Collection<? extends E> c) ; 14 // 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。 15 boolean addAll(int index, Collection<? extends E> c) ; 16 // 将指定 collection 中的所有元素从指定位置开始插入此列表。 17 void addFirst(E e) ; 18 // 将指定元素插入此列表的开头。 19 void addLast(E e) ; 20 // 将指定元素添加到此列表的结尾。 21 void clear() ; 22 // 从此列表中移除所有元素。 23 Object clone() ; 24 // 返回此 LinkedList 的浅表副本。 25 boolean contains(Object o) ; 26 // 如果此列表包含指定元素，则返回 true。 27 Iterator<E> descendingIterator() ; 28 // 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。 29 E element() ; 30 // 获取但不移除此列表的头（第一个元素）。 31 E get(int index) ; 32 // 返回此列表中指定位置处的元素。 33 E getFirst() ; 34 // 返回此列表的第一个元素。 35 E getLast() ; 36 // 返回此列表的最后一个元素。 37 int indexOf(Object o) ; 38 // 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 39 int lastIndexOf(Object o) ; 40 // 返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 41 ListIterator<E> listIterator(int index) ; 42 // 返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。 43 boolean offer(E e) ; 44 // 将指定元素添加到此列表的末尾（最后一个元素）。 45 boolean offerFirst(E e) ; 46 // 在此列表的开头插入指定的元素。 47 boolean offerLast(E e) ; 48 // 在此列表末尾插入指定的元素。 49 E peek() ; 50 // 获取但不移除此列表的头（第一个元素）。 51 E peekFirst() ; 52 // 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 53 E peekLast() ; 54 // 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。 55 E poll() ; 56 // 获取并移除此列表的头（第一个元素） 57 E pollFirst() ; 58 // 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 59 E pollLast() ; 60 // 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 61 E pop() ; 62 // 从此列表所表示的堆栈处弹出一个元素。 63 void push(E e) ; 64 // 将元素推入此列表所表示的堆栈。 65 E remove() ; 66 // 获取并移除此列表的头（第一个元素）。 67 E remove(int index) ; 68 // 移除此列表中指定位置处的元素。 69 boolean remove(Object o) ; 70 // 从此列表中移除首次出现的指定元素（如果存在）。 71 E removeFirst() ; 72 // 移除并返回此列表的第一个元素。 73 boolean removeFirstOccurrence(Object o) ; 74 // 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。 75 E removeLast() ; 76 // 移除并返回此列表的最后一个元素。 77 boolean removeLastOccurrence(Object o) ; 78 // 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。 79 E set(int index, E element) ; 80 // 将此列表中指定位置的元素替换为指定的元素。 81 int size() ; 82 // 返回此列表的元素数。 83 Object[] toArray() ; 84 // 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。 85 <T> T[] toArray(T[] a) ; 86 // 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。 87 }
Vector类：
Vector类十余ArrayL，但Vector是线程同步的。当一个Iterator被创建而且正在使用时，另外一个线程改变了vector的状态。这时调用Iterator的方法，将抛出ConcurrentModificationException异常，因此必须捕获异常。
Vector方法：
1 import java.util.AbstractList; 2 import java.util.List; 3 import java.util.RandomAccess; 4 5 public class Vector<E> 6 extends AbstractList<E> 7 implements List<E>, RandomAccess, Cloneable, java.io.Serializable 8 { 9 boolean add(E e) ; 10 //将指定元素添加到此向量的末尾。 11 void add(int index, E element) ; 12 // 在此向量的指定位置插入指定的元素。 13 boolean addAll(Collection<? extends E> c) ; 14 // 将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。 15 boolean addAll(int index, Collection<? extends E> c) ; 16 // 在指定位置将指定 Collection 中的所有元素插入到此向量中。 17 void addElement(E obj) ; 18 // 将指定的组件添加到此向量的末尾，将其大小增加 1。 19 int capacity() ; 20 //返回此向量的当前容量。 21 void clear() ; 22 // 从此向量中移除所有元素。 23 Object clone() ; 24 // 返回向量的一个副本。 25 boolean contains(Object o) ; 26 // 如果此向量包含指定的元素，则返回 true。 27 boolean containsAll(Collection<?> c); 28 // 如果此向量包含指定 Collection 中的所有元素，则返回 true。 29 void copyInto(Object[] anArray) ; 30 // 将此向量的组件复制到指定的数组中。 31 E elementAt(int index) ; 32 // 返回指定索引处的组件。 33 Enumeration<E> elements() ; 34 //返回此向量的组件的枚举。 35 void ensureCapacity(int minCapacity) ; 36 // 增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。 37 boolean equals(Object o) ; 38 // 比较指定对象与此向量的相等性。 39 E firstElement() ; 40 //返回此向量的第一个组件（位于索引 0) 处的项）。 41 E get(int index) ; 42 // 返回向量中指定位置的元素。 43 int hashCode() ; 44 // 返回此向量的哈希码值。 45 int indexOf(Object o) ; 46 // 返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。 47 int indexOf(Object o, int index) ; 48 // 返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。 49 void insertElementAt(E obj, int index) ; 50 // 将指定对象作为此向量中的组件插入到指定的 index 处。 51 boolean isEmpty() ; 52 // 测试此向量是否不包含组件。 53 E lastElement() ; 54 // 返回此向量的最后一个组件。 55 int lastIndexOf(Object o) ; 56 // 返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。 57 int lastIndexOf(Object o, int index) ; 58 // 返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。 59 E remove(int index) ; 60 // 移除此向量中指定位置的元素。 61 boolean remove(Object o) ; 62 // 移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。 63 boolean removeAll(Collection<?> c) 64 // 从此向量中移除包含在指定 Collection 中的所有元素。 65 void removeAllElements() ; 66 // 从此向量中移除全部组件，并将其大小设置为零。 67 boolean removeElement(Object obj) ; 68 // 从此向量中移除变量的第一个（索引最小的）匹配项。 69 void removeElementAt(int index) ; 70 // 删除指定索引处的组件。 71 protected void removeRange(int fromIndex, int toIndex) ; 72 // 从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。 73 boolean retainAll(Collection<?> c) ; 74 // 在此向量中仅保留包含在指定 Collection 中的元素。 75 E set(int index, E element) ; 76 // 用指定的元素替换此向量中指定位置处的元素。 77 void setElementAt(E obj, int index) ; 78 // 将此向量指定 index 处的组件设置为指定的对象。 79 void setSize(int newSize) ; 80 // 设置此向量的大小。 81 int size() ; 82 // 返回此向量中的组件数。 83 List<E> subList(int fromIndex, int toIndex) ; 84 // 返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。 85 Object[] toArray() ; 86 // 返回一个数组，包含此向量中以恰当顺序存放的所有元素。 87 <T> T[] 88 toArray(T[] a) ; 89 // 返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。 90 String toString() ; 91 // 返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。 92 void trimToSize() ; 93 // 对此向量的容量进行微调，使其等于向量的当前大小。 94 }
Stack类：
Stack类继承自Vector，他实现了一个先进后出的栈。Stack提供了五个额外的方法使得Vector被当做堆栈使用，push,pop,peek,search,empty。
Stack方法：
1 public class Stack<E> extends Vector<E> { 2 boolean empty() ; 3 // 测试堆栈是否为空。 4 E peek() ; 5 // 查看堆栈顶部的对象，但不从堆栈中移除它。 6 E pop() ; 7 // 移除堆栈顶部的对象，并作为此函数的值返回该对象。 8 E push(E item) ; 9 // 把项压入堆栈顶部。 10 int search(Object o) ; 11 // 返回对象在堆栈中的位置，以 1 为基数。 12 }
Set接口：
Set是无序集合，不包括重复元素，及e1.equals(e2)==false，最多含有一个null。
常用的子类有HashSet，TreeSet。
Set接口方法列表如下所示：
1 public interface Set<E> extends Collection<E> { 2 boolean add(E e) ; 3 // 如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。 4 boolean addAll(Collection<? extends E> c) ; 5 //如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。 6 void clear() ; 7 // 移除此 set 中的所有元素（可选操作）。 8 boolean contains(Object o) ; 9 // 如果 set 包含指定的元素，则返回 true。 10 boolean containsAll(Collection<?> c) ; 11 // 如果此 set 包含指定 collection 的所有元素，则返回 true。 12 boolean equals(Object o) ; 13 // 比较指定对象与此 set 的相等性。 14 int hashCode() ; 15 // 返回 set 的哈希码值。 16 boolean isEmpty() ; 17 // 如果 set 不包含元素，则返回 true。 18 Iterator<E> iterator() ; 19 // 返回在此 set 中的元素上进行迭代的迭代器。 20 boolean remove(Object o) ; 21 // 如果 set 中存在指定的元素，则将其移除（可选操作）。 22 boolean removeAll(Collection<?> c) ; 23 // 移除 set 中那些包含在指定 collection 中的元素（可选操作）。 24 boolean retainAll(Collection<?> c) ; 25 // 仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。 26 int size() ; 27 // 返回 set 中的元素数（其容量）。 28 Object[] toArray() ; 29 // 返回一个包含 set 中所有元素的数组。 30 <T> T[] toArray(T[] a) ; 31 // 返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。 32 33 }
HashSet类：
HashSet实现Set接口，由哈希表支持（实际上是一个HashMap实例），不保证集合的迭代顺序，它是基于HashMap实现，底层使用HashMap保存所有元素，基本上都是直接调用底层HashMap的相关方法实现。
HashSet方法：
1 public class HashSet<E> 2 extends AbstractSet<E> 3 implements Set<E>, Cloneable, java.io.Serializable 4 boolean add(E e) ; 5 //如果此 set 中尚未包含指定元素，则添加指定元素。 6 void clear() ; 7 //从此 set 中移除所有元素。 8 Object clone() ; 9 //返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。 10 boolean contains(Object o) ; 11 // 如果此 set 包含指定元素，则返回 true。 12 boolean isEmpty() ; 13 // 如果此 set 不包含任何元素，则返回 true。 14 Iterator<E> iterator() ; 15 // 返回对此 set 中元素进行迭代的迭代器。 16 boolean remove(Object o) ; 17 // 如果指定元素存在于此 set 中，则将其移除。 18 int size() ; 19 // 返回此 set 中的元素的数量（set 的容量）。 20 }
Map接口：
Map接口没有继承Collection接口，Map提供Key到value的关系映射。Map中不能含有重复的Key，每个key只能映射一个value。Map是Dictionary（字典）的替代品，Map提供了三种集合视图：键集，值集和键值映射关系集的形式来查看映射的内容。
常用的子类有：HashMap。TreeMap，子接口有SortedMap。
方法列表：
1 public interface Map<K,V> { 2 void clear() ; 3 // 从此映射中移除所有映射关系（可选操作）。 4 boolean containsKey(Object key); 5 //如果此映射包含指定键的映射关系，则返回 true。 6 boolean containsValue(Object value) ; 7 // 如果此映射将一个或多个键映射到指定值，则返回 true。 8 Set<Map.Entry<K,V>> entrySet(); 9 // 返回此映射中包含的映射关系的 Set 视图。 10 boolean equals(Object o) ; 11 // 比较指定的对象与此映射是否相等。 12 V get(Object key) ; 13 //返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 14 int hashCode() ; 15 // 返回此映射的哈希码值。 16 boolean isEmpty(); 17 // 如果此映射未包含键-值映射关系，则返回 true。 18 Set<K> keySet() ; 19 //返回此映射中包含的键的 Set 视图。 20 V put(K key, V value) ; 21 // 将指定的值与此映射中的指定键关联（可选操作）。 22 void putAll(Map<? extends K,? extends V> m) ; 23 // 从指定映射中将所有映射关系复制到此映射中（可选操作）。 24 V remove(Object key) ; 25 // 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 26 int size() ; 27 // 返回此映射中的键-值映射关系数。 28 Collection<V> values() ; // 返回此映射中包含的值的 Collection 视图。 29 }
HashMap类：
基于哈希表的Map接口实现，非线程同步，提供所有可选的映射操作，允许null键值，不保证映射顺序。
TreeMap：
基于红黑树的SortedMap接口实现，保证映射按照升序排列关键字，根据使用的构造方法不同，可能会按不同的方法排序。
1 import java.util.AbstractMap; 2 import java.util.NavigableMap; 3 4 public class TreeMap<K,V> 5 extends AbstractMap<K,V> 6 implements NavigableMap<K,V>, Cloneable, java.io.Serializable 7 { 8 Map.Entry<K,V> ceilingEntry(K key) ; 9 // 返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。 10 K ceilingKey(K key) ; 11 // 返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。 12 void clear() ; 13 // 从此映射中移除所有映射关系。 14 Object clone() ; 15 // 返回此 TreeMap 实例的浅表副本。 16 Comparator<? super K> comparator() ; 17 // 返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。 18 boolean containsKey(Object key) ; 19 // 如果此映射包含指定键的映射关系，则返回 true。 20 boolean containsValue(Object value) ; 21 // 如果此映射为指定值映射一个或多个键，则返回 true。 22 NavigableSet<K> descendingKeySet() ; 23 // 返回此映射中所包含键的逆序 NavigableSet 视图。 24 NavigableMap<K,V> descendingMap() ; 25 // 返回此映射中所包含映射关系的逆序视图。 26 Set<Map.Entry<K,V>> entrySet() ; 27 // 返回此映射中包含的映射关系的 Set 视图。 28 Map.Entry<K,V> firstEntry() ; 29 // 返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。 30 K firstKey() ; 31 // 返回此映射中当前第一个（最低）键。 32 Map.Entry<K,V> floorEntry(K key) ; 33 // 返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。 34 K floorKey(K key) ; 35 // 返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。 36 V get(Object key) ; 37 // 返回指定键所映射的值，如果对于该键而言，此映射不包含任何映射关系，则返回 null。 38 SortedMap<K,V> headMap(K toKey) ; 39 // 返回此映射的部分视图，其键值严格小于 toKey。 40 NavigableMap<K,V> headMap(K toKey, boolean inclusive) ; 41 // 返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。 42 Map.Entry<K,V> higherEntry(K key) ; 43 // 返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。 44 K higherKey(K key) ; 45 // 返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。 46 Set<K> keySet() ; 47 // 返回此映射包含的键的 Set 视图。 48 Map.Entry<K,V> lastEntry() ; 49 // 返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。 50 K lastKey() ; 51 // 返回映射中当前最后一个（最高）键。 52 Map.Entry<K,V> lowerEntry(K key); 53 // 返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null。 54 K lowerKey(K key) ; 55 // 返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。 56 NavigableSet<K> navigableKeySet() ; 57 // 返回此映射中所包含键的 NavigableSet 视图。 58 Map.Entry<K,V> pollFirstEntry() ; 59 // 移除并返回与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。 60 Map.Entry<K,V> pollLastEntry() ; 61 // 移除并返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。 62 V put(K key, V value) ; 63 // 将指定值与此映射中的指定键进行关联。 64 void putAll(Map<? extends K,? extends V> map) ; 65 //将指定映射中的所有映射关系复制到此映射中;。 66 V remove(Object key) ; 67 // 如果此 TreeMap 中存在该键的映射关系，则将其删除。 68 int size() ; 69 // 返回此映射中的键-值映射关系数。 70 NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) ; 71 // 返回此映射的部分视图，其键的范围从 fromKey 到 toKey。 72 SortedMap<K,V> subMap(K fromKey, K toKey) ; 73 // 返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。 74 SortedMap<K,V> tailMap(K fromKey) ; 75 // 返回此映射的部分视图，其键大于等于 fromKey。 76 NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) ; 77 // 返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。 78 Collection<V> values() ; 79 // 返回此映射包含的值的 Collection 视图。 80 }
HashTable：
不允许null键值，线程同步，其他类似于HashMap。
总结：
如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，
应该使用ArrayList。
如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该
使用同步的类。
要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。
这就是针对抽象编程
