Java基础-TreeSet与Java自定义类型的排序

演示TreeSet对String是可排序的

1.TreeMap集合底层实际上是一个TreeMap
2.TreeMap集合底层是一个二叉树
3.放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了
4.TreeSet集合中的元素，无序不可重复，但是可以按照元素的大小顺序自动排序
称为：可排序集合
例如：编写程序从数据库中取出数据，在页面展示用户信息的时候按照生日升序或者降序，
这个时候可以使用TreeSet集合，因为TreeSet集合放进去，拿出来就是有序的。

//创建一个TreeSet集合
  TreeSet<String> ts=new TreeSet<>();
  //添加String
ts.add("zhangsan");
ts.add("lisi");
ts.add("wangwu");
ts.add("zhangsi");
ts.add("wangliu");
for(String s:ts){
     
      //按照字典顺序排序
      System.out.print(s+" ");
  }
  TreeSet<Integer> ts2=new TreeSet<>();
ts2.add(100);
ts2.add(200);
ts2.add(900);
ts2.add(800);  
ts2.add(600);
ts2.add(10);
for(Integer i:ts2){
     
      //按照升序排序
      System.out.print(i+" ");
}

TreeSet无法对自定义类型进行排序

TreeSet可以对自定义类型进行排序？
以下程序中，对于Person类来说，无法排序，因为没有指定Person对象之间的比较规则。谁大谁小并没有说明。

public class TreeSetTest02 {
     
    public static void main(String[] args) {
     
        Person p1=new Person(50);
        Person p2=new Person(10);
        Person p3=new Person(20);
        Person p4=new Person(60);
        Person p5=new Person(40);
        Person p6=new Person(30);
        TreeSet<Person> persons=new TreeSet<>();
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);
        persons.add(p5);
        persons.add(p6);
        for(Person p:persons){
     
            System.out.println(p);
        }
    }
}
class Person{
     
    int age;
    public Person(int age){
     
        this.age=age;
    }
    @Override
    public String toString() {
     
        return "Person [age=" + age + "]";
    }
}

Exception in thread "main" java.lang.ClassCastException: testCollection.Person cannot be cast to java.lang.Comparable

出现这个错误的原因是
Person类没有实现java.lang,Comparable接口

//放在TreeSet集合中的元素需要实现java.lang.Comparable接口
//并且实现compareTo方法，equals可以不写

  public class TreeSetTest04 {
     
        public static void main(String[] args) {
     
            Customer p1=new Customer(50);
            Customer p2=new Customer(10);
            Customer p3=new Customer(20);
            Customer p4=new Customer(60);
            Customer p5=new Customer(40);
            Customer p6=new Customer(30);
            TreeSet<Customer> customers=new TreeSet<>();
            customers.add(p1);
            customers.add(p2);
            customers.add(p3);
            customers.add(p4);
            customers.add(p5);
            customers.add(p6);
            for(Customer p:customers){
     
                System.out.println(p);
            }
        }
    }
    //放在TreeSet集合中的元素需要实现java.lang.Comparable接口
//并且实现compareTo方法，equals可以不写
    class Customer implements Comparable<Customer>{
     
        int age;
        public Customer(int age){
     
            this.age=age;
        }
        @Override
        public String toString() {
     
            return "Customer [age=" + age + "]";
        }
        //需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较。
        //k.compareTo(t.key)
        //拿着参数k和集合中的每个k进行比较，返回值可能是>0,<0,=0
        //比较规则最终还是程序员实现的：例如按照年龄升序，或者按照年龄降序
        @Override
        public int compareTo(Customer c) {
         //c1.compareTo(c2)
// TODO Auto-generated method stub
            //this是c1
            //c是c2
            //c1和c2进行比较的时候，就是this和c比较
//    int age1=this.age;
//    int age2=c.age;
//    if(age1==age2){
     
//       return 0;
//    }else if(age1>age2){
     
//       return 1;
//    }else{
     
//       return -1;
//    }
            return this.age-c.age;    //>,<,=
        }

    }

//需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较。
//k.compareTo(t.key)
//拿着参数k和集合中的每个k进行比较，返回值可能是>0,<0,=0
//比较规则最终还是程序员实现的：例如按照年龄升序，或者按照年龄降序

比较规则怎么写

先按照年龄升序，如果年龄一样的再按照姓名升序

public class TreeSetTest05 {
     
    public static void main(String[] args) {
     
        TreeSet<Vip> vips=new TreeSet<>();
        vips.add(new Vip("zhangsi",20));
        vips.add(new Vip("zhangsan",20));
        vips.add(new Vip("king",18));
        vips.add(new Vip("soft",17));
        for(Vip vip:vips){
     
            System.out.println(vip);
        }
    }
}
class Vip implements Comparable<Vip>{
     
    String name;
    int age;
    public Vip(String name,int age){
     
        this.name=name;
        this.age=age;
    }
    @Override
    public String toString() {
     
        return "Vip [name=" + name + ", age=" + age + "]";
    }
    //compareTo方法的返回值很重要：
    //返回0表示相同，value会覆盖
    //>0,会继续在右子树上找
    //<0，会继续在左子树上找

    @Override
    public int compareTo(Vip v) {
     
        if(this.age==v.age){
     
            //年龄相同时，按照名字排序
            //姓名是String类型，可以直接比，调用compareTo方法
            return this.name.compareTo(v.name);
        }else{
     
            //年龄不一样
            return this.age-v.age;
        }
    }

}

自平衡二叉树结构

1.自平衡二叉树，遵循左小右大的原则存放
2.遍历二叉树的时候有三种方式
前序遍历：根左右
中序遍历：左根右
后序遍历：左右根
注意：前中后说的是根的位置
3.TreeSet集合和TreeMap集合采用的是中序遍历方式，即左根右。他们是自平衡二叉树
100 200 50 60 80 120 140 130 135 180 666

实现比较器接口

TreeSet集合中元素可排序的第二种方式，使用比较器的方式

public class TreeSetTest06 {
     
    public static void main(String[] args) {
     
        //创建TreeSet集合的时候，需要使用比较器
        //TreeSet wuGuis=new TreeSet<>();   //这样不行，没有通过构造方法传递一个比较器进去
        TreeSet<Wugui> wuGuis=new TreeSet<>(new WuguiComparator());
        wuGuis.add(new Wugui(1000));
        wuGuis.add(new Wugui(800));
        wuGuis.add(new Wugui(900));
        wuGuis.add(new Wugui(300));
        wuGuis.add(new Wugui(60));
        for(Wugui wugui:wuGuis){
     
            System.out.println(wugui);
        }

    }
}
class Wugui{
     
    int age;

    public Wugui(int age) {
     
        super();
        this.age = age;
    }

    @Override
    public String toString() {
     
        return "Wugui [age=" + age + "]";
    }
}
//单独再这里编写一个比较器
//比较器实现java.util.Comparator接口（Comparable是java.lang包下的）
class WuguiComparator implements Comparator<Wugui>{
     
    public int compare(Wugui o1,Wugui o2){
     
        //指定比较规则
        //按照年龄排序
        return o1.age-o2.age;
    }
}

我们可以使用匿名内部类的方式
可以使用匿名内部类的方式（这个类没有名字，直接new接口）

TreeSet<Wugui> wuGuis=new TreeSet<>(new Comparator<Wugui>(){
     
public int compare(Wugui o1,Wugui o2){
     
        //指定比较规则
        //按照年龄排序
        return o1.age-o2.age;
        }

});

最终的结论，放在TreeSet或者TreeMap集合key部分的元素要想做到排序，包括两种方式
第一种：放在集合中的元素实现java.lang.Comparable接口
第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。
Comparable和Comparator怎么选择呢？
当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口
如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用comparator接口
comparator接口的设计符合OCP原则。

Collections工具类

java.util.Collections集合工具类，方便集合的操作

public class CollectionsTest {
     
    static class Wugui2 implements Comparable<Wugui2>{
     
        int age;

        public Wugui2(int age) {
     
            super();
            this.age = age;
        }

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

        @Override
        public int compareTo(Wugui2 o) {
     
            // TODO Auto-generated method stub
            return this.age-o.age;
        }
    }
    public static void main(String[] args) {
     
        //ArrayList集合不是线程安全的
        List<String> list=new ArrayList<String>();
        //变成线程安全的
        Collections.synchronizedList(list);
        //排序
        list.add("abc");
        list.add("abe");
        list.add("abd");
        list.add("abf");
        list.add("abn");
        list.add("abm");
        Collections.sort(list);
        for(String s:list){
     
            System.out.println(s);
        }
        List<Wugui2> wuguis=new ArrayList<>();
        wuguis.add(new Wugui2(1000));
        wuguis.add(new Wugui2(8000));
        wuguis.add(new Wugui2(4000));
        wuguis.add(new Wugui2(6000));
        //注意：对list集合中元素排序，需要保证list集合中元素实现了Comparable接口
        Collections.sort(wuguis);
        for(Wugui2 wugui:wuguis){
     
            System.out.println(wugui);
        }
        //对set集合怎么排序呢
        Set<String> set=new HashSet<>();
        set.add("king");
        set.add("kingsoft");
        set.add("king2");
        set.add("king1");
        //将set集合转换成list集合
        List<String> myList=new ArrayList<>(set);
        Collections.sort(myList);
        for(String s:myList){
     
            System.out.println(s);
        }
        //这种方式也可以排序
        //Collections.sort(list集合，比较器对象)
    }
}