Set接口下的三个实用类

HashSet类

HashSet集合底层是HashMap结构，HashMap底层是一个哈希散列表数据结构。
哈希表底层其实就是一个数组，只不过数组不像以前一样存放单个元素，而是数组每个元素是一条单向链表，每个单向链表都有一个独一无二的Hash值，代表数组的下标。在某个单向链表中的每个节点上的Hash值是相等的，hash值实际上是key调用的HashCode方法，在通过哈希算法转换成相应的值。
如何向哈希表中添加元素呢，或者说元素是通过怎样的判断被添加到链表中呢？
	首先添加元素时，会先调用key的HashCode方法，通过其返回的哈西码值，如果这个哈希表中不存在这个哈西码值，则直接将该元素添加，如果存在这个哈西码值，那么会调用equals方法判断该元素是否与某条链表的元素相同，如果返回值为false，则说明哈希表中没有该元素，就会添加该元素，返回值为true，放弃添加该元素。
我们可以通过重写HashCode方法与equals方法，让哈希表对元素的分类添加按照我们的要求来。
HashSet与HashMap初始化容量都是16，默认加载因子是0.75（当元素占总容量的75%时就会自动扩容!

 //入口
    public static void main(String[] args) {
        Set h1=new HashSet();
        //无序不可重复
        h1.add(1);
        h1.add("aa");
        h1.add(1);
        //遍历
        Iterator i=h1.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }
        //关于往Set集合中存储的元素，该元素的hashCode方法与equals方法
        /*
            结论：存储在HashSet集合或者HashMap集合key部分的元素，需要同时重写hashCode与equals方法
         */
        //创建集合
        Set es=new HashSet();
        Employee e1=new Employee("1000","jack");
        Employee e2=new Employee("1000","jack");
        Employee e3=new Employee("3001","Scott");
        Employee e4=new Employee("4002","Clearlove");
        Employee e5=new Employee("5000","Faker");
        //因为再添加的过程中，e1与e2存储的员工编号与名字是相同的，按照业务逻辑，不应该被加入到集合当中，但是因为两个对象的不同，其哈希码就不同，所以会被添加，要重写hashCode方法
        System.out.println(e1.hashCode());
        System.out.println(e2.hashCode());
        //添加元素
        es.add(e1);
        es.add(e2);
        es.add(e3);
        es.add(e4);
        es.add(e5);
        //查看集合元素个数
        System.out.println(es.size());

    }
}
//根据现实的业务逻辑得知：该公司员工编号是：1000-9999
class   Employee{
    //编号
    String no;
    //姓名
    String name;
    //Constructor
    public Employee(String no, String name) {
        this.no = no;
        this.name = name;
    }
    //重写hashCode方法

    @Override
    //重写equals方法
    //如果员工编号相同，并且名字相同，则是同一个对象
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee e= (Employee) o;
        if(e.no.equals(this.no)&&e.name.equals(this.name)){
            return true;
        }
        return false;
    }

    @Override
    //重写hashCode方法
    public int hashCode() {
        //以员工编号分组
        return no.hashCode();
    }
}

LinkedHashSet类

LinkedHashSet类是HashSet类的子类，但是其数据结构与HashSet还是有区别的。
LinkedHashSet底层是有一个链表与一个哈希表，这个链表定义了迭代顺序，该顺序可以是插入的顺序或者是访问的顺序。
我们都清楚Set集合的特点：元素无序不可重复。无序性指的是我们添加元素时可能和取出集合元素的顺序不同。
但是这个集合就实现了有序。

 public static void main(String[] args) {
        HashSet s1=new HashSet();
        s1.add("a");
        s1.add(10);
        s1.add(5);
        s1.add("c");
        s1.add(2.0);
        s1.add("f");
        System.out.println(s1); //[2.0, a, c, 5, f, 10]
        System.out.println("==========");
        //按照什么顺序添加的，集合也就按照什么顺序排列
        HashSet s2=new LinkedHashSet();
        s2.add("a");
        s2.add(10);
        s2.add(5);
        s2.add("c");
        s2.add(2.0);
        s2.add("f");
        System.out.println(s2);//[a, 10, 5, c, 2.0, f]
    }

TreeSet类

TreeSet类实现了SortedSet接口，特点还是无序不可重复，但是存进去的元素可以按照元素大小顺序自动排列。
它的底层是SortedMap类。

 public static void main(String[] args) throws ParseException {
        //创建集合
        SortedSet ss=new TreeSet();
        //添加元素
        ss.add(15);//自动装箱，因为集合只能存储引用类型，所以，他会把基本类型转换为引用类型存储
        ss.add(20);
        ss.add(12);
        ss.add(1);
        //遍历集合
        Iterator it=ss.iterator();
        while (it.hasNext()){
            Object element=(Object)it.next();
            System.out.println(element);
        }
        /*
            1
            12
            15
            20
         */
        SortedSet ss1=new TreeSet();
        //添加日期元素
        String t1="2008-10-20";
        String t2="2000-05-8";
        SimpleDateFormat p=new SimpleDateFormat("yyyy-MM-dd");
        Date d1=p.parse(t1);
        Date d2=p.parse(t2);
        ss1.add(d1);
        ss1.add(d2);
        //遍历集合
        it=ss1.iterator();
        while (it.hasNext()){
            Object element=it.next();
            if (element instanceof Date){
                Date d=(Date)element;
                System.out.println(p.format(d));
            }
            /*
                2000-05-08
                2008-10-20
             */
        }
    }

我们已知它的底层是SortedMap结构，那它是如何实现排序的呢？

//录入学生成绩信息，并且将学生成绩按照大小排序将学生信息输出。
 public static void main(String[] args) {
        SortedSet<Students> stu=new TreeSet<>();
        System.out.println("请输入你要录入学生信息总数：");
        Scanner sc=new Scanner(System.in);
        Scanner sc1=new Scanner(System.in);
        int num=sc.nextInt();
        for (int i = 0; i <num; i++) {
            System.out.println("请输入学生姓名：");
            String stuName=sc.next();
            System.out.println("请输入学生总分：");
            float stuScore=sc1.nextInt();
            Students s=new Students(stuName,stuScore);
            stu.add(s);
        }
        for (Students s:stu) {
            System.out.println(s);
        }
    }
}
class Students{
    private String name;
    private float score;
    public Students (String name,float score){
        this.name=name;
        this.score=score;
    }

    @Override
    public String toString() {
        return "学生姓名：" + name  + " 学生成绩：" + score ;
    }
    public float getScore(){
        return score;
    }
}

当我们使用将自定义对象存储到TreeSet集合中会出现一个异常：java.lang.ClassCastException: class Students cannot be cast to class java.lang.Comparable
叫做类型转换异常：学生类型不能被转换成可比较的类型。
那么为什么那些基本类型可以进行排序，自定义的数据类型就不可以？
	实际上基本类型底层实现了Comparable接口或者编写了一个Comparator比较器，用来比较元素进行排序。那我们如果要想自定义对象也进行排序，就有两种方法，一是学生类实现Comparable接口，二是单独编写一个比较器类实现Comparator接口，然后在创建TreeSet集合将比较器传入就行。
对于这两个方法我们只要取其一就可以，但是一般情况选择编写选择器比较好，因为程序设计原则就是面向接口，降低类与类之间的耦合度，编写比较器可以降低测试类与用户类的耦合度，所以优先选择。
实现接口，我们就要实现接口中的方法，虽然两个接口实现的方法不同，但是其思想是一样的。

class stuComparator implements Comparator{
	//用两个学生的成绩进行相减比较返回整形值
	

    @Override
    public int compare(Object o, Object t1) {
        int num1= (int) (((Students)o).getScore()-((Students)t1).getScore());
       return num;
    }
}

这就是实现了Comparator接口的比较器，它底层采用了二叉树的思想进行排序，两个元素进行相减比较，然后返回一个整形的值，底层会用返回的整形值进行判断，当返回值为0的时候那就表明这两个值是相等的，返回值大于0，就将它往二叉树的元素右边排，返回值小于0，往左边排，这样就实现了元素的排序。
那么这下我们将比较器传入，就能排好序啦！

public static void main(String[] args) {
        SortedSet<Students> stu=new TreeSet<>(new stuComparator());//传入比较器
        System.out.println("请输入你要录入学生信息总数：");
        Scanner sc=new Scanner(System.in);
        Scanner sc1=new Scanner(System.in);
        int num=sc.nextInt();
        for (int i = 0; i <num; i++) {
            System.out.println("请输入学生姓名：");
            String stuName=sc.next();
            System.out.println("请输入学生总分：");
            float stuScore=sc1.nextInt();
            Students s=new Students(stuName,stuScore);
            stu.add(s);
        }
        for (Students s:stu) {
            System.out.println(s);
        }
        /*
        学生姓名：aa 学生成绩：500.0
        学生姓名：cc 学生成绩：400.0
        学生姓名：bb 学生成绩：300.0
         */
    }