Day20比较器、set、map、散列

Set和排序

特点:无序,不可重复,添加顺序跟取出顺序不一定一致

Set->SortedSort->TreeSet:底层是红黑树,要添加的元素必须按照某个规则进行排序

TreeSet

数字默认升序,字符串默认比较Ascii码值,时间默认自然日期(昨天,今天,明天,后天)

 

 

 

 

 

 树

二叉查找树

类似于二分法查找,查询效率比较高

左叶子 用于小于根节点的值

右叶子 永远大于根节点的值

这种方式是二分查找的思想,查询所需要的最大次数,等同于二叉树的高度

在添加数据的时候,也是类似的方式,一层层找,一直找到适合新节点的位置

但是二叉查找树也有问题

比如 一直添加比根节点小的或者大的数据

这样的话,虽然符合二叉查找树特性,但是性能大打折扣,几乎变成了线性的

红黑树

为了解决二叉查找树多次插入新节点而导致的不平衡,红黑树就诞生了

完全符合二叉查找的特性

1 节点是红色或者黑色

2 根节点一定是黑色

3 每个子节点都是黑色的空节点

4 每个红节点的两个子节点都是黑色(从每个叶子到根节点的路径上不能有连续两个的红色节点)

5 从任何节点到其每一个子节点都有相同数量的黑色节点

左旋转 : 逆时针旋转,父节点被右节点取代,而自己成为左节点

右旋转 : 顺时针旋转,父节点被左节点取代,而自己成为右节点

右边黑色数量多,就左旋转

左边黑色数量多,就右旋转

排序

比较器：1、java.lang.Comparable 接口 并实现compareTo方法
              2、java.util.Comparator 比较器类
 Comparable

public class Collection_2 {
public static void main(String[] args) {
    // java.lang.ClassCastException: day_02.User cannot be cast to java.lang.Comparable
    //treeMap并不知道该如何put，就会报这个异常错误。第一次put时，因为为空，所以不需要比较，即不会报错。但是当第二次put时，treeMap为了确保他是有序的就必须比较
    //这个时候发现这两个key根本无法比较，则抛出该异常错误。
    TreeSet treeSet = new TreeSet();
    treeSet.add(new User(11));
    treeSet.add(new User(13));
    treeSet.add(new User(10));
    System.out.println(treeSet);
    
    }
}
class User implements Comparable{
    int age;
    
    public User(int age) {
        this.age = age;
    }
    

    @Override
    public String toString() {
        return "User [age=" + age + "]";
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Object o) {
        //this是要添加的元素，o是集合中的每一个元素
        //返回值为0，相等不添加
        //返回小于0的，说明要添加的元素比集合中的元素小，放前面
        //返回大于0的，说明要添加的元素比集合中的元素大，放后面
        if (o instanceof User) {
            User user = (User)o;
            //升序
            //return this.age - user.age;
            //降序
            return user.age - this.age;
        }
        return -1;
    }
    
}

 Comparator

import java.util.Comparator;
import java.util.TreeSet;

/* 应用场景
 *
 * 比如我们现在要保存 数字 , 并且是降序排序
 *
 * 而 Integer中 默认是升序,我们没有办法更改他的源码,所以可以使用Comparator解决该问题
 * 通过treeMap源码发现,Comparator优先级 大于 Comparable
 * 所以 我们可以利用Comparator的优先级,来自定义排序规则
 * 我们自定义类型 需要排序,优先使用Comparable来实现,这样 如果不能满足别人的需求,还可以通过comparator对排序进行扩展
 * 我们操作的是别人定义的类型的话,都需要使用comparator进行扩展,因为改不了人家源码
 *             1 本来有排序,比如Integer,默认升序,但是不能满足我们的排序需求,此时需要使用comparator进行扩展
 *             2 不支持排序,也就是说该类型没有实现comparable接口,不能排序.但是此时我们需要排序,也可以通过comparator进行扩展
 *             3 总之 其他类型.无法满足我们的排序规则的时候,都可以使用comparator进行扩展排序
 *
 */
public class Collection_3 {
    public static void main(String[] args) {
        //lnteger
        // TreeSet treeSet = new TreeSet(new ScorTest());
        //匿名内部类
        TreeSet treeSet = new TreeSet( new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // o1是要添加的元素,o2是集合中的元素
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                // i1-i2是升序, i2-i1是降序
                return i2 - i1;
            }
        } );
        treeSet.add(22);
        treeSet.add(1);
        treeSet.add(41);
        treeSet.add(21);
        System.out.println(treeSet);
    }
}

Collections

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/*list要想排序，元素必须实现comparable接口
 * 如果元素自身没有实现comparable接口，是不能调用sort方法
 * 非要比较，可以使用comparator进行比较，那么sort方法有一个重载。
 * 接收comparator
 */
public class Collection_ListSort {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(2);
        arrayList.add(21);
        arrayList.add(12);
        arrayList.add(4);

        // Collections.sort(arrayList);
        Collections.sort(arrayList, new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        System.out.println(arrayList);
    }
}

 总结

如果 添加的元素 是我们写的,那么我们应该使用comparable进行排序,因为对扩展开放,当满足不了别人需求的时候,人家还可以使用comparator进行扩展

如果 添加的元素 不是我们写的,是别人写的,那么我们肯定不能更改人家的源码

此时我们可以通过comparator进行重新排序

因为comparator和comparable同时存在的时候,comparator优先级要高

HashSet

import java.util.HashSet;

/*散列表：数组中保存的链表
 * HasgSet底层就是HashMap的key部分，屏蔽了HashMap的value
 * HashMa底层是散列表
 * 添加过程：
 * 1、根据key生成hash值（hashCode方法）
 * 2、根据生成hash值，通过hash算法得到数组下标
 *   i=(n-1)&hash
 *  3、调用key的equals方法，和数组中对应的链表的每一个节点进行比较
 *  4、如果不存在，就添加进去，如果存在，就不添加
 *  5、java8开始，引入红黑树，如果链表个数 大于等于9
 *  就把链表转型为红黑树 从而加速查询效率
 *  
 *  覆写equals要注意：
 * 需要使用 hashCode和equals共同表示对象
 *
 */
public class Collection_HashSet {
    public static void main(String[] args) {
        HashSet set =new HashSet();
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("e");
        System.out.println(set);
        // set.remove(o)
        for (Object object : set) {
            System.out.println(object);
        }
    }

}