<正则吃饺子> ：关于Collections中 比较器的简单使用

在线文档地址： http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

sort

public static <T extends Comparable<? super T>> void sort(List<T> list)

根据元素的 自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此外，列表中的所有元素都必须是 可相互比较的（也就是说，对于列表中的任何 e1 和 e2 元素， e1.compareTo(e2) 不得抛出 ClassCastException）。

此排序方法具有稳定性：不会因调用 sort 方法而对相等的元素进行重新排序。

指定列表必须是可修改的，但不必是大小可调整的。

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n log(n) 性能。 此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置处每个元素的列表上进行迭代。这避免了由于试图原地对链接列表进行排序而产生的 n² log(n) 性能。

参数：

list - 要排序的列表。

抛出：

ClassCastException - 如果列表包含不 可相互比较 的元素（例如，字符串和整数）。

UnsupportedOperationException - 如果指定列表的列表迭代器不支持 set 操作。

另请参见：

Comparable

-------------------------------------------------------------------

sort

public static <T> void sort(List<T> list,
                            Comparator<? super T> c)

根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器 相互比较（也就是说，对于列表中的任意 e1 和 e2 元素， c.compare(e1, e2) 不得抛出 ClassCastException）。

此排序被保证是稳定的：不会因调用 sort 而对相等的元素进行重新排序。

排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n log(n) 性能。 指定列表必须是可修改的，但不必是可大小调整的。此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置每个元素的列表上进行迭代。这避免了由于试图原地对链接列表进行排序而产生的 n² log(n) 性能。

参数：

list - 要排序的列表。

c - 确定列表顺序的比较器。 null 值指示应该使用元素的 自然顺序。

抛出：

ClassCastException - 如果列表中包含不可使用指定比较器 相互比较 的元素。

UnsupportedOperationException - 如果指定列表的列表迭代器不支持 set 操作。

另请参见：

Comparator

package com.zhengze.test;

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

public class Cat {
    private String name;
    private int 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;
    }

    /**
     *  数据获取
     * @return
     */
    public List<Cat> getCatList() {
        List<Cat> list = new ArrayList<Cat>();
        Cat cat = null;
        for (int i = 0; i <= 8; i++) {
            cat = new Cat();
            cat.setName("nnn" + (i + 1));
            cat.setAge(i + 1);
            list.add(cat);
        }

        return list;
    }

    /**
     *  模拟比较器
     */
    public void compare() {
        // 模拟获取数据
        List<Cat> list = this.getCatList();
        Comparator<Cat> comm = new Comparator<Cat>() {

            @Override
            public int compare(Cat o1, Cat o2) {
                // 这里面可以做一些业务处理，现在只是使用集合中的cat的年龄进行排序

                return o2.getAge() - o1.getAge(); // 倒序
                // return o1.getAge() - o2.getAge(); //正序
            }
        };
        // 比较 1
        Collections.sort(list, comm);

        // 比较2
        // 需要 Cat 实现 Comparable 接口。则可以直接在 Cat 类中 重写 compareTo 方法，在此处可以自定义比较方式。
        // 基于此就可以，Collections.sort(list);

        for (int i = 0; i < list.size(); i++) {
            Cat cat = list.get(i);
            System.out.println("名称：" + cat.getName());
            System.out.println("年龄：" + cat.getAge());
            // 打印结果：此处是倒序
            // 名称：nnn8
            // 年龄：8
            // 名称：nnn7
            // 年龄：7
            // 名称：nnn6
            // 年龄：6
            // 名称：nnn5
            // 年龄：5
            // 名称：nnn4
            // 年龄：4
            // 名称：nnn3
            // 年龄：3
            // 名称：nnn2
            // 年龄：2
            // 名称：nnn1
            // 年龄：1
        }
    }

    // main方法
    public static void main(String[] agrs) {
        Cat c = new Cat();
        c.compare();

    }

}