Java集合框架3——HashSet、TreeSet

|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复，并且Set具有与Collection完全一样的接口，没有任何额外的功能，主要作用是查找元素，基于对象的值来确定归属性

    |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
	HashSet通过hashCode()和equals()两个方法保证了元素的唯一性。
	如果元素的hashcode值不同，直接存入，不会调用equals。
	如果元素的HashCode值相同，才会判断equals是否为true。

Demo1：HashSet简单使用

class HashSetDemo {
	public static void main(String[] args) {
		
		HashSet hs = new HashSet();

		hs.add("java01");
		hs.add("java01");
		hs.add("java02");
		hs.add("java03");
		hs.add("java03");
		hs.add("java04");

		Iterator it = hs.iterator();

		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
}
/*输出：
	java04
	java02
	java03
	java01
 */

重复元素没有存进去，并且取出时是无序的。

Demo2：HashSet存自定义元素

/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。
*/
class HashSetTest {
	public static void main(String[] args) {
		HashSet hs = new HashSet();

		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a2",12));
		hs.add(new Person("a4",14));
		
		System.out.println();
		//判断a2是否在集合里
		System.out.println("a2:"+hs.contains(new Person("a2",12)));
		
		System.out.println();
		//移除a4
		hs.remove(new Person("a4",14));
		
		System.out.println();
		Iterator it = hs.iterator();

		while(it.hasNext()) {
			Person p = (Person)it.next();
			System.out.println(p.getName()+"::"+p.getAge());
		}
	}
}
class Person{
	private String name;
	private int age;
	Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	//重写hashCode方法
	public int hashCode() {
		System.out.println(this.name+"....hashCode");
		return name.hashCode()+age;	//返回姓名的哈希值加年龄
	}
	//重写equals方法
	public boolean equals(Object obj) {

		if(!(obj instanceof Person))
			return false;

		Person p = (Person)obj;
		System.out.println(this.name+"...equals.."+p.name);
		//姓名年龄都相等才相等
		return this.name.equals(p.name) && this.age == p.age;
	}

	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
}
/*
输出：
a1....hashCode		//a1取得哈希值
a2....hashCode		//a2取得哈希值
a3....hashCode		//a3取得哈希值
a2....hashCode		//另外一个a2也取的哈希值
a2...equals..a2		//因为这个a2和前面的a2哈希值重复了，所以调用equals方法
a4....hashCode		//a4取得哈希值

a2....hashCode		//先取的哈希值
a2...equals..a2		//哈希值一样，调用equals
a2:true				//equals也一样，返回true

a4....hashCode		//移除的时候判断也一样，先哈希值再equals
a4...equals..a4

a1::11		//a4被移除掉，最终只剩下三个
a2::12
a3::13
 */

	|--TreeSet：可以对Set集合中的元素进行排序。底层数据结构是二叉树。根据compareTo方法return 0来确保元素的唯一性。对于Integer默认升序排序，对于String默认字典顺序排序，对于自定义类型，存储的时候会出现异常，需要我们自己实现排序方法
	TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。
	TreeSet的第二种排序方式。当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。我们需要定义一个比较器（定义一个类，实现Comparator接口，覆盖compare方法），将比较器对象作为参数传递给TreeSet集合的构造函数。
	当两种排序都存在时，以比较器为主。

Demo3：TreeSet简单使用

class  TreeSetTest
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();
		TreeSet ts2 = new TreeSet();
		
		ts.add("abcd");
		ts.add("cc");
		ts.add("aaa");
		ts.add("z");
		ts.add("hahaha");
		
		ts2.add(100);
		ts2.add(55);
		ts2.add(432);
		ts2.add(-1);
		
		Iterator it = ts.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		
		System.out.println();
		Iterator it2 = ts2.iterator();
		while(it2.hasNext()){
			System.out.println(it2.next());
		}
	}
}
/*
输出：
aaa
abcd
cc
hahaha
z

-1
55
100
432
 */

Demo4：实现Comparable接口，先按学生年龄升序排序，如果相同再按姓名字典顺序排序

class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();

		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi07",20));
		ts.add(new Student("lisi04",19));
		ts.add(new Student("lisi08",19));

		Iterator it = ts.iterator();
		while(it.hasNext()) {
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}

//让学生这个类实现Comparable接口，使学生本身具备比较性
class Student implements Comparable {
	private String name;
	private int age;

	Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public int compareTo(Object obj){
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		if(this.age>s.age)
			return 1;
		//如果年龄一样，再比较姓名，按姓名的字典顺序来排列
		if(this.age==s.age){
			return this.name.compareTo(s.name);
		}
		return -1;
	}

	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
}
/*
输出：
lisi04...19
lisi08...19
lisi07...20
lisi02...22
 */

TreeSet有一个构造函数，可以传入一个比较器comparator

TreeSet(Comparator<? superE> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。

而comparator是一个接口，里面有一个compara方法，需要我们自己实现

int	compare(T o1,T o2) 比较用来排序的两个参数。

Demo5：实现Comparator接口，先按学生姓名进行排序，如果相同按照年龄升序排序

class TreeSetDemo2 {
	public static void main(String[] args) {
		TreeSet ts = new TreeSet(new MyCompare());

		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi02",21));
		ts.add(new Student("lisi00",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi00",29));

		Iterator it = ts.iterator();
		while(it.hasNext()) {
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}
//自定义一个类实现comparator接口
class MyCompare implements Comparator {
	public int compare(Object o1,Object o2) {
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;

		int num = s1.getName().compareTo(s2.getName());
		if(num==0) {
			if(s1.getAge()>s2.getAge())
				return 1;
			if(s1.getAge()==s2.getAge())
				return 0;
			return -1;
		}
		return num;
	}
}