Comparator 排序

例1：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        Map<String, Integer> m = new HashMap<String, Integer>();
        m.put("a", 1);
        m.put("b", 1);
        m.put("c", 2);
        m.put("d", 3);
        System.out.println(getFristEntryOfSortedMap(m, true));
        System.out.println(getFristEntryOfSortedMap(m, false));
    }

    /**
     * 通过map 的 value 排序，并返回排序后的第一个条目
     * 
     * @param m
     *            待排序集合
     * @param desc
     *            true:降序排序,false:升序排序
     * @return 返回排序后的第一个条目
     */
    public static Entry<String, Integer> getFristEntryOfSortedMap(Map<String, Integer> m, boolean desc) {

        if (m == null || m.isEmpty()) {
            throw new IllegalArgumentException("map is null or empty");
        }
        Set<Entry<String, Integer>> entrySet = m.entrySet();
        Iterator<Entry<String, Integer>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            if (iterator.next().getValue() == null) {
                throw new IllegalArgumentException("map contains null value");
            }
        }
        List<Entry<String, Integer>> entryList = new ArrayList<Entry<String, Integer>>(entrySet);
        if (desc) {
            Collections.sort(entryList, new Comparator<Entry<String, Integer>>() {
                @Override
                public int compare(Entry<String, Integer> e1, Entry<String, Integer> e2) {
                    return e2.getValue() - e1.getValue();
                }
            });
        } else {
            Collections.sort(entryList, new Comparator<Entry<String, Integer>>() {
                @Override
                public int compare(Entry<String, Integer> e1, Entry<String, Integer> e2) {
                    return e1.getValue() - e2.getValue();
                }
            });
        }
        return entryList.get(0);
    }

}

d=3
a=1

例2：

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

public class Test {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<Person>();
        list.add(new Person(3, "d"));
        list.add(new Person(1, "a"));
        list.add(new Person(1, "b"));
        list.add(new Person(2, "c"));
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p2.getAge() - p1.getAge();
            }
        });

        System.out.println(list);
    }

}

class Person {
    private int age;
    private String name;

    Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

}

[Person [age=3, name=d], Person [age=2, name=c], Person [age=1, name=a], Person [age=1, name=b]]

注： 值等时保持原有顺序

非自然序，降序

自然序(1,2,3,...)，升序