<正则吃饺子> ：关于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();

    }

}