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{

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();
}

}