java使用Comparable和Comparator实现排序 和多条件排序

import java.util.*;

/*
栈: 先进后出
队列:先进先出
数组: 查询快,增删慢
链表: 查询慢,增删快
红黑树: 每个节点最多有2个子节点

Collection 集合:
    List集合:  存取有序,有索引,元素可重复
        ArrayList:
               底层结构:数组,查询快,增删慢,线程不安全
        LinkedList:
            底层结构:链表,查询慢,增删快

        Vector:
            底层结构: 数组,查询快,增删慢,线程安全

    Set集合:   存取无序,无索引,元素不可重复(唯一)
        HashSet:    存取无序,无索引,元素不可重复(唯一)
                底层结构: 哈希表结构
                    哈希表: 数组+链表
                        jdk1.8之前: 数组+链表
                        jdk1.8之后: 数组+链表+红黑树
                            元素个数超过8个: 数组+链表+红黑树
                            元素个数不超过8个: 数组+链表

            LinkedHashSet:  存取有序,无索引,元素不可重复(唯一)
                    底层:链表+哈希表
                    由链表保证集合中元素存取有序,由哈希表保证元素唯一

        TreeSet: 可以对集合中的元素进行排序
            底层: 二叉树


Collections :
    - java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：

        - public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
        - public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
        - public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
                注意:
                    1.参数是List集合
                    2.默认规则排序: 就是按照写死的规则进行排序
                        默认规则是在compareTo方法中写死的规则,而需要被排序的类型要实现Comparable接口中的compareTo方法
                        也就意味着在被需要排序的类型中 要重写compareTo方法,在compareTo方法中指定比较规则
                    3.使用sort(List<T> list),只能按照默认规则进行排序,默认规则是在需要排序的类型里面的compareTo方法中指定的
                    4.如果使用sort(List<T> list)对一个集合排序,而集合中的元素是自定义的类型,应该怎么办??????
                        集合中元素所属的类型需要实现Comparable接口,然后在compareTo方法中指定默认排序规则
                    5.弊端:只能按照一种规则排序

        - public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。
                    1.可以灵活指定规则排序
                    2.在Comparator接口中的compare方法中指定比较规则
 */
public class Demo3 {
    public static void main(String[] args) {
        Person p1 = new Person("金毛狮王谢逊",18);
        Person p2 = new Person("张无忌",19);
        Person p3 = new Person("灭绝师太",14);
        Person p4 = new Person("赵敏",15);
        Person p5 = new Person("张三丰",119);

        ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,p1,p2,p3,p4,p5);

        System.out.println("排序之前:"+list);


        // 先按照姓名长度从短到长排序,再按照年龄从大到小排序
        // 优先按照姓名长度从短到长排序,如果姓名长度相同,就再按照年龄从大到小排序
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {// 指定规则排序
                // 前减后 升序
                // 后减前 降序
                // 按照姓名长度从短到长排序
                int result1 = o1.getName().length() - o2.getName().length();
                // 再按照年龄从大到小排序
                int result2 = o2.getAge() - o1.getAge();

                // 分析: 返回result1按照姓名长度从短到长排序,返回result2按照年龄从大到小排序
                //    只有姓名长度相同的时候返回result2,其他情况返回result1
//                return o1.getName().length() == o2.getName().length()  ? result2 : result1;
                return result1==0 ? result2 : result1;
            }
        });

        System.out.println("排序之后:"+list);

    }

    private static void method03() {
        Person p1 = new Person("金毛狮王谢逊",18);
        Person p2 = new Person("张无忌",19);
        Person p3 = new Person("灭绝师太",14);
        Person p4 = new Person("赵敏",15);

        ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,p1,p2,p3,p4);

        System.out.println("排序之前:"+list);

        // 排序  按照年龄从大到小排序
        Collections.sort(list);// 错误,如果被排序的类型没有实现Comparable接口,那么就不能使用默认规则排序

        System.out.println("排序之后:"+list);


        //  需求:按照姓名长度从短到长排序
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {//指定排序规则
                // 前减后,升序
                // 后减前,降序
                return o1.getName().length() - o2.getName().length();
            }
        });
        System.out.println("排序之后:"+list);

        //  需求:按照姓名长度从长到短排序
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {//指定排序规则
                // 前减后,升序
                // 后减前,降序
                return o2.getName().length() - o1.getName().length();
            }
        });
        System.out.println("排序之后:"+list);


        //


        ArrayList<String> list2 = new ArrayList<>();

        Collections.addAll(list2,"cba","nba","abc","mba","bac","cab");

        System.out.println("排序之前:"+list2);// 排序之前:[cba, nba, abc, mba, bac, cab]

        //sort(List<T> list)这个方法完成的排序，实际上要求了被排序的类型需要实现Comparable接口完成比较的功能
        Collections.sort(list2);// 按照首字母升序排序

        System.out.println("排序之后:"+list2);// 排序之后:[abc, bac, cab, cba, mba, nba]


        // 需求:按照首字母降序排序
        Collections.sort(list2, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                // 前减后  升序
                // 后减前  降序
                return o2.charAt(0) - o1.charAt(0);
            }
        });
        System.out.println("排序之后:"+list2);// 排序之后:[nba, mba, cab, cba, bac, abc]
    }

    private static void method02() {
        //        Collection<String> col = new ArrayList<>();


        Collection<String> col = new HashSet<>();

        String[] arr = {"张三","李四","王五","赵六","李四"};
        Collections.addAll(col,arr);

        System.out.println(col);// [张三, 李四, 王五, 赵六]

        Object[] objects = col.toArray();// 数组去重
    }

    private static void method01() {
        Collection<String> col = new ArrayList<>();

        Collections.addAll(col,"张三","李四","王五","赵六");

        System.out.println(col);// [张三, 李四, 王五, 赵六]


        Collection<String> col2 = new HashSet<>();

        Collections.addAll(col2,"张三","李四","王五","赵六","李四");

        System.out.println(col2);// [李四, 张三, 王五, 赵六]
    }
}


定义的Person类代码
public class Person implements Comparable<Person>{

    private String name;

    private int age;

    public Person() {
    }

    public Person(String name, int age) {

        this.name = name;
        this.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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Person o) {
        // 指定默认排序规则: 按照年龄从大到小进行排序
        // 前减后 升序
        // 后减前 降序

        return o.getAge() - this.getAge();
    }
}