TreeSet（Comparable和Comparator）和HashSet

TreeSet----底层基于红黑树

有序存储
不允许元素重复，并且按照元素升序排序，不允许存放null
自定义类要想保存到TreeSet中，
要么实现Comparable接口，要么向TreeSet传入比较器(Compartor接口)

实现了Comparable接口的类可以直接存放在TreeSet或TreeMap中。

public int compareTo(T o);
返回值三种情况：
返回正数：表示当前对象大于目标对象
返回0：表示当前对象等于目标对象
返回负数：表示当前对象小于目标对象

实现Comparable接口
class Person implements Comparable<Person>
{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person o) {
        if(this.age>o.age)
            return 1;  //那么是升序
        else if(this.age<o.age)
            return -1;
         return this.name.compareTo(o.name);  //String类有自己的compareTo方法
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Comparator1 {
    public static void main(String[] args) {
        Set<Person> set=new TreeSet<>();
        Person p1=new Person("pick",20);
        Person p2=new Person("bai",28);
        set.add(p1);
        set.add(p2);
        System.out.println(set);
    }
}

Comparator(外部排序接口）
若要控制某个自定义类的顺序，而该类本身不支持排序（该类本身没有实现Comparable接口）。我们可以建立一个该类的比较器来进行排序。比较器实现Comparator接口即可。
“比较器”：实现了Comparator接口的类作为比较器，通过该比较器来进行类的排序。
int compare(T o1,T o2); ----因为在类外进行比较，有2个参数
返回值三种情况：
返回正数：表示o1大于o2
返回0：表示01等于o2
返回负数：表示o1小于o2

升序，小的排在前面，Comparator两个抽象方法，但只需要实现compare方法，equals方法object类实现
升序：return o1.getAge()- o2.getAge() , 返回值大于0，说明o1大，把o1放在o2后 o1> o2 return 1
降序：return o2.getAge()- o1.getAge() , o1>o2 return -1

jdk默认是升序，是基于:
小于 return -1
等于 return 0
大于 return 1

降序：
小于 return 1
等于 return 0
大于 return -1

//利用比较器
class Person2
{
    private String name;
    private int age;

    public Person2(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

//升序排
//jdk默认是升序，是基于:
//<    return -1
// =   return 0
// >  return 1
class AscSort implements Comparator<Person2>
{
    @Override
    public int compare(Person2 o1, Person2 o2) {
        if(o1.getAge()>o2.getAge())
            return 1;
        else if(o1.getAge()==o2.getAge())
            return 0;
        return -1;
    }
}

//降序排
//降序：<  return 1
//    = return 0
//   > return -1
class DescSort implements Comparator<Person2>
{
    @Override
    public int compare(Person2 o1, Person2 o2) {
        if(o1.getAge()>o2.getAge())
            return -1;
        else if(o1.getAge()==o2.getAge())
            return 0;
        return 1;
    }
}
public class Comparator1 {
    public static void main(String[] args) {
        Set<Person2> set=new TreeSet<>(new DescSort());  //降序排
        Person2 p1=new Person2("pick",20);
        Person2 p2=new Person2("bai",28);
        set.add(p1);
        set.add(p2);
        System.out.println(set); //[Person{name='bai', age=28}, Person{name='pick', age=20}]
    }
}

Comparable接口与Compartor接口区别：
1.在Java中，若想实现自定义类的比较，提供了以下两个接口
java.lang.Comparable接口（内部比较器）—排序接口：
若一个类实现了Comparable接口，即自己排序，就意味着该类支持排序
存放该类的Conllection或数组，可以直接通过Collections.sort()或Arrays.sort进行排序
2.Comparator接口是比较器接口，类本身不支持排序，专门有若干个第三方的比较器（实现了Comparator接口的类）来进行类的排序，是一个外部比较器（策略模式）
使用Comparator更加灵活，只需要根据不同的需求用不同类实现Comparator,不影响比较的类

重复元素的判断：
TreeSet和TreeMap依靠Comparator或Comparable接口来区分重复元素（返回值=0即是重复）

自定义类要保存在TreeSet或TreeMap中：
1.要么该类直接实现Comparable接口，覆写compareTo方法
2.或者实现一个比较器传入TreeSet或TreeMap来进行外部比较

而HashSet与HashMap并不依赖比较接口。此时要想区分自定义元素是否重复，需要同时覆写equals与hashCode方法。

若两个对象的equals方法返回true,他们的hashCode必然要保证相等。但是两个对象的hashCode相等，equals不一定相等。
当且仅当equals与hashCode方法均返回true,才认为两个对象真正相等

HashSet和HashMap判断元素是否重复：
先调用hashCode计算出对象hash码决定存放的数据桶
而后使用quals来比较元素是否相等，若相等，则不再放置元素，若equals返回false，则在相同桶之后，使用链表将若干元素链起来。
object类提供的hashCode方法默认使用对象的地址进行hash

//覆写hashCode
public int hashCode()
{
    return Objects.hash(age,name);  Objects:所有类父类提供的若干方法 
     //当两个元素的属性相等，则一定放在同一个桶中
}

Set接口是Value值相同的Map集合，先有Map才有Set
TreeSet是TreeMap
TreeMap区分key值重复，需要实现Comparable或实现一个比较器
HashSet是HashMap
HashMap区分key值重复，需要实现equals和HashCode方法

TreeSet（Comparable和Comparator）和HashSet

猜你喜欢