【JAVA】比较集合的大小

判断集合元素相等
集合判断相等的这个规范，不是说光针对HasSet,而是针对Collection的所子类。如果需要执行某种操作，需要判断对象是不是相等的时候，都靠的是规范来进行的。

我们一般不能拿等号来判断而是用equals。
还有一种方法，我们比较的则是集合元素的哈希码，且在集合中相同的值的哈希码是一样的。

而我们一般在判断的时候，两个都用来进行判断。我们要让集合能判断相等，就得要重写equals和HasSet方法。

在集合比较大小的集合的时候，我们要继承Comparable，放进去的对象就需要实现规范。

比较集合的大小
所有集合跟我们放进去的东西都有一个约定———Comparable
在刚开始我们没有继承Comparable接口的时候，我们的运行窗口会报类转换异常。那么，对于我们排序集来讲，就要有一个要求：

所有的集合如果有比较大小的需求，且要判断两个对象谁大谁小。这个规则只有我们自己知道，且这个规则的制定只取决于我们自己。排序规则就像我们重写HasCode方法，要事先约定好，而这个约定是用接口写的。接口里面有我们都需要的规范，所以接口的作用是隔离调用者和实现者的。当我们把对象加进去之后，该方法给我们把对象转换成了接口。

public class Student implements Comparable {

有关TreeSet的详解，转大神博客，请点击该链接。
https://blog.youkuaiyun.com/zhaojie181711/article/details/80494318

整体代码如下

import java.util.HashSet;
import java.util.Objects;

public class Student implements Comparable {
    public Student(int id, String name, char sex) {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    private int id;
    private String name;
    private char sex;

    public int hasCode() {
        return new Integer(id).hashCode() +
                name.hashCode() +
                new Character(sex).hashCode();
    }

//    public  boolean equals(Object obj){
//        if(obj instanceof  Student){
//            student s=(Student) obj;
//            if(s.id==this.id&&
//            /*s.name==this.name 因为字符串也是对象*/
//            //对象比较用equals
//            s.name.equals(this.name)&&
//            s.sex==this.sex){
//        }
//        return true;
//    }
//    return false;

    /**
     * Objects的工具类
     */
    //如果我们自己写的对象，
    //放到集合里，要让集合判断这两个对象相等，
    //一定要重写它的equals和HasCode。
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id &&
                sex == student.sex &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, sex);
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                '}';
    }

    /**
     * 升序排列
     *
     * @param o
     * @return
     */
    //返回1，是指我自己大于传进来的对象。
    //返回0，是指我自己和传进来的对象相等。
    //返回-1，是指我自己和传进来的对象相等。
    @Override
    public int compareTo(Object o) {
        if (o instanceof Student) {
            //这里就不用返回了，直接扔一个异常就行。
            //先把这个父类对象进行强制转换，
            //因为父类对象无法访问子类里的属性。
            Student s = (Student) o;
            if (this.id > s.id) {
                return 1;
            } else if (this.id < s.id) {
                return -1;
            }
            return 0;
        }
        throw new RuntimeException("类型不匹配，无法比较大小！");
    }

//    /**
//     * 降序排列
//     */
//    if(this.id >s.id){
//        return -1;
//    } else if(this.id<s.id){
//        return 1;
//    }
//    return 0;
//}
}

import java.util.Iterator;
import java.util.TreeSet;

public class Test2 {
    public static void main(String[] args) {
        TreeSet s=new TreeSet();
        s.add(20);
        s.add(22);
        s.add(19);
        s.add(11);
        Iterator iter=s.iterator();
        while(iter.hasNext()){
            System.out.println(iter.next());

            //升序排列
            s=new TreeSet();
            s.add(new Student(2000,"孙悟空",'m'));
            s.add(new Student(2001, "牛魔王", 'm'));
            s.add(new Student(1999, "紫霞", 'f'));
            iter=s.iterator();
            while(iter.hasNext()){
                System.out.println(iter.next());
            }
        }
    }
}