Java数据结构与算法之数据结构-逻辑结构-集合(七)------集合之Set接口和HashSet和TreeSet、LinkedHashSet实现类总结

一、Set接口的概述:

1、Set接口的基本使用特点:

Set接口存储一组唯一，无序的对象

HashSet 是Set接口常用的实现类

HashSet允许集合元素值为null 操作数据的方法与List类似

Set接口不存在get()方法

set 是一个不包含重复元素的集合(collction)。Set接口中的函数都是从Collection继承而来。

但限制了add 的使用，需要其不能添加重复元素。

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

此接口模仿了数学上的 set 抽象。

在所有构造方法以及 add、equals 和 hashCode 方法的协定上，Set 接口还加入了其他规定，这些规定超出了从 Collection 接口所继承的内容。出于方便

考虑，它还包括了其他继承方法的声明（这些声明的规范已经专门针对 Set 接口进行了修改，但是没有包含任何其他的规定）。

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

注：如果将可变对象用作 set 元素，那么必须极其小心。如果对象是 set 中某个元素，以一种影响 equals 比较的方式改变对象的值，那么 set 的行为就是不确

定的。此项禁止的一个特殊情况是不允许某个 set 包含其自身作为元素。

某些 set 实现对其所包含的元素有所限制。例如，某些实现禁止 null 元素，而某些则对其元素的类型所有限制。试图添加不合格的元素会抛出未经检查的

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

2、Set接口的API文档描述:

图1：
如上图所示，可以得到如下的信息:

①、 Set接口继承于Collection的集合总接口。而Collection接口又继承语Iterable接口；

②、 Set接口的子接口有NavigableSet<E>, SortedSet<E>

  ③、 Set接口的实现类有：AbstractSet, ConcurrentHashMap.KeySetView, ConcurrentSkipListSet, CopyOnWriteArraySet,EnumSet,
HashSet, JobStateReasons, LinkedHashSet, TreeSet，但是在实际的开发中使用比较多的往往只有HashSet，

LinkedHashSet,
TreeSet这三个接口。

3、Set接口的源码解析:

Set接口是继承子Collection接口的一个接口，其具有如下的一些待实现的方法:



图2:
从图中可以得知其具有的方法基本上和Collection里面的方法没有什么差别。主要的差别体现再Set接口的众多的实现类HashSet上。

有网友对Set接口的源码进行翻译了一遍，这样可以相对清晰的理解Set接口的每一个方法进行了解。在这里将网友的翻译引进过来以方便大家查看。原文出自:http://www.cnblogs.com/whyhappy/p/5479595.html.

size
int size()返回 set 中的元素数（其容量）。如果 set 包含多个 Integer.MAX_VALUE 元素，则返回 Integer.MAX_VALUE。

指定者：
接口 Collection<E> 中的 size
返回：
此 set 中的元素数（其容量）

--------------------------------------------------------------------------------

isEmpty
boolean isEmpty()如果 set 不包含元素，则返回 true。

指定者：
接口 Collection<E> 中的 isEmpty
返回：
如果此 set 不包含元素，则返回 true

--------------------------------------------------------------------------------

contains
boolean contains(Object o)如果 set 包含指定的元素，则返回 true。更确切地讲，当且仅当 set 包含满足 (o==null ? e==null : o.equals(e)) 的元素 e 时返回 true。

指定者：
接口 Collection<E> 中的 contains
参数：
o - 要测试此 set 中是否存在的元素
返回：
如果此 set 包含指定的元素，则返回 true
抛出：
ClassCastException - 如果指定元素的类型与此 set 不兼容（可选）
NullPointerException - 如果指定的元素为 null 并且此 set 不允许 null 元素（可选）

--------------------------------------------------------------------------------

iterator
Iterator<E> iterator()返回在此 set 中的元素上进行迭代的迭代器。返回的元素没有特定的顺序（除非此 set 是某个提供顺序保证的类的实例）。

指定者：
接口 Collection<E> 中的 iterator
指定者：
接口 Iterable<E> 中的 iterator
返回：
在此 set 中的元素上进行迭代的迭代器

--------------------------------------------------------------------------------

toArray
Object[] toArray()返回一个包含 set 中所有元素的数组。如果此 set 对其迭代器返回的元素的顺序作出了某些保证，那么此方法也必须按相同的顺序返回这些元素。
由于此 set 不维护对返回数组的任何引用，因而它是安全的。（换句话说，即使此 set 受到数组的支持，此方法也必须分配一个新的数组）。因此，调用者可以随意修改返回的数组。

此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。

指定者：
接口 Collection<E> 中的 toArray
返回：
包含此 set 中所有元素的数组

--------------------------------------------------------------------------------

toArray
<T> T[] toArray(T[] a)返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。如果指定的数组能容纳该 set，则它将在其中返回。否则，将分配一个具有指定数组的运行时类型和此 set 大小的新数组。
如果指定的数组能容纳此 set，并有剩余的空间（即该数组的元素比此 set 多），那么会将列表中紧接该 set 尾部的元素设置为 null。（只有在调用者知道此 set 不包含任何 null 元素时才能用此方法确定此 set 的长度）。

如果此 set 对其迭代器返回的元素的顺序作出了某些保证，那么此方法也必须按相同的顺序返回这些元素。

像 toArray() 方法一样，此方法充当基于数组的 API 与基于 collection 的 API 之间的桥梁。更进一步说，此方法允许对输出数组的运行时类型上进行精确控制，在某些情况下，可以用来节省分配开销。

假定 x 是只包含字符串的一个已知 set。以下代码用来将该 set 转储到一个新分配的 String 数组：

String[] y = x.toArray(new String[0]);注意，toArray(new Object[0]) 和 toArray() 在功能上是相同的。

指定者：
接口 Collection<E> 中的 toArray
参数：
a - 存储此 set 中元素的数组（如果其足够大）；否则将为此分配一个具有相同运行时类型的新数组。
返回：
包含此 set 中所有元素的数组
抛出：
ArrayStoreException - 如果指定数组的运行时类型不是此 set 中所有元素的运行时类型的超类型
NullPointerException - 如果指定的数组为 null

--------------------------------------------------------------------------------

add
boolean add(E e)如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。更确切地讲，如果此 set 没有包含满足 (e==null ? e2==null : e.equals(e2)) 的元素 e2，则向该 set 中添加指定的元素 e。
如果此 set 已经包含该元素，则该调用不改变此 set 并返回 false。结合构造方法上的限制，这就可以确保 set 永远不包含重复的元素。
上述规定并未暗示 set 必须接受所有元素；set 可以拒绝添加任意特定的元素，包括 null，并抛出异常，这与 Collection.add 规范中所描述的一样。每个 set 实现应该明确地记录对其可能包含元素的所有限制。

指定者：
接口 Collection<E> 中的 add
参数：
e - 要添加到 set 中的元素
返回：
如果 set 尚未包含指定的元素，则返回 true
抛出：
UnsupportedOperationException - 如果此 set 不支持 add 操作
ClassCastException - 如果指定元素的类不允许它添加到此 set
NullPointerException - 如果指定的元素为 null 并且此 set 不允许 null 元素
IllegalArgumentException - 如果指定元素的某些属性不允许它添加到此 set

--------------------------------------------------------------------------------

remove
boolean remove(Object o)如果 set 中存在指定的元素，则将其移除（可选操作）。更确切地讲，如果此 set 中包含满足 (o==null ? e==null : o.equals(e)) 的元素 e，则移除它。
如果此 set 包含指定的元素（或者此 set 由于调用而发生更改），则返回 true（一旦调用返回，则此 set 不再包含指定的元素）。

指定者：
接口 Collection<E> 中的 remove
参数：
o - 从 set 中移除的对象（如果存在）
返回：
如果此 set 包含指定的对象，则返回 true
抛出：
ClassCastException - 如果指定元素的类型与此 set 不兼容（可选）
NullPointerException - 如果指定的元素为 null，并且此 set 不允许 null 元素（可选）
UnsupportedOperationException - 如果此 set 不支持 remove 操作

--------------------------------------------------------------------------------

containsAll
boolean containsAll(Collection<?> c)如果此 set 包含指定 collection 的所有元素，则返回 true。如果指定的 collection 也是一个 set，那么当该 collection 是此 set 的子集 时返回 true。

指定者：
接口 Collection<E> 中的 containsAll
参数：
c - 检查是否包含在此 set 中的 collection
返回：
如果此 set 包含指定 collection 中的所有元素，则返回 true
抛出：
ClassCastException - 如果指定 collection 中的一个或多个元素的类型与此 set 不兼容（可选）
NullPointerException - 如果指定的 collection 包含一个或多个 null 元素并且此 set 不允许 null 元素（可选），或者指定的 collection 为 null
另请参见：
contains(Object)

--------------------------------------------------------------------------------

addAll
boolean addAll(Collection<? extends E> c)如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。如果指定的 collection 也是一个 set，则 addAll 操作会实际修改此 set，这样其值是两个 set 的一个并集。
如果操作正在进行的同时修改了指定的 collection，则此操作的行为是不确定的。

指定者：
接口 Collection<E> 中的 addAll
参数：
c - 包含要添加到此 set 中的元素的 collection
返回：
如果此 set 由于调用而发生更改，则返回 true
抛出：
UnsupportedOperationException - 如果 set 不支持 addAll 操作
ClassCastException - 如果某些指定 collection 元素的类不允许它添加到此 set
NullPointerException - 如果指定的 collection 包含一个或多个 null 元素并且此 set 不允许 null 元素，或者指定的 collection 为 null
IllegalArgumentException - 如果指定 collection 元素的某些属性不允许它添加到此 set
另请参见：
add(Object)

--------------------------------------------------------------------------------

retainAll
boolean retainAll(Collection<?> c)仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
换句话说，移除此 set 中所有未包含在指定 collection 中的元素。如果指定的 collection 也是一个 set，则此操作会实际修改此 set，这样其值是两个 set 的一个交集。

指定者：
接口 Collection<E> 中的 retainAll
参数：
c - 包含要保留到此 set 中的元素的 collection
返回：
如果此 set 由于调用而发生更改，则返回 true
抛出：
UnsupportedOperationException - 如果此 set 不支持 retainAll 操作
ClassCastException - 如果此 set 元素的类与指定的 collection 不兼容（可选）
NullPointerException - 如果此 set 包含 null 元素并且指定的 collection 不支持 null 元素（可选），或者指定的 collection 为 null
另请参见：
remove(Object)

--------------------------------------------------------------------------------

removeAll
boolean removeAll(Collection<?> c)移除 set 中那些包含在指定 collection 中的元素（可选操作）。如果指定的 collection 也是一个 set，则此操作会实际修改此 set，这样其值是两个 set 的一个不对称差集。

指定者：
接口 Collection<E> 中的 removeAll
参数：
c - 包含要从此 set 中移除的元素的 collection
返回：
如果此 set 由于调用而发生更改，则返回 true
抛出：
UnsupportedOperationException - 如果此 set 不支持 removeAll 操作
ClassCastException - 如果此 set 元素的类与指定的 collection 不兼容（可选）
NullPointerException - 如果此 set 包含 null 元素并且指定的 collection 不允许 null 元素（可选），或者指定的 collection 为 null
另请参见：
remove(Object), contains(Object)

--------------------------------------------------------------------------------

clear
void clear()移除此 set 中的所有元素（可选操作）。此调用返回后该 set 将是空的。

指定者：
接口 Collection<E> 中的 clear
抛出：
UnsupportedOperationException - 如果此 set 不支持 clear 方法

--------------------------------------------------------------------------------

equals
boolean equals(Object o)比较指定对象与此 set 的相等性。如果指定的对象也是一个 set，两个 set 的大小相同，并且指定 set 的所有成员都包含在此 set 中（或者，此 set 的所有成员都包含在指定的 set 中也一样），则返回 true。
此定义确保了 equals 方法可在不同的 set 接口实现间正常工作。

指定者：
接口 Collection<E> 中的 equals
覆盖：
类 Object 中的 equals
参数：
o - 要与此 set 进行相等性比较的对象
返回：
如果指定的对象等于此 set，则返回 true

----------------------------------------------------------------

hashCode
int hashCode()
返回 set 的哈希码值。一个 set 的哈希码定义为此 set 中所有元素的哈希码和，其中 null 元素的哈希码定义为零。这就确保对于任意两个 set s1 和 s2 而言，s1.equals(s2) 就意味着 s1.hashCode()==s2.hashCode()，正如 Object.hashCode() 的常规协定所要求的那样。指定者：接口 Collection<E> 中的 hashCode覆盖：类 Object 中的 hashCode返回：此 set 的哈希码值

二、Set接口的实现类:

1、Set接口的实现类之HashSet:

①、HashSet的Java8 API文档描述如下:

HashSet特点:

HashSet实现了Set接口，它不允许集合中有重复的值，当我们提到HashSet时，第一件事情就是在将对象存储在HashSet之前，要先确保对象重写equals()和hashCode()方法，这样才能比较对象的值是否相等，以确保set中没有储存相等的对象。如果我们没有重写这两个方法，将会使用这个方法的默认实现。

②、HashSet的源码解析:

public boolean add(Object o)方法用来在Set中添加元素，当元素值重复时则会立即返回false，如果成功添加的话会返回true。

HashSet是基于HashMap来实现的，操作很简单，更像是对HashMap做了一次“封装”，而且只使用了HashMap的key来实现各种特性。对

于HashSet而言，它是基于HashMap来实现的。底层采用了HashMap来保存元素的。所以如果对HashMap比较熟悉的话HashSet也是相对简单的。

*HashSet的类声明:

public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable

HashSet继承AbstractSet类，实现Set、Cloneable、Serializable接口。其中AbstractSet提供 Set 接口的骨干实现，从而最大限度地减少了实

现此接口所需的工作。Set接口是一种不包括重复元素的Collection，它维持它自己的内部排序，所以随机访问没有任何意义。

*HashSet的基本属性:

/基于HashMap实现，底层使用HashMap保存所有元素
private transient HashMap<E,Object> map;

//定义一个Object对象作为HashMap的value
private static final Object PRESENT = new Object();

*HashSet的构造函数:

/**
* 默认构造函数
* 初始化一个空的HashMap，并使用默认初始容量为16和加载因子0.75。
*/
public HashSet() {
map = new HashMap<>();
}

/**
* 构造一个包含指定 collection 中的元素的新 set。
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}

/**
* 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}

/**
* 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。
*/
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}

/**
* 在API中我没有看到这个构造函数，今天看源码才发现（原来访问权限为包权限，不对外公开的）
* 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。
* dummy 为标识 该构造函数主要作用是对LinkedHashSet起到一个支持作用
*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

从构造函数中可以看出HashSet所有的构造都是构造出一个新的HashMap，其中最后一个构造函数，为包访问权限是不对外公开，仅仅只在使用

LinkedHashSet时才会发生作用。

*HashSet的方法:

既然HashSet是基于HashMap，那么对于HashSet而言，其方法的实现过程是非常简单的。

public Iterator<E> iterator() {
return map.keySet().iterator();
}

iterator()方法返回对此 set 中元素进行迭代的迭代器。返回元素的顺序并不是特定的。底层调用HashMap的keySet返回所有的key，这点反应了

HashSet中的所有元素都是保存在HashMap的key中，value则是使用的PRESENT对象，该对象为static final。

public int size() {
return map.size();
}

size()返回此 set 中的元素的数量（set 的容量）。底层调用HashMap的size方法，返回HashMap容器的大小。

public boolean isEmpty() {
return map.isEmpty();
}

  isEmpty()，判断HashSet()集合是否为空，为空返回 true，否则返回false。

public boolean contains(Object o) {
return map.containsKey(o);
}

  contains()，判断某个元素是否存在于HashSet()中，存在返回true，否则返回false。更加确切的讲应该是要满足这种关系才能返回true：

(o==null ? e==null : o.equals(e))。底层调用containsKey判断HashMap的key值是否为空。

public boolean add(E e) {
return map.put(e, PRESENT)==null;
}

add()如果此 set 中尚未包含指定元素，则添加指定元素。如果此Set没有包含满足(e==null ? e2==null : e.equals(e2)) 的e2时，则将e2添加到Set中，

否则不添加且返回false。由于底层使用HashMap的put方法将key = e，value=PRESENT构建成key-value键值对，当此e存在于HashMap的key中，则

value将会覆盖原有value，但是key保持不变，所以如果将一个已经存在的e元素添加中HashSet中，新添加的元素是不会保存到HashMap中，所以这就

满足了HashSet中元素不会重复的特性。

public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}

remove如果指定元素存在于此 set 中，则将其移除。底层使用HashMap的remove方法删除指定的Entry。

public void clear() {
map.clear();
}

clear从此 set 中移除所有元素。底层调用HashMap的clear方法清除所有的Entry。

public Object clone() {
try {
HashSet<E> newSet = (HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}

 clone返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。

由于HashSet底层使用了HashMap实现，使其的实现过程变得非常简单，如果你对HashMap比较了解，那么HashSet简直是小菜一碟。有两个方法

对HashMap和HashSet而言是非常重要的，下篇将详细讲解hashcode和equals。(这部分内容学习自: http://blog.csdn.net/chenssy/article/details/21988605)

2、Set接口的实现类之LinkedHashSet:

①、 LinkedHashSet实现类API解析:

②、 LinkedHashSet实现类源码解析:

public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, java.io.Serializable

LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起 来像是以插

入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。
LinkedHashSet在迭代访问Set中的全部元素时，性能比HashSet好，但是插入时性能稍微逊色于HashSet。

3、Set接口的实现类之TreeSet:

TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序

为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0

自然排序：
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。
obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。
如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0
定制排序
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法

如下用一个小程序验证HashSet和LinkedHashSet的基本区别。

@Test
public void setTest(){
Set<Integer> set = new HashSet<Integer>();

Set<Integer> set2 = new LinkedHashSet<Integer>();

//Set<String> set3 = new TreeSet<String>();

//向set中添加元素
set.add(100);
set.add(200);
set.add(300);
set.add(400);
set.add(500);
set.add(600);
set.add(700);
set.add(800);
set.add(900);
set.add(1000);
set.add(1100);
set.add(1200);

//向set中添加元素
set2.add(100);
set2.add(200);
set2.add(300);
set2.add(400);
set2.add(500);
set2.add(600);
set2.add(700);
set2.add(800);
set2.add(900);
set2.add(1000);
set2.add(1100);
set2.add(1200);

//输出元素
System.out.println("HashSet输出的顺序是和插入顺序不相同的:");
for(Iterator it = set.iterator(); it.hasNext();){
System.out.print(it.next()+",");
//输出元素的顺序和插入的顺序不是一样的:400,800,1200,100,500,900,200,600,1000,300,700,1100,
}

System.out.println();
//输出元素
System.out.println("LinkedHashSet输出的顺序是和插入顺序相同的:");
for(Iterator it = set2.iterator(); it.hasNext();){
System.out.print(it.next()+",");

}
}

输出的结果为:

HashSet输出的顺序是和插入顺序不相同的:
400,800,1200,100,500,900,200,600,1000,300,700,1100,
LinkedHashSet输出的顺序是和插入顺序相同的:
100,200,300,400,500,600,700,800,900,1000,1100,1200,