TreeSet

TreeSet   保证元素唯一  并且排序

　　添加对象时  对象必须有排序功能，如果没有，则报classException

　　能不能存进去，看的就是比较器的比较结果

两种排序方法：

1、 实现comparable接口，重写compareTo（）方法

@Override
    public int compareTo(Person o) {
        /*int num = this.age-o.age;   // 年龄是主要条件，name是次要排序
        return num == 0 ? this.name.compareTo(o.name) : num;*/
        /*int num = this.name.compareTo(o.name);
        return num == 0 ? this.age - o.age : num ;*/
        
        //按照姓名长度排序
        int length = this.name.length() - o.name.length();
        return length == 0 ? this.age - o.age: length;        ##  先比较首要的 ，再比较次要的
    }

compareTo() 返回0 ： 不存
返回正数 ： 集合中怎么存怎么取
返回负数 ： 倒序存储

 　　　　二叉树原理   ：

　　　　　　　　每次存的时候 都要比较，小的在左边，大的在右边。

　　　　　　　　取得时候，先去左边的，即取小的

　2、比较器排序

import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

public class test4 {
    //  无序且重复的字符串，   将其排序并且不去除重复
    public static void main(String[] args) {
        ArrayList<String> a1 = new ArrayList<>();
        a1.add("aaa");
        a1.add("aaa");
        a1.add("ccc");
        a1.add("ddd");
        a1.add("aaa");
        a1.add("fffffff");
        a1.add("aaa");
        a1.add("heima");
        a1.add("dfasd");
        a1.add("aaa");
        sort(a1);
        System.out.println(a1);
    }
    // 定义方法排序  并保留重复
    public static void sort(List<String> list) {
        TreeSet<String> t1 = new TreeSet<>(new liuchong());   //  传入的是比较器    这个地方可以直接传匿名内部类
        t1.addAll(list);
        list.clear();
        list.addAll(t1);        
    }
}

class liuchong implements Comparator<String>{　　　　//实现比较器

    @Override
    public int compare(String o1, String o2) {
        int num = o1.compareTo(o2); 
        return num == 0 ? 1 : num ;    //   当num == 0时  表示相等，本来就不会存了，但是此时我们返回1,那么就会存了
    }
    
}

public class test5 {
    /*
     *从键盘接收一个字符串，程序对其中所有字符进行排序，例如键盘录入hellitcast     排序 保留重复
     */
    public static void main(String[] args) {        
        paixu();
    }

    public static void paixu() {
        Scanner s1 = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s2 = s1.nextLine();        
        char[] c1 = s2.toCharArray();
        ArrayList<Character> a1 = new ArrayList<>();
        for (char c : c1) {
            a1.add(c);
        }
        System.out.println(a1);
        sort(a1);
        for (Character character : a1) {
            System.out.print(character);
        }
    }
    
    public static void sort(ArrayList<Character> list) {               
        TreeSet<Character> t1 = new TreeSet<>(new Liu());
        t1.addAll(list);
        list.clear();
        list.addAll(t1);
        
    }

}
class Liu implements Comparator<Character>{

    @Override
    public int compare(Character ch1, Character ch2) {
        int num = ch1 - ch2;
        return num == 0 ? 1:num;
    }
    
}

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

public class test6 {
    /*
     * 程序启动后 可以从键盘接收多个整数，直到输入quit时结束输入，
     * 将所有输入的整数倒叙排列打印
     */
    public static void main(String[] args) {
        Scanner s1 = new Scanner(System.in);
        TreeSet<Integer> t1 = new TreeSet<>(new Comparator<Integer>() {     //  匿名内部类，  其实是  Comparator的子类对象

            @Override
            public int compare(Integer i1, Integer i2) {
                int num = i2 - i1 ;    //  i2  - i1  就是反着排序了
                return num == 0 ? 1 : num;
            }
            
        });
        
        while (true) {
            String line = s1.nextLine();
            if ("quit".equals(line)) {
                break;
            } 
            Integer integer = Integer.parseInt(line);
            t1.add(integer);
        }
        for (Integer i : t1) {
            System.out.println(i);
        }
        
        
    }

}

public class test7 {
    /*
     * 键盘录入5个学生信息（姓名，语，数，外成绩），按照总分从高到低输出控制台
     */
    public static void main(String[] args) {
        TreeSet<Student> t1 = new TreeSet<>(new ssort());
        Scanner s1 = new Scanner(System.in);
        System.out.println("请输入学生信息，格式是姓名,语,数,外");
        while (t1.size() <5) {
            String s2 = s1.nextLine();
            String[] c1 = s2.split(",");
            String name = c1[0];
            int yu = Integer.parseInt(c1[1]);
            int shu = Integer.parseInt(c1[2]);
            int wai = Integer.parseInt(c1[3]);
            t1.add(new Student(name,yu,shu,wai));
        }
        s1.close();
        for (Student student : t1) {
            System.out.println(student);
        }
        
    }

}
class ssort implements Comparator<Student>{

    @Override
    public int compare(Student sa, Student sb) {
        int num = sb.getSum() - sa.getSum();
        return num == 0 ? 1 :num ;
    }
    
}