java集合框架

 

 

Java为数据结构的映射定义了一个接口java.util.Map.它有四个实现类，分别是HashMap, Hashtable,LinkedHashMap和TreeMap主要用于存储键值对，根据键得到值，因此不允许键重复，但允许值重复。

HashMap是一个最常用的Map，它根据键的HashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度，遍历时，取得数据的顺序完全是随机的。HashMap最多只允许一条记录的键为Null,允许多条记录的值为Null,当get()方法返回null值时，既可以表示HashMap中没有该键，也可以表示该键所对应的值为null,因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用Collections的synchronizdeMap方法使HashMap具有同步能力，或者使用ConcurrentHashMap.另外HashMap是基于哈希表实现的，HashMap的键得重写hashCode()和equals()方法。

 

TreeMap

是实现SortedMap接口，能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator遍历TreeMap时，得到的记录是排过序的。所以TreeMap的键得实现Comparabl,没有实现的话就要给TreeMap指定一个Comparator

Hashtable中的方法是同步的，也即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；而Hashtable不允许键值为空。

内部哈希：哈希映射技术

几乎所有通用Map都使用哈希映射，这是一种将元素映射到数组的非常简单的机制，您应了解哈希映射的工作原理，以便充分利用Map.

哈希映射结构由一个存储元素的内部数组组成，由于内部采用数组存储，因此必然存在一个用于确定任意键访问数组的索引机制，实际上该机制需要提供一个小于数组大小的整数索引值，该机制称作哈希函数。在Java基于哈希的Map中，哈希函数将对象转换为一个适合内部数组的整数，您别不必为寻找一个易于使用的哈希函数而大伤脑筋：每个对象都包含一个返回整数值的hashCode()方法，要将该值映射到数组，只需将其转换为一个正值，然后将该值除以数组大小后取余数即可，以下是一个简单的，适用于任何对象的Java哈希函数

int hashvalue = Maths.abs(key.hashCode()) % table.length;

(%二进制运算符(称作模)将左侧的值处以右侧的值，然后返回整数形式的余数。)

实际上，在1.4版发布之前，这就是各种基于哈希的Map类所使用的哈希函数，但如果您查看以下代码，您将看到

int hashvalue = (key.hashCode() & 0x7FFFFFFF) % table.length;

它实际上是使用更快的机制过去正值的同一函数。在1.4版中，HashMap类实现一个不同且更复杂的哈希函数。但如果两个不同的键映射到相同的位置，情况将会如何？这是一种必然发生的情况。在哈希映射的术语中，这称作冲突，Map处理这些冲突的方法是在索引位置处插入一个链接列表，并简单地将元素添加到此链接列表。因此，一个基于哈希的Map的基本put()方法可能如下所示：

public Object put(Object key, Object value) {

  //我们的内部数组是一个 Entry 对象数组

  //Entry[] table;

  //获取哈希码，并映射到一个索引

  int hash = key.hashCode();

  int index = (hash & 0x7FFFFFFF) % table.length;

  //循环遍历位于 table[index] 处的链接列表，以查明

  //我们是否拥有此键项 — 如果拥有，则覆盖它

  for (Entry e = table[index] ; e != null ; e = e.next) {

    //必须检查键是否相等，原因是不同的键对象

    //可能拥有相同的哈希

    if ((e.hash == hash) && e.key.equals(key)) {

      //这是相同键，覆盖该值

      //并从该方法返回 old 值

      Object old = e.value;

      e.value = value;

      return old;

    }

  }

  //仍然在此处，因此它是一个新键，只需添加一个新 Entry

  //Entry 对象包含 key 对象、 value 对象、一个整型的 hash、

  //和一个指向列表中的下一个 Entry 的 next Entry

  //创建一个指向上一个列表开头的新 Entry，

  //并将此新 Entry 插入表中

  Entry e = new Entry(hash, key, value, table[index]);

  table[index] = e;

  return null;

}

 

如果看一下各种基于哈希的Map的源代码，您将发现这基本上就是它们的工作原理。此外，还有一些需要进一步考虑的事项，如处理空键和值以及调整内部数组，此处定义的的put()方法还应包含相应的get()的算法，这是因为插入包括搜索映射索引处的相以查询该键是否已经存在(即get()方法和put()方法具有相同的算法，但get()不包含插入和覆盖代码。使用链接列表并不是解决冲突的唯一方法，某些哈希映射使用另一种“开放式寻址“方案。

同步Map

同步与否由何差别？（对于同步，您即可以使用同步的Map，也可以使用Collections.syschronizedMap()将未同步的Map转换为同步的Map，后者使用”同步的包装器”）这是一个异常复杂的选择，完全取决于您如何根据多线程并发访问和更新使用Map，同时还需要进行维护方面的考虑。，并在后来向应用程序中添加并发更新线程时忘记将此未同步的 Map 更改为同步的 Map。 这将使您的应用程序容易崩溃（一种要确定和跟踪的最糟糕的错误）。 但如果默认为同步，则将因随之而来的可怕性能而序列化执行多线程应用程序。看起来，我们需要某种决策树来帮助我们正确选择。

Doug Lea 是纽约州立大学奥斯威戈分校计算机科学系的教授。他创建了一组公共领域的程序包（统称 util.concurrent），该程序包包含许多可以简化高性能并行编程的实用程序类。这些类中包含两个 Map，即 ConcurrentReaderHashMap 和 ConcurrentHashMap。 这些 Map 实现是线程安全的，并且不需要对并发访问或更新进行同步，同时还适用于大多数需要 Map 的情况。 它们还远比同步的 Map（如 Hashtable）或使用同步的包装器更具伸缩性，并且与 HashMap 相比，它们对性能的破坏很小。 util.concurrent 程序包构成了 JSR166 的基础；JSR166 已经开发了一个包含在 Java 1.5 版中的并发实用程序，而 Java 1.5 版将把这些 Map 包含在一个新的 java.util.concurrent 程序包中。

所有这一切意味着您不需要一个决策树来决定是使用同步的 Map 还是使用非同步的 Map， 而只需使用 ConcurrentHashMap。 当然，在某些情况下，使用 ConcurrentHashMap 并不合适。 但这些情况很少见，并且应具体情况具体处理。 这就是监测的用途。

优化 Hasmap

如果哈希映射的内部数组只包含一个元素，则所有项将映射到此数组位置，从而构成一个较长的链接列表。由于我们的更新和访问使用了对链接列表的线性搜索，而这要比 Map 中的每个数组索引只包含一个对象的情形要慢得多，因此这样做的效率很低。访问或更新链接列表的时间与列表的大小线性相关，而使用哈希函数问或更新数组中的单个元素则与数组大小无关 — 就渐进性质（Big-O 表示法）而言，前者为 O(n)，而后者为 O(1)。 因此，使用一个较大的数组而不是让太多的项聚集在太少的数组位置中是有意义的。

调整 Map 实现的大小

在哈希术语中，内部数组中的每个位置称作“存储桶”(bucket)，而可用的存储桶数（即内部数组的大小）称作容量 (capacity)。 为使 Map 对象有效地处理任意数目的项，Map 实现可以调整自身的大小。 但调整大小的开销很大。 调整大小需要将所有元素重新插入到新数组中，这是因为不同的数组大小意味着对象现在映射到不同的索引值。先前冲突的键可能不再冲突，而先前不冲突的其他键现在可能冲突。 这显然表明，如果将 Map 调整得足够大，则可以减少甚至不再需要重新调整大小，这很有可能显著提高速度。

使用 1.4.2 JVM 运行一个简单的测试，即用大量的项（数目超过一百万）填充 HashMap。 表 5 显示了结果，并将所有时间标准化为已预先设置大小的服务器模式（关联文件中的。 对于已预先设置大小的 JVM，客户端和服务器模式 JVM 运行时间几乎相同（在放弃 JIT 编译阶段后）。 但使用 Map 的默认大小将引发多次调整大小操作，开销很大，在服务器模式下要多用 50% 的时间，而在客户端模式下几乎要多用两倍的时间！

表 5： 填充已预先设置大小的 HashMap 与填充默认大小的 HashMap 所需时间的比较

 

客户端模式

服务器模式

预先设置的大小

100%

100%

默认大小

294%

157%

使用负载因子

为确定何时调整大小，而不是对每个存储桶中的链接列表的深度进行记数，基于哈希的 Map 使用一个额外参数并粗略计算存储桶的密度。 Map 在调整大小之前，使用名为“负载因子”的参数指示 Map 将承担的“负载”量，即它的负载程度。 负载因子、项数（Map 大小）与容量之间的关系简单明了：

• 如果（负载因子）x（容量）>（Map 大小），则调整 Map 大小

例如，如果默认负载因子为 0.75，默认容量为 11，则 11 x 0.75 = 8.25，该值向下取整为 8 个元素。 因此，如果将第 8 个项添加到此 Map，则该 Map 将自身的大小调整为一个更大的值。 相反，要计算避免调整大小所需的初始容量，用将要添加的项数除以负载因子，并向上取整，例如，

• 对于负载因子为 0.75 的 100 个项，应将容量设置为 100/0.75 = 133.33，并将结果向上取整为 134（或取整为 135 以使用奇数）

奇数个存储桶使 map 能够通过减少冲突数来提高执行效率。 虽然我所做的测试（关联文件中的 并未表明质数可以始终获得更好的效率，但理想情形是容量取质数。 1.4 版后的某些 Map（如 HashMap 和 LinkedHashMap，而非 Hashtable 或 IdentityHashMap）使用需要 2 的幂容量的哈希函数，但下一个最高 2 的幂容量由这些 Map 计算，因此您不必亲自计算。

负载因子本身是空间和时间之间的调整折衷。较小的负载因子将占用更多的空间，但将降低冲突的可能性，从而将加快访问和更新的速度。 使用大于 0.75 的负载因子可能是不明智的，而使用大于 1.0 的负载因子肯定是不明知的，这是因为这必定会引发一次冲突。 使用小于 0.50 的负载因子好处并不大，但只要您有效地调整 Map 的大小，应不会对小负载因子造成性能开销，而只会造成内存开销。 但较小的负载因子将意味着如果您未预先调整 Map 的大小，则导致更频繁的调整大小，从而降低性能，因此在调整负载因子时一定要注意这个问题。

Collection

java.lang.Iterable实现这个接口允许对象成为 "foreach" 语句的目标

1.Collection 接口
　　用于表示任何对象或元素组。想要尽可能以常规方式处理一组元素时，就使用这一接口。
　　(1) 单元素添加、删除操作：

　　　boolean add(Object o):将对象添加给集合

　　　boolean remove(Object o): 如果集合中有与o相匹配的对象，则删除对象o
　　(2) 查询操作：
　　　int size() ：返回当前集合中元素的数量

　　　boolean isEmpty() ：判断集合中是否有任何元素

　　　boolean contains(Object o) ：查找集合中是否含有对象o

　　　Iterator iterator() ：返回一个迭代器，用来访问集合中的各个元素

　　(3) 组操作 ：作用于元素组或整个集合

　　　boolean containsAll(Collection c): 查找集合中是否含有集合c 中所有元素

　　　boolean addAll(Collection c) : 将集合c 中所有元素添加给该集合

　　　void clear(): 删除集合中所有元素

　　　void removeAll(Collection c) : 从集合中删除集合c 中的所有元素

　　　void retainAll(Collection c) : 从集合中删除集合c 中不包含的元素

　　(4) Collection转换为Object数组 ：

　　　Object[] toArray() ：返回一个内含集合所有元素的array

　　　Object[] toArray(Object[] a) ：返回一个内含集合所有元素的array。运行期返回的array和参数a的型别相同，需要转换为正确型别。

　　此外，您还可以把集合转换成其它任何其它的对象数组。但是，您不能直接把集合转换成基本数据类型的数组，因为集合必须持有对象。

 

Collection不提供get()方法。如果要遍历Collectin中的元素，就必须用Iterator。

1.1.AbstractCollection 抽象类

　　AbstractCollection 类提供具体“集合框架”类的基本功能。虽然您可以自行实现 Collection 接口的所有方法，但是，除了iterator()和size()方法在恰当的子类中实现以外，其它所有方法都由 AbstractCollection 类来提供实现。如果子类不覆盖某些方法，可选的如add()之类的方法将抛出异常。

1.2.Iterator 接口
　　Collection 接口的iterator()方法返回一个 Iterator。Iterator接口方法能以迭代方式逐个访问集合中各个元素，并安全的从Collection 中除去适当的元素。
　　(1) boolean hasNext(): 判断是否存在另一个可访问的元素
　　　　Object next(): 返回要访问的下一个元素。如果到达集合结尾，则抛出NoSuchElementException异常。

　　(2) void remove(): 删除上次访问返回的对象。本方法必须紧跟在一个元素的访问后执行。如果上次访问后集合已被修改，方法将抛出IllegalStateException。

　　“Iterator中删除操作对底层Collection也有影响。”

　　迭代器是 故障快速修复（fail-fast）的。这意味着，当另一个线程修改底层集合的时候，如果您正在用 Iterator 遍历集合，那么，Iterator就会抛出 ConcurrentModificationException （另一种 RuntimeException异常）异常并立刻失败

2.List接口

　　List 接口继承了 Collection 接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作。

　　(1) 面向位置的操作包括插入某个元素或 Collection 的功能，还包括获取、除去或更改元素的功能。在 List 中搜索元素可以从列表的头部或尾部开始，如果找到元素，还将报告元素所在的位置 :

　　void add(int index, Object element): 在指定位置index上添加元素element

　　boolean addAll(int index, Collection c): 将集合c的所有元素添加到指定位置index

　　Object get(int index): 返回List中指定位置的元素

　　int indexOf(Object o): 返回第一个出现元素o的位置，否则返回-1

　　int lastIndexOf(Object o) ：返回最后一个出现元素o的位置，否则返回-1

　　Object remove(int index)　：删除指定位置上的元素

　　Object set(int index, Object element) ：用元素element取代位置index上的元素，并且返回旧的元素

　　(2) List 接口不但以位置序列迭代的遍历整个列表，还能处理集合的子集：

　　　ListIterator listIterator() : 返回一个列表迭代器，用来访问列表中的元素

　　　ListIterator listIterator(int index) : 返回一个列表迭代器，用来从指定位置index开始访问列表中的元素

　　List subList(int fromIndex, int toIndex) ：返回从指定位置fromIndex（包含）到toIndex（不包含）范围中各个元素的列表视图

　　“对子列表的更改（如 add()、remove() 和 set() 调用）对底层 List 也有影响。”

　　2.1.ListIterator接口

　　ListIterator 接口继承 Iterator 接口以支持添加或更改底层集合中的元素，还支持双向访问。ListIterator没有当前位置，光标位于调用previous和next方法返回的值之间。一个长度为n的列表，有n+1个有效索引值：

　　(1) void add(Object o): 将对象o添加到当前位置的前面

　　　void set(Object o): 用对象o替代next或previous方法访问的上一个元素。如果上次调用后列表结构被修改了，那么将抛出IllegalStateException异常。

　　(2) boolean hasPrevious(): 判断向后迭代时是否有元素可访问

　　　Object previous()：返回上一个对象

　　　int nextIndex(): 返回下次调用next方法时将返回的元素的索引

　　　int previousIndex():　返回下次调用previous方法时将返回的元素的索引

　　“正常情况下，不用ListIterator改变某次遍历集合元素的方向 — 向前或者向后。虽然在技术上可以实现，但previous() 后立刻调用next()，返回的是同一个元素。把调用 next()和previous()的顺序颠倒一下，结果相同。”

　　“我们还需要稍微再解释一下 add() 操作。添加一个元素会导致新元素立刻被添加到隐式光标的前面。因此，添加元素后调用 previous() 会返回新元素，而调用 next() 则不起作用，返回添加操作之前的下一个元素。”

2.2.AbstractList和AbstractSequentialList抽象类

　　有两个抽象的 List 实现类：AbstractList 和 AbstractSequentialList。像 AbstractSet 类一样，它们覆盖了 equals() 和 hashCode() 方法以确保两个相等的集合返回相同的哈希码。若两个列表大小相等且包含顺序相同的相同元素，则这两个列表相等。这里的 hashCode() 实现在 List 接口定义中指定，而在这里实现。

　　除了equals()和hashCode()，AbstractList和AbstractSequentialList实现了其余 List 方法的一部分。因为数据的随机访问和顺序访问是分别实现的，使得具体列表实现的创建更为容易。需要定义的一套方法取决于您希望支持的行为。您永远不必亲自提供的是 iterator方法的实现。

2.3. LinkedList类和ArrayList类

　　在“集合框架”中有两种常规的 List 实现：ArrayList 和 LinkedList。使用两种 List 实现的哪一种取决于您特定的需要。如果要支持随机访问，而不必在除尾部的任何位置插入或除去元素，那么，ArrayList 提供了可选的集合。但如果，您要频繁的从列表的中间位置添加和除去元素，而只要顺序的访问列表元素，那么，LinkedList 实现更好。

　　“ArrayList 和 LinkedList 都实现 Cloneable 接口，都提供了两个构造函数，一个无参的，一个接受另一个Collection”

2.3.1. LinkedList类

　　LinkedList类添加了一些处理列表两端元素的方法。

　　(1) void addFirst(Object o): 将对象o添加到列表的开头

　　　void addLast(Object o)：将对象o添加到列表的结尾

　　(2) Object getFirst(): 返回列表开头的元素

　　　　Object getLast(): 返回列表结尾的元素

　　(3) Object removeFirst(): 删除并且返回列表开头的元素

　　　　Object removeLast():删除并且返回列表结尾的元素

　　(4) LinkedList(): 构建一个空的链接列表

　　　　LinkedList(Collection c): 构建一个链接列表，并且添加集合c的所有元素

　　“使用这些新方法，您就可以轻松的把 LinkedList 当作一个堆栈、队列或其它面向端点的数据结构。”

2.3.2. ArrayList类

　　ArrayList类封装了一个动态再分配的Object[]数组。每个ArrayList对象有一个capacity。这个capacity表示存储列表中元素的数组的容量。当元素添加到ArrayList时，它的capacity在常量时间内自动增加。

　　在向一个ArrayList对象添加大量元素的程序中，可使用ensureCapacity方法增加capacity。这可以减少增加重分配的数量。

　　(1) void ensureCapacity(int minCapacity): 将ArrayList对象容量增加minCapacity

　　(2) void trimToSize(): 整理ArrayList对象容量为列表当前大小。程序可使用这个操作减少ArrayList对象存储空间。

2.3.2.1. RandomAccess接口

　　一个特征接口。该接口没有任何方法，不过你可以使用该接口来测试某个集合是否支持有效的随机访问。ArrayList和Vector类用于实现该接口

3.Set接口

　　Set 接口继承 Collection 接口，而且它不允许集合中存在重复项，每个具体的 Set 实现类依赖添加的对象的 equals()方法来检查独一性。Set接口没有引入新方法，所以Set就是一个Collection，只不过其行为不同。

3.1. Hash表

　　Hash表是一种数据结构，用来查找对象。Hash表为每个对象计算出一个整数，称为Hash Code(哈希码)。Hash表是个链接式列表的阵列。每个列表称为一个buckets(哈希表元)。对象位置的计算　index = HashCode % buckets (HashCode为对象哈希码，buckets为哈希表元总数)。

　　当你添加元素时，有时你会遇到已经填充了元素的哈希表元，这种情况称为Hash Collisions(哈希冲突)。这时，你必须判断该元素是否已经存在于该哈希表中。

　　如果哈希码是合理地随机分布的，并且哈希表元的数量足够大，那么哈希冲突的数量就会减少。同时，你也可以通过设定一个初始的哈希表元数量来更好地控制哈希表的运行。初始哈希表元的数量为　buckets = size * 150% + 1 (size为预期元素的数量)。

　　如果哈希表中的元素放得太满，就必须进行rehashing(再哈希)。再哈希使哈希表元数增倍，并将原有的对象重新导入新的哈希表元中，而原始的哈希表元被删除。load factor(加载因子)决定何时要对哈希表进行再哈希。在Java编程语言中，加载因子默认值为0.75，默认哈希表元为101。

3.2. Comparable接口和Comparator接口

　　在“集合框架”中有两种比较接口：Comparable接口和Comparator接口。像String和Integer等Java内建类实现Comparable接口以提供一定排序方式，但这样只能实现该接口一次。对于那些没有实现Comparable接口的类、或者自定义的类，您可以通过Comparator接口来定义您自己的比较方式。

3.2.1. Comparable接口

　　在java.lang包中，Comparable接口适用于一个类有自然顺序的时候。假定对象集合是同一类型，该接口允许您把集合排序成自然顺序。

　　(1) int compareTo(Object o): 比较当前实例对象与对象o，如果位于对象o之前，返回负值，如果两个对象在排序中位置相同，则返回0，如果位于对象o后面，则返回正值

　　在 Java 2 SDK版本1.4中有二十四个类实现Comparable接口。下表展示了8种基本类型的自然排序。虽然一些类共享同一种自然排序，但只有相互可比的类才能排序。

类
 排序
BigDecimal,BigInteger,Byte, Double, Float,Integer,Long,Short
 按数字大小排序 
Character
 按 Unicode 值的数字大小排序 
String
 按字符串中字符 Unicode 值排序
　　
　　利用Comparable接口创建您自己的类的排序顺序，只是实现compareTo()方法的问题。通常就是依赖几个数据成员的自然排序。同时类也应该覆盖equals()和hashCode()以确保两个相等的对象返回同一个哈希码

若一个类不能用于实现java.lang.Comparable，或者您不喜欢缺省的Comparable行为并想提供自己的排序顺序(可能多种排序方式)，你可以实现Comparator接口，从而定义一个比较器。

　　(1)int compare(Object o1, Object o2): 对两个对象o1和o2进行比较，如果o1位于o2的前面，则返回负值，如果在排序顺序中认为o1和o2是相同的，返回0，如果o1位于o2的后面，则返回正值

　　“与Comparable相似，0返回值不表示元素相等。一个0返回值只是表示两个对象排在同一位置。由Comparator用户决定如何处理。如果两个不相等的元素比较的结果为零，您首先应该确信那就是您要的结果，然后记录行为。”

　　(2)boolean equals(Object obj): 指示对象obj是否和比较器相等。

　　“该方法覆写Object的equals()方法，检查的是Comparator实现的等同性，不是处于比较状态下的对象。”

 

3.3. SortedSet接口

　　“集合框架”提供了个特殊的Set接口：SortedSet，它保持元素的有序顺序。SortedSet接口为集的视图(子集)和它的两端（即头和尾）提供了访问方法。当您处理列表的子集时，更改视图会反映到源集。此外，更改源集也会反映在子集上。发生这种情况的原因在于视图由两端的元素而不是下标元素指定，所以如果您想要一个特殊的高端元素（toElement）在子集中，您必须找到下一个元素。

　　添加到SortedSet实现类的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。TreeSet类是它的唯一一份实现。

　　“因为集必须包含唯一的项，如果添加元素时比较两个元素导致了0返回值（通过Comparable的compareTo()方法或Comparator的compare()方法），那么新元素就没有添加进去。如果两个元素相等，那还好。但如果它们不相等的话，您接下来就应该修改比较方法，让比较方法和 equals() 的效果一致。”

　　(1) Comparator comparator(): 返回对元素进行排序时使用的比较器，如果使用Comparable接口的compareTo()方法对元素进行比较，则返回null

　　(2) Object first(): 返回有序集合中第一个(最低)元素

　　(3) Object last(): 返回有序集合中最后一个(最高)元素

　　(4) SortedSet subSet(Object fromElement, Object toElement): 返回从fromElement(包括)至toElement(不包括)范围内元素的SortedSet视图(子集)

　　(5) SortedSet headSet(Object toElement): 返回SortedSet的一个视图，其内各元素皆小于toElement

　　(6) SortedSet tailSet(Object fromElement): 返回SortedSet的一个视图，其内各元素皆大于或等于fromElement

3.4. AbstractSet抽象类

　　AbstractSet类覆盖了Object类的equals()和hashCode()方法，以确保两个相等的集返回相同的哈希码。若两个集大小相等且包含相同元素，则这两个集相等。按定义，集的哈希码是集中元素哈希码的总和。因此，不论集的内部顺序如何，两个相等的集会有相同的哈希码。

　　3.4.1. Object类

　　(1) boolean equals(Object obj): 对两个对象进行比较，以便确定它们是否相同

　　(2) int hashCode(): 返回该对象的哈希码。相同的对象必须返回相同的哈希码

3.5. HashSet类类和TreeSet类

　　“集合框架”支持Set接口两种普通的实现：HashSet和TreeSet(TreeSet实现SortedSet接口)。在更多情况下，您会使用 HashSet 存储重复自由的集合。考虑到效率，添加到 HashSet 的对象需要采用恰当分配哈希码的方式来实现hashCode()方法。虽然大多数系统类覆盖了 Object中缺省的hashCode()和equals()实现，但创建您自己的要添加到HashSet的类时，别忘了覆盖 hashCode()和equals()。

　　当您要从集合中以有序的方式插入和抽取元素时，TreeSet实现会有用处。为了能顺利进行，添加到TreeSet的元素必须是可排序的。

　　3.5.1.HashSet类

　　(1) HashSet(): 构建一个空的哈希集

　　(2) HashSet(Collection c): 构建一个哈希集，并且添加集合c中所有元素

　　(3) HashSet(int initialCapacity): 构建一个拥有特定容量的空哈希集

　　(4) HashSet(int initialCapacity, float loadFactor): 构建一个拥有特定容量和加载因子的空哈希集。LoadFactor是0.0至1.0之间的一个数

　　3.5.2. TreeSet类

　　(1) TreeSet():构建一个空的树集

　　(2) TreeSet(Collection c): 构建一个树集，并且添加集合c中所有元素

　　(3) TreeSet(Comparator c): 构建一个树集，并且使用特定的比较器对其元素进行排序

　　“comparator比较器没有任何数据，它只是比较方法的存放器。这种对象有时称为函数对象。函数对象通常在“运行过程中”被定义为匿名内部类的一个实例。”

　　TreeSet(SortedSet s): 构建一个树集，添加有序集合s中所有元素，并且使用与有序集合s相同的比较器排序

　　3.6. LinkedHashSet类

　　LinkedHashSet扩展HashSet。如果想跟踪添加给HashSet的元素的顺序，LinkedHashSet实现会有帮助。LinkedHashSet的迭代器按照元素的插入顺序来访问各个元素。它提供了一个可以快速访问各个元素的有序集合。同时，它也增加了实现的代价，因为哈希表元中的各个元素是通过双重链接式列表链接在一起的。

　　(1) LinkedHashSet(): 构建一个空的链接式哈希集

　　(2) LinkedHashSet(Collection c): 构建一个链接式哈希集，并且添加集合c中所有元素

　　(3) LinkedHashSet(int initialCapacity): 构建一个拥有特定容量的空链接式哈希集

　　(4) LinkedHashSet(int initialCapacity, float loadFactor): 构建一个拥有特定容量和加载因子的空链接式哈希集。LoadFactor是0.0至1.0之间的一个数

　　“为优化HashSet空间的使用，您可以调优初始容量和负载因子。TreeSet不包含调优选项，因为树总是平衡的。”

 

Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。