Set集合下的子类HashSet、TreeSet

 Set:无序，不可以重复。
 Set集合集合中的方法和Collection是一致的。它的取出方式只有一种。迭代器。
 
 	 |-HashSet:底层数据结构是哈希表,该集合是线程不同步的。
			HashSet集合是如何保证元素唯一性的呢？
			通过元素的hashCode方法和equals方法来完成的唯一性的判断。
			如果hashCode值相同，再继续判断元素的equals方法是否为true
			如果hashCode值不同，不会判断equals方法。
			
			HashSet的contains和remove依据都是hashCode方法，如果该方法返回值相同，才判断equals方法。
			
	 |-TreeSet:它可以给Set集合中的元素进行指定方式的排序。也是线程不同步的。
			保证元素唯一性的方式：通过比较的结果是否为0.
			底层数据结构是：二叉树。(红黑树结构)
		
            排序第一种方式：学生需要进行比较，就必须要让学生具备比较性。那么，就需要学生实现Comparable接口，强制让学生具备比较性。
			复写Comparable接口里的 int CompareTo()方法，此方法的返回值有三种，
			负数：该元素小于被对比的元素
			0，该元素等于被对比的元素
			正数：该元素排序的顺序大于被对比的元素，即排序越靠后。
			让元素自身具备比较性。只要让元素实现java.lang.Comparable接口，覆盖compareTo方法即可。
			
			但是，如果元素自身不具备比较性，或者元素自身具备的比较性，不是所需要的。
			比如，学生的自然排序是按年龄排序，现在想要按照学生姓名排序。还可以不改动原有代码。
			这时怎么办呢？
		排序的第二种方式：自定比较器的方式。
			这时可以让集合自身具备比较性。
			可以定义一个类实现java.util.Comparator接口，覆盖compare方法。将该Comparator接口子类对象作为实际参数
			传递给TreeSet集合构造函数。

 

 下面看一下HashSet的一个例子：

 

public class HashSetOverView {

	public static void main(String[] args) {
		HashSet hs = new HashSet();
		hs.add(new Person("abc0",20));
		hs.add(new Person("abc6",26));
		hs.add(new Person("abc1",21));
		hs.add(new Person("abc6",26));
		Iterator it = hs.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			System.out.println(p.getName()+"--"+p.getAge());
		}
		
//		System.out.println(hs.contains(new Person("abc6",26)));这样的话会调用equals方法，删掉相同的人。
	}
}

class Person 
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	
	public int hashCode()
	{
		System.out.println(this.name+"...hashCode");
		final int NUMBER = 49;
		return name.hashCode()+age*NUMBER;
	}
	
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			throw new ClassCastException("类型不匹配");
		Person p = (Person)obj;
		System.out.println(this.name+"  equals run  "+p.name);
		return this.name.equals(p.name) && this.age==p.age;
	}
	public String toString()
	{
		return name+"::"+age;
	}
}

 HashSetOverView类的main方法执行结果为：

abc0...hashCode

abc6...hashCode

abc1...hashCode

 

abc6...hashCode

abc6  equals run  abc6

 

abc0--20

abc1--21

 

abc6--26

 

下面在看一下TreeSet集合的一个例子是怎样保持元素有序与唯一性的

 

package cn.java.collection.set;

import java.util.TreeSet;

/*TreeSet的第一种比较方式，并用数据类型本身的比较方法。需要比较的元素实现compareble接口，并实现其compareTo方法*/
//年龄相等的情况下，用姓名排序
public class TreeSetDemo {
	
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();

		ts.add(new Student1("lisi0：",30));
		ts.add(new Student1("lisixx：",29));
		ts.add(new Student1("lisi9：",29));
		ts.add(new Student1("lisi8：",38));
		ts.add(new Student1("lisixx：",29));
		ts.add(new Student1("lisi4：",14));
		ts.add(new Student1("lisi7：",27));
		System.out.println(ts);

	}

}
//让元素自身具备比较性
class Student1 implements Comparable{
	private String name;
	private int age;
	Student1(String name,int age){
		this.name=name;
		this.age=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 int compareTo(Object o) {
		Student1 stu=(Student1)o;
		int num=new Integer(this.age).compareTo(new Integer(stu.age));
		return num==0?this.name.compareTo(stu.name):num;
		/*Student stu=(Student)o;
		if(this.age>stu.age)
		return 1;
		if(this.age==stu.age)
			return 0;
		return 1;*/
	}
	
	public String toString() {
		return name+this.age;
	}
}

 

上面TreeSetDemo的main方法执行的结果为：

[lisi4：14, lisi7：27, lisi9：29, lisixx：29, lisi0：30, lisi8：38]

此类里的compareTo方法既是可以决定排序关键，也是保证唯一性的关键 

 

TreeSet排序的第二种方式：

 

package cn.java.collection.set;

import java.util.Comparator;
import java.util.TreeSet;

/*
TreeSet:它可以给Set集合中的元素进行指定方式的排序。
		保证元素唯一性的方式：通过比较的结果是否为0.
		底层数据结构是：二叉树。

		排序的第一种方式：
			让元素自身具备比较性。只要让元素实现java.lang.Comparable接口，覆盖compareTo方法即可。
			
			但是，如果元素自身不具备比较性，或者元素自身具备的比较性，不是所需要的。
			比如，学生的自然排序是按年龄排序，现在想要按照学生姓名排序。还可以不改动原有代码。
			这时怎么办呢？
		排序的第二种方式：自定比较器的方式。
			这时可以让集合自身具备比较性。
			可以定义一个类实现java.util.Comparator接口，覆盖compare方法。将该Comparator接口子类对象作为实际参数
			传递给TreeSet集合构造函数。

			该对象就是比较器。
*/
public class TreeSetDemo3 {
	public static void main(String[] args) {
		TreeSet ts = new TreeSet(new StudentComparatorByName());

		ts.add(new Student1("lisi0：",30));
		ts.add(new Student1("lisixx：",29));
		ts.add(new Student1("lisi9：",29));
		ts.add(new Student1("lisi8：",38));
		ts.add(new Student1("lisixx：",29));
		ts.add(new Student1("lisi4：",14));
		//ts.add(new Student(39));
		ts.add(new Student1("lisi7：",27));

		System.out.println(ts);
	}

}


/*
 * 创建一个比较器，实现comparator
 */
class StudentComparatorByName implements Comparator<Student1>{

	@Override
	public int compare(Student1 s1, Student1 s2) {
		Student1 stu=(Student1)s1;
		Student1 stu2=(Student1)s2;
		int num=stu.getName().compareTo(stu2.getName());
		return num==0?new Integer(stu.getAge()).compareTo(new Integer(stu2.getAge())):num;
	}
}
//让元素自身具备比较性
class Student1 implements Comparable{
	private String name;
	private int age;

	Student1(String name,int age){
		this.name=name;
		this.age=age;
	}
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public int compareTo(Object o) {
		Student1 stu=(Student1)o;
		if(this.age>stu.age)
		return 1;
		if(this.age==stu.age)
			return 0;
		return 1;
	}
	
	@Override
	public String toString() {
		return this.getName()+this.age;
	}
}

 TreeSet排序的第二种方式执行结果为：

 

[lisi0：30, lisi4：14, lisi7：27, lisi8：38, lisi9：29, lisixx：29]