HashSet
无序（存入和取出的顺序不同），不重复，无索引
底层是哈希表结构，也称散列表结构，查找和删除快，添加慢
像HashSet中存储自定义对象需要重写hashCode（）和equals()方法
import java.util.HashSet;
import java.util.Iterator;

/** *  演示HashSet是如何保证元素的唯一性的 * @author WangShuang * */public class Demo {    public static void main(String[] args) {        Person p = new Person("张三","男");        Person p1 = new Person("张三","男");        HashSet<Person> hashSet=new HashSet<Person>();        hashSet.add(p);        hashSet.add(p1);        Iterator<Person> iterator = hashSet.iterator();        while(iterator.hasNext()){            Person next = iterator.next();            System.out.println(next);        }    }}class Person{    private String name;    private String sex;    public Person(String name, String sex) {        this.name = name;        this.sex = sex;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getSex() {        return sex;    }    public void setSex(String sex) {        this.sex = sex;    }    @Override    public int hashCode() {        return name.hashCode()+sex.hashCode() ;    }    @Override    public boolean equals(Object obj) {        if(!(obj instanceof Person)){            return false;        }        Person p = (Person)obj;        return this.name.equals(p.name)&& this.sex.equals(p.sex);    }    @Override    public String toString() {        return "Person [name=" + name + ", sex=" + sex + "]";    }}

HashSet在存元素时，会调用对象的hashCode方法计算出存储位置，然后和该位置上所有的元素进行equals比较，

如果该位置没有其他元素或者比较的结果都为false就存进去，否则就不存。

这样的原理注定了元素是按照哈希值来找存储位置，所有无序，而且可以保证无重复元素

我们在往HashSet集合存储元素时，对象应该正确重写Object类的hashCode和equals方法

正因为这样的原理，HashSet集合是非常高效的。

比如，要查找集合中是否包含某个对象，首先计算对象的hashCode，折算出位置号，到该位置上去找就可以了，而不用和所有的元素都比较一遍

TreeSet
可以对set集合中的元素进行排序，默认按照asic码表的自然顺序排序
之所以treeset能排序是因为底层是二叉树，数据越多越慢,TreeSet是依靠TreeMap来实现的
像TreeSet中存储自定义对象需要实现comparable接口

import java.util.Iterator;import java.util.TreeSet;/** *  让人根据年龄排序，如果年龄一样根据姓名的自然顺序排序 * @author WangShuang * */public class Demo {    public static void main(String[] args) {        Person p0 = new Person("张三",3);        Person p = new Person("张三",1);        Person p1 = new Person("张三",2);        Person p2 = new Person("张四",2);        Person p3 = new Person("张四",2);        TreeSet<Person> treeSet=new TreeSet<Person>();        treeSet.add(p0);        treeSet.add(p);        treeSet.add(p1);        treeSet.add(p2);        treeSet.add(p3);        Iterator<Person> iterator = treeSet.iterator();        while(iterator.hasNext()){            Person next = iterator.next();            System.out.println(next);        }    }}class Person implements Comparable<Person>{//该接口强制让人具有比较性    private String name;    private int age;    public 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;    }    @Override    public int compareTo(Person o) {        if(this.age>o.age){            return 1;        }else if(this.age<o.age){            return -1;        }else{            return this.name.compareTo(o.name);        }    }    @Override    public String toString() {        return "Person [name=" + name +  ", age=" + age + "]";    }}

首先把p0("张三，3）存到根部，
然后p("张三",1)调用compareTo()方法和p0("张三，3）比较年龄，小的放在右边，
然后p1（“张三”，2）调用，调用compareTo()方法和p0("张三，3）比较年龄，小的放在右边，因为右边有p("张三",1)，在调用ompareTo()方法和p("张三",1)，大的放在左边，
然后p2("张四"，2）调用compareTo()方法和p0("张三，3）比较年龄，小的放在右边，因为右边有p("张三",1)，在调用ompareTo()方法和p("张三",1)，大的放在左边，因为左边有p1（“张三”，2），调用ompareTo()方法和p1（“张三”，2），年龄一样，比较姓名，大的放在左边，
然后p3("张四"，2）调用compareTo()方法和p0("张三，3）比较年龄，小的放在右边，因为右边有p("张三",1)，在调用ompareTo()方法和p("张三",1)，大的放在左边，因为左边有p1（“张三”，2），调用ompareTo()方法和p1（“张三”，2），年龄一样，比较姓名，大的放在左边，因为左边有p2("张四",2），调用ompareTo()方法和p2（“张四”，2），姓名一样，年龄一样，去除重复