<small>

集合排序

可以直接通过集合工具类，Collections中的sort（ ）方法进行排序
collections中的sort排序规则是按照自然排序规则实现的
static sort() 静态方法，无需返回值

1. 英文字母按照ascii码排序
2. 数字按照阿拉伯顺序排序
   注意：集合中的元素想要实现排序功能，则集合元素对应的类型，必须是可比较的

List<String> list1 = 
                    new ArrayList<String>();
        list1.add("梅川酷子");
        list1.add("程承");
        list1.add("阿百川");
        list1.add("丁");
        System.out.println("原集合："+list1);
        Collections.sort(list1);

当集合中的元素是自定的people类时：

List<People> list3 = 
                new ArrayList<People>();
        list3.add(new People("程咬金",118));
        list3.add(new People("关羽",20));
        list3.add(new People("西门吹雪",39));
        System.out.println("原集合："+list3);
    
    Collections.sort(list3);

这时候需要对people中的comparTo方法进行重写

    @Override
    public int compareTo(People other) {
        /*
         * 可比较规则：
         *  比较的是人的年龄，按年龄大小自然排序。
         *  
         *  无需关心比较计算的具体结果，原则：
         *      结果 > 0，说明：this.age > other.age
         *      结果 = 0，说明：this.age = other.age
         *      结果 < 0，说明：this.age < other.age
         *  自然排序，大的后移。
         * 
         *  顺序排序：this对象在前，other对象在后。
         *  倒序排序：other对象在前，this对象在后。
         */
        return //this.age - other.age;//顺序排序
                other.age - this.age;//倒序排序

当这种自然排序不符合业务需求的时候，需要借助到比较器

@Override
    public int compare(People peo1, People peo2) {
        return peo1.name.length() - peo2.name.length();
    }

如果是非自定义的类，例如string无法实现接口的时候，需要通过匿名内部类来实现：

List<String> list1 = 
                new ArrayList<String>();
        list1.add("梅川酷子");
        list1.add("程承");
        list1.add("阿百川");
        list1.add("丁");
        System.out.println("原集合："+list1);
        /*
         * String类的中可比较接口，是按字符串的字典顺序排序。
         *  如何按照字符串中的字母个数顺序排序？
         * 
         * 当自然排序规则，满足不了业务需求时，
         *  可以直接通过另一种比较规则：
         *      自定义比较器比较规则，通过自定义规则
         *      来完成集合元素排序。
         * 
         * 比较器：
         *  也是一个接口，实现Comparator，重写compare方法。
         * 
         * Collections.sort(List list) 一个集合参数，
         *      只会按照元素的自然排序（Comparable的）规则。
         * 
         * Collections.sort(List list,Comparator) 
         *      集合、比较器两个参数
         *      会按照比较器（Comparator的）中自定义定义的
         *      规则，来完成排序。
         *  
         */
//      Collections.sort(list1);//自然排序
        Comparator<String> stringComparator = 
                new Comparator<String>(){
            @Override
            public int compare(String str1, String str2) {
                return str1.length() - str2.length();
            }
            
        };
        Collections.sort(list1,stringComparator);//自定义排序
        System.out.println("排序之后的集合："+list1);

总结：

1、必须要求元素类型为可比较类型
2、对于API常见类，都是按照自然排序规则实现的
当已有的排序规则满足不了排序规则时，考虑到自定义排序规则，排序规则有两种实现：
a、实现可比较接口，重写compareTo方法
b、实现比较器接口，重写compare方法
3、自定义类，上述两种规则都可以实现
class 类名 implements Comparable<类名>，comparator<类名>
4、非自定义类，如果没有排序规则，只能通过匿名内部类方式，创建可比较器对象，再通过Collections.sort（集合，比较器），此方法才能实现排序

comparable（可比较接口）与comparator（比较器接口）比较

1、comparable（可比较接口）自然排序规则，重写compareTo方法，定好规则，不会发生改变，Collections.sort(),实现自然排序
2、comparator（比较器接口）自定义排序规则，重写compare方法，规则经常发生改变，Collections.sort(集合，比较器),实现自定义排序
3、自定义类中：两种接口都可以直接实现，一般comparable是通过实现方式完成，已近实现自然排序规则，但自然排序规则满足不了业务需求，需要通过匿名内部类的方式，创建comparator比较器对象，通过Collections.sort完成排序，或者没有实现自然排序规则也可以通过这种方法来完成排序

结论：使用匿名内部类来创建比较器规则是最常用的排序方法