java 集合类 之 Set

Set类

Set接口继承自Collection，不按特定的方式排序，并且不能重复，主要有两个实现类：HashSet和TreeSet,HashSet类按照哈希算法来存取集合中对象，存取速度比较快，HashSet类还有一个子类LinkedHashSet类，不仅实现了哈希算法，而且实现了链表数据结构，提高数据结构的插入和删除元素的性能，TreeSet类实现了SortedSet接口，具有排序功能。

看下这个程序：

package com.bin.proxy;
import java.util.HashSet;
import java.util.Set;
public class Test4 {
public static void main(String[] args){
Set<String> set = new HashSet<String>();
String s1="hello";
String s2=s1;

String s3=new String("world");
set.add(s1);
set.add(s2);
set.add(s3);
System.out.print(s2.equals(s1));
System.out.print(set.size());
}
}

把s2 的对象引用赋值给s1，则2个位同一个引用，值是相同的。Set采用equals()比较对象是否相等。而不是“==”。

HastSet类

我们先从HashSet源码看起：

下面是HashSet的定义：

1 public classHashSet<E>

2     extendsAbstractSet<E>

3     implementsSet<E>, Cloneable, java.io.Serializable

HashSet继承了AbstractSet，实现了Set接口。其实AbstractSet已经实现Set接口了。AbstractSet继承自AbstractCollection，而AbstractCollection实现了Collection接口的部分方法，而Set接口和Collection接口完全一致，所以AbstractSet只是实现了AbstractCollection没有实现的Set接口的方法和重写了部分AbstractCollection已经实现的方法。AbstractSet实现了equql()、hashCode（）、removeAll()功能的重写。

再看HashSet

下面是HashSet定义的属性：

1 private transient HashMap<E,Object> map;

2 private static final Object PRESENT = new Object();

想一下HashMap有什么特点：基于哈希表，存储键值对，Key不能相同等等。Key不能相同！这个特点是不是和Set的元素不能相同和类似？如果将Set的元素当成Map的Key，是否就保证了元素的不重复？！答案是肯定的。但是Map存储键值对，Key有了，那么Value呢？这正是第二个属性PERSENT的意义。看到PERSENT属性时一个Object对象，且是static和final的，它的用途就是当做Value存进map中。

总结一下，HashSet的实现方式大致如下，通过一个HashMap存储元素，元素是存放在HashMap的Key中，而Value统一使用一个Object对象。

这样看来HashSet应该很简单，应该只是使用了HashMap的部分内容来实现。

看下add()方法源码 ，即是通过HashMap实现，

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

addAll方式是在抽象类AbstractCollection中实现，HashSet通过继承拥有该方法，采用循环插入实现。

public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e))
modified = true;
return modified;
}
iterator()
public Iterator<E> iterator() {
returnmap.keySet().iterator();
}

很清楚了，返回的是HashMap中KeySet的迭代器。
size()
public int size() {
return
map.size();
}
size()方法同样返回的是map的大小，所以HashSet根本就没定义size属性。
public boolean isEmpty() {
return map.isEmpty();
}
既然size()用的是map的大小，那么isEmpty()自然也是判断map。

public boolean contains(Object o) {
return map.containsKey(o);
}
public voidclear() {
map.clear();
}
public Objectclone() {
try {
HashSet<E> newSet =(HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}

这几个方法就不解释了。
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
remove(Object o)为什么还要判断结果呢？因为通过HashSet存入的元素，所对应的Value值都是PERSENT，如果传入的o不存在，map的remove方法返回为null，则对应的结果是HashSet的remove操作应该放回false，所以这里根据返回的结果判断是否移除成功。
在Object类中定义了hashCode()和equals()方法，equals()方法按照内存地址比较对象是否相等，因此如果object1.equals(object2)为true,则表明两个变量引用同一个对象，其哈希码也肯定相等。如果用户定义一个类覆盖了Object类的equals()方法，但没有覆盖Object类的hashCode()方法，就会会导致，当object1.equals(object2)为true,而哈希码不一定一样，导致HashSet或HashMap无法正常工作。

package com.bin.proxy;
class Customer {
String name;
int
age;
public String getName() {
return
name;
}
public
void setName(String name) {
this.name = name;
}
public
int getAge() {
return
age;
}
public
void setAge(int age) {
this.age = age;
}
public
boolean equals(Object o){
if(this ==o)returntrue;
if((o
instanceof Test5))returnfalse;
final Customer test=(Customer)o;
if(this.name.equals(test.getName())&&this.age==test.getAge())
return
true;
else
return
false;
}
public
int hashCode(){
int result;
result=(name ==null?0:name.hashCode());
result = 29*result+age;
return result;
}
}
public
class Test5{
public
static void main(String[] args){
Customer t1= new Customer();
Customer t2= new Customer();
t1.setAge(4);
t1.setName("song");
t2.setAge(4);
t2.setName("song");
System.out.print(t1.equals(t2));
}
}
如上程序，若把hashCode()去掉，则在HashSet和HashMap代表不同的对象。

四、TreeSet类

其构造方法为：

构造方法摘要
TreeSet() 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
TreeSet(Collection<? extendsE> c) 构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
TreeSet(Comparator<? superE> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。
TreeSet(SortedSet<E> s) 构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

例程：

Set<Integer>set =new TreeSet<Integer>();

set.add(newInteger(8));

set.add(new Integer(7));

set.add(new Integer(9));

则程序打印set时显示 6 7 8 9。

TreeSet支持两种排序方式：自然排序和客户化排序，默认采用自然排序

1、 自然排序

在JDK中有个Comparable接口，部分类实现了他，如Integer,Double和String等，其有个接口compareTo(Object o)方法，x.compareTo(y),返回0,表示相等，若大于0表示x大于y,反之小于0，表示x小于y。

TreeSet调用compareTo（）方法比较集合对象的大小，然后进行升序排序，成为自然排序，使用自然排序的时候，只能想TreeSetJ集合加入同类型的对象，这些对象必须实现了Comparable接口，

2、 客户化排序

除了自然排序,TreeSet还支持客户化排序，java.util.Comparator<Type>接口提供具体排序方式，Comparator有个compare(Type x,Type y)方法，用于比较对象大小，当返回大于0时，表示x大于y，当放回小于0时，表示x小于y，当返回等于0时，表示x等于y

package com.bin.jihe;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class CustomerComparator implements Comparator<Customer>{
public static void main(String[] args) {
Set<Customer> set=new TreeSet<Customer>(newCustomerComparator());
set.add(new Customer(11,"tom"));
set.add(new Customer(12,"jim"));
set.add(new Customer(10,"ljcy"));
Iterator <Customer>it=set.iterator();
while(it.hasNext()){
Customer customer=it.next();
System.out.println(customer.getAge()+"-"+customer.getName());
}
}
@Override
public int compare(Customer o1, Customer o2) {
if(o1.getName().compareTo(o2.getName())>0)return 1;
if(o1.getName().compareTo(o2.getName())<0)return -1;
return 0;
}
}