I学霸官方免费教程三十二：Java集合框架之Set集合

Set接口

Set集合是无序的、元素不可重复的结合
常用集合类有HashSet和TreeSet

HashSet类
常用的两种List集合各有各的优点，那么有没有同时具备这两种List集合的优点的集合呢？答案是肯定的，就是Set集合。

实例：
package collection.set.hashSet;
import java.util.HashSet;
import java.util.Iterator;
/**
 * 演示HashSet
 * @author 学霸联盟 - 赵灿
 */
public class HashSetDemo {
	public static void main(String[] args) {
		//创建HashSet对象
		HashSet hs = new HashSet();
		//循环向集合hs中添加元素
		for (int i = 0; i < 10; i++) {
			//创建Person对象
			Person p = new Person();
			//为Person对象的name属性赋值
			//有此处可知，加入的顺序是赵0、赵1、赵2......赵9
			p.name = "赵" + i;
			//将Person对象p加入集合
			hs.add(p);
		}
		/*
		 * Iterator（迭代器）：提供一种访问Collection集合中每个元素的方法
		 * Iterator是一个接口
		 * 其中定义了hasNext()方法，用于判断集合中是否含有下一个元素
		 * 如果还有下一个元素，返回true；反之，返回false
		 * 还定义了next()方法，获取下一个元素
		 * Collection中定义了一个iterator()方法，用于获取Iterator对象
		 * 
		 * 由于Set集合无法使用下标访问元素，无法使用下标的方式遍历集合元素
		 * 所以java为我们提供了Iterator用于访问集合中的各个元素
		 */
		Iterator it = hs.iterator();
		//调用hasNext方法判断集合中是否还有下一个元素
		while(it.hasNext()){
			//调用next方法获取下一个元素
			Object obj = it.next();
			//强制类型转换
			Person p = (Person)obj;
			//输出name属性值，和加入的顺序不同
			System.out.print(p.name + "  ");
		}
	}
}
//Person类
class Person{
	public String name;
}
我的机器上运行的结果：
赵4  赵7  赵8  赵0  赵6  赵1  赵2  赵3  赵5  赵9

从上面的结果可以看到，输出的顺序并不是加入时的顺序（未必一次就能运行出乱序的效果，可以瞬间连续多次点击eclipse上的运行按钮，这样看到乱序的效果几率比较大）；所以称Set是无序的集合。
那么Set是如何同时实现两种List集合的优点，又为什么没有顺序呢？
首先Set同时使用了两种List集合的结构，即数组 + 链表（Set中使用的是单项链表：一个节点中只存储下一个节点，而不存储上一个节点）；其中数组中的每一个位置均用于存储一个链表第一个元素。
这里不得不提到hashCode和equals。在创建Set集合的子类对象是，会创建一个Node[] table（节点数组）用于存储Node对象，Node中存储下一个Node和加入集合的元素。
再向集合中添加元素A时，Set会创建一个Node对象nodeA（Node nodeA = new Node()），将元素A赋值给nodeA中key属性（nodeA.key = A），然后根据元素A的hashCode值计算出下标（假如得到的下标是1），最后将nodeA的地址赋值到下标为1的位置中。
再次向集合中添加元素B时，又会创建Node对象nodeB，使用元素B的hashCode值计算出的下标也是1；此时会用equals方法判断元素A和元素B这两个对象是否相同。
如果equals返回true，则表示A和B内容相同，此时不会再将nodeB加入集合。
如果equals方法返回false，说明元素A和元素B是不同的两个对象，此时会将nodeB赋值给nodeA中的next属性（nodeA.next = nodeB），这样就形成了单项链表结构。
由以上描述可知，Set中不能添加重复的元素，而且无法从Set中快速获取某一个指定的元素，只能使用Iterator为我们提供的遍历集合的方法获取Set中的每一个元素。
示例图


上述中创建的table称作散列表或哈希表，默认初始长度为16（如果创建集合对象时自定义初始容量，自定义的容量值必须是2的整倍数），加载因子默认为0.75（当集合中添加的元素个数等于当前长度乘以加载因子时，集合会自动将容量增加至原来的2倍）。

拓展阅读：《I学霸官方免费教程三十七：Java数据结构之单向链表结构》

在使用key的hashCode值计算下标（计算方法：int h = key.hashCode(); int hash = h^(h>>>16); int index = (table.length - 1) & hash），这样可以保证不越界，但无法保证顺序，所以Set集合是无序的。
这样做带来的优点是当加入和删除元素时，都无需将前后元素在数组中位移，只需根据计算出的下标和equals方法得到的结果，进行加入和删除即可。
缺点是没有顺序，无法快速获取某个元素，必须采用遍历的方式获取Set集合中的元素。

另外，可以利用重写Object类中的hashCode方法，来控制什么样的对象可以生成一致的（节点对象在hash表中的）下标。此时再利用重写Object类的equals方法，来控制对象是否属于重复的对象。而且必须两个方法得到的结果同时满足要求时，才认为两个对象时同一对象；任一方法不满足要求都认为是不同的对象。

实例：
package collection.set.hashSet;
import java.util.HashSet;
import java.util.Set;
/**
 * 演示重写hashCode方法和equals方法
 * 
 * @author 学霸联盟 - 赵灿
 */
public class HashCodeEqualsDemo {
	public static void main(String[] args) {
		/*
		 * 在堆内存中创建了一个PersonHE类型的对象
		 * 对象中保存的是"张三"和"123456789"两个字符串
		 */
		PersonHE p1 = new PersonHE("张三", "123456789", 10);
		/*
		 * 又在堆内存中创建了一个PersonHE类型的对象
		 * 对象中保存的也是"张三"和"123456789"两个字符串
		 */
		PersonHE p2 = new PersonHE("张三", "123456789", 20);
		/*
		 * 此时在内存中有两个PersonHE类型的对象
		 * 如果PersonHE类没有重写父类Object的equals方法
		 * 那么使用的则是Object类中的equals方法比较
		 * 和使用==比较一样，结果是：false
		 */
		System.out.println(p1 == p2);
		/*
		 * 现在已经重写了equals方法，按照姓名和身份证号比较
		 * 创建的时候姓名和身份证号赋的值都一样
		 * 所以此时使用equals比较得到的结果是：true
		 */
		System.out.println(p1.equals(p2));
		//创建HashSet对象（父类引用指向子类对象）
		Set setHE = new HashSet();
		//向集合中添加元素
		setHE.add(p1);
		/*
		 * PersonHE重写了hashCode方法和equals方法
		 * 使得对象p1和p2的hashCode相等，equals的结果为true
		 * 所以不会将对象p2加入集合
		 */
		setHE.add(p2);
		/*
		 * 可以使用Iterator + while循环获取Set集合中的元素
		 * 也可以使用增强for循环
		 * 语法格式：for(数据类型  变量名 : 继承Collection接口的集合或数组){}
		 * 作用：循环一次从集合或数组中取出一个元素赋值变量
		 * 注意：声明变量的数据类型，必须能够接收集合或数组中取出的元素的类型
		 * 反例：String[] str = {"abc", "xyz"};
		 * 		for(int i : str){};
		 * 		执行第一次循环，取出字符串abc，赋值给int类型的变量i
		 * 		这很明显是错误的
		 */
		for(Object obj:setHE){
			PersonHE pHE = (PersonHE)obj;
			/*
			 * 由于加入前一个对象p1被覆盖
			 * 所以这里只会输出一次，而且输出的是对象p1
			 * 输出结果：姓名：张三  身份证号：123456789  年龄：10
			 */
			System.out.println(pHE);
		}
	}
}


/**
 * 创建人类PersonHE
 * @author 学霸联盟 - 赵灿
 */
class PersonHE{
	//姓名
	private String name;
	//身份证号
	private String id;
	//年龄
	public int age;
	//声明带参构造方法
	public PersonHE(String name, String id, int age){
		this.name = name;
		this.id = id;
		this.age = age;
	}
	/**
	 * 重写父类的hashCode
	 * 目的：自定义计算hash值的算法
	 */
	@Override
	public int hashCode() {
		/*
		 * 这里自定义的计算规则是，姓名的hash值亦或身份证号的hash值
		 * 当然算法不是固定的，只要能符合需求即可
		 * 使用亦或运算只是为了尽可能少的出现相同情况
		 */
		return name.hashCode() ^ id.hashCode();
	}
	/**
	 * 重写父类的equals方法
	 * 目的：自定义比较两个对象内容是否相同的规则
	 */
	@Override
	public boolean equals(Object obj) {
		//将Object强制类型转换为Person
		PersonHE p = (PersonHE)obj;
		//这里自定义的比较规则是，当姓名和身份证号相同时，就表示是同一个人
		boolean result = this.name.equals(p.name) && this.id.equals(p.id);
		return result;
	}
	/**
	 * 重写父类的toString方法
	 * 目的：自定义将对象转换成字符串的规则
	 */
	@Override
	public String toString() {
		//这里自定义的规则是 ，返回姓名和身份证号的字符串
		return "姓名：" + name + "  身份证号：" + id + "  年龄：" + age;
	}
}
运行结果：
false
true
姓名：张三  省份证号：123456789  年龄：10

总结：

Set集合是无序的，不可重复的集合，采用散列（Hash）存储（数组 + 单向链表），遍历时可以采用Iterator + 循环和增强for循环，Iterator（迭代器）主要方法：hasNext()和next()，判断加入集合中的两个对象是否重复：
1、判断hashCode是否相同；
当hashCode相同，但equals比较结果为false时，两个对象会被保存在一个单向链表上，这个单向链表称为“桶”
2、使用equals判断内容是否相同；
当equals比较结果为true，但hashCode不同时，两个对象会被保存在不同的“桶”中

TreeSet类

既然Set集合是无序的，那么可不可以另外给Set增加排序的方法呢？答案是肯定的。
java为我们提供了TreeSet类，实现了自动对加入Set集合的元素进行排序。但是要求加入到TreeSet集合的元素类型必须实现Comparable接口，并实现接口中的compareTo()方法，在该方法中自定义排序方式。

实例：
package collection.set.treeSet;
import java.util.TreeSet;
/**
 * 演示泛型TreeSet集合
 * @author 学霸联盟 - 赵灿
 */
public class TreeSetDemo {
	public static void main(String[] args) {
		//创建三个树枝对象
		Branch b1 = new Branch("树枝10", 10);
		Branch b2 = new Branch("树枝5", 5);
		Branch b3 = new Branch("树枝8", 8);
		//创建TreeSet集合对象
		TreeSet ts = new TreeSet();
		//向集合中添加元素;加入TreeSet集合的元素类型必须实现Comparable接口
		ts.add(b1);
		ts.add(b2);
		ts.add(b3);
		//增强for循环遍历集合ts
		for (Object obj : ts) {
			//强制类型转换
			Branch b = (Branch) obj;
			//输出
			System.out.println("名称：" + b.getName() + "  年轮" + b.getAnnualRing());
		}
	}
}

/**
 * 树枝类Branch
 * 加入TreeSet集合的元素类型必须实现Comparable接口
 * 否则程序运行的时候会出现异常
 * @author 学霸联盟 - 赵灿
 */
class Branch implements Comparable{
	//标识名称
	private String name;
	//年轮：用于排序的依据
	private int annualRing;
	//带参构造方法
	public Branch(String name, int annualRing){
		this.name = name;
		this.annualRing = annualRing;
	}
	//重写接口中的方法
	@Override
	public int compareTo(Object o) {
		//强制类型转换
		Branch b = (Branch)o;
		/*
		 * 使用年轮作为排序比较的依据
		 * 当前对象年轮减去参数传入的Branch对象的年龄
		 * 结果等于0表示：两个树枝年轮相等，排序不分先后
		 * 结果大于0表示：当前对象的年轮大，排在后面
		 * 结果小于0表示：参数对象的年轮大，排在后面
		 */
		int result = this.annualRing - b.annualRing;
		return result;
	}
	//获取名称
	public String getName(){
		return name;
	}
	//获取年轮
	public int getAnnualRing(){
		return annualRing;
	}
}
运行结果：
名称：树枝5  年轮5
名称：树枝8  年轮8
名称：树枝10  年轮10

版权声明：本文为博主原创文章，未经博主允许不得转载。