JAVA学习 集合框架Set

Set实现的超级父类接口：Collection

Set :元素是无序的，元素不可以重复

常见子类：1.HashSet

                 2.TreeSet

HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。 是线程不同步的，底层数据结构是哈希表。

HashSet是如何保证元素唯一性的呢？
    是通过元素的两个方法，hasCode和equals来完成的
    如果元素的hashCode值相同，才会判断equals是否为true。
    如果元素的hashCode值不同，不会调用equals

    注意，对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法，而List只依赖equals方法

import java.util.*;
public class SetDemo {
	public static void main(String[] args) {
		HashSet hs=new HashSet();
		hs.add(new Person("lisi03",23));
		hs.add(new Person("lisi007",25));
		hs.add(new Person("lisi01",22));
		hs.add(new Person("lisi01",22));
		
		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;
	}
	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 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));
	}
	
	//通过重写hashCode函数来解决出现相同元素问题
	public int hashCode(){
		//System.out.println(name+"....");
		return (name.hashCode()+age*37);
	}
	
}

TreeSet：可以对Set集合中的元素进行排序。  

    底层数据结构是二叉树
    保证元素唯一性的依据：compareTo方法return 0；
    TreeSet排序的第一种方式，让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法，
    这中方式也成为元素的自然顺序，或者叫做默认顺序。 
    TreeSet排序的第二中方式，当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较      性。
    在集合初始化时，就有了比较方式。
    定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
 
    当两中排序都存在时，以比较器为主。

    定义一个类，实现Comparator接口，覆盖compare方法

package Test;

import java.util.*;

public class practice{
	public static void main(String [] args){
		TreeSet  ts=new TreeSet(new Namecompare());
		ts.add(new Person(3,"kb"));
		ts.add(new Person(1,"kewenjie"));
		ts.add(new Person(4,"html"));
		ts.add(new Person(2,"wjk"));
		ts.add(new Person(2,"kwj"));
		
		Iterator  it=ts.iterator();
		while(it.hasNext()){
			Person ps=it.next();
			System.out.println(ps.getAge()+"...."+ps.getName());
		}
	}
}

class Person implements Comparable{
	private int age;
	private String name;
	public Person(int id,String name){
		this.name=name;
		this.age=id;
	}
	public int getAge() {
		return age;
	}
	public void setId(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int compareTo(Object o){	 //覆盖compareTo方法，实现按年龄顺序排列，如果年龄相同，则按照姓名的自然顺序排列
		if(!(o instanceof Person)){
			throw new RuntimeException("不是Person对象");
		}
		Person ps=(Person)o;
		int n=this.age-ps.age;
		if(n==0){
			return this.getName().compareTo(ps.getName());
		}
		return n;
	}
}

class Namecompare implements Comparator{ //定义比较器，实现按照姓名的自然顺序排列，如果年龄相同，则实现按年龄顺序排列。
	public int compare(Object o1,Object o2){
		Person ps1=(Person)o1;
		Person ps2=(Person)o2;
		int n=ps1.getName().compareTo(ps2.getName());
		if(n==0){
			return ps1.getAge()-ps2.getAge();
		}
		return n;
	}
}

由于Person类不具备比较性，所以需要实现Comparable接口，并覆盖compareTo方法，或者定义比较器。