Comparable与Comparator

Comparable与Comparator浅析

Collections.sort(List<T> list); 
Collections.sort(List<T> list, Comparator<? super T> c)

Comparable适用范围:
若一个类实现了Comparable接口，就意味着“该类支持排序”

内部比较器(在类的内部使用)，比较属性 comaparable必须要实现compareTo方法

package java.lang;
import java.util.*;
public interface Comparable<T> {
    public int compareTo(T o);
}

举例（类Person1实现了Comparable接口）

package collections;

public class Person1 implements Comparable<Person1>
{
    private int age;
    private String name;

    public Person1(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Person1 o)
    {
        return this.age-o.age;
    }
    @Override 
    public String toString()
    {
        return name+":"+age;
    }
}

可以看到Person1实现了Comparable接口中的compareTo方法。实现Comparable接口必须修改自身的类，即在自身类中实现接口中相应的方法。

		Person1 person1 = new Person1("zzh",18);
        Person1 person2 = new Person1("jj",17);
        Person1 person3 = new Person1("qq",19);

        List<Person1> list = new ArrayList<>();
        list.add(person1);
        list.add(person2);
        list.add(person3);

        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);

输出结果：

[zzh:18, jj:17, qq:19]
[jj:17, zzh:18, qq:19]

Comparator适用范围:
Comparator 是比较器接口。我们若需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)；那么，我们可以建立一个“该类的比较器”来进行排序。

外部比较器(在类的外部使用)，比较器 comparator实现compare

package java.util;
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

如果我们的这个类无法修改，譬如String，我们又要对其进行排序，当然String中已经实现了Comparable接口，如果单纯的用String举例就不太形象。对类自身无法修改这就用到了Comparator这个接口（策略模式）。

public final class Person2
{
    private int age;
    private String name;

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

    @Override 
    public String toString()
    {
        return name+":"+age;
    }

    //getter and setter方法省略....
}

如类Person2，这个类已经固定，无法进行对其类自身的修改，也修饰词final了，你也别想继承再implements Comparable，那么此时怎么办呢？在类的外部使用Comparator的接口。如下测试代码：

		Person2 p1 = new Person2("zzh",18);
        Person2 p2 = new Person2("jj",17);
        Person2 p3 = new Person2("qq",19);
        List<Person2> list2 = new ArrayList<Person2>();
        list2.add(p1);
        list2.add(p2);
        list2.add(p3);
        System.out.println(list2);
        Collections.sort(list2,new Comparator<Person2>(){

            @Override
            public int compare(Person2 o1, Person2 o2)
            {
	            if(o1 == null || o2 == null)
					return 0;
                return o1.getAge()-o2.getAge();
            }

        });
        System.out.println(list2);

[zzh:18, jj:17, qq:19]
[jj:17, zzh:18, qq:19] 

如果待排序的列表中是数字或者字符，可以直接使用Collections.sort(list);当需要排序的集合或数组不是单纯的数字型时，需要自己定义排序规则，实现一个Comparator比较器。

如果我们的这个类无法修改，譬如String，我们又要对其进行排序，当然String中已经实现了Comparable接口，如果单纯的用String举例就不太形象。对类自身无法修改这就用到了Comparator这个接口（策略模式）。
Collections调用Collections.sort(list)方法,方法传递一个List集合,这里要求,List泛型里面装的元素必须实现Compareable接口此外，列表中的所有元素都必须是可相互比较的（也就是说，对于列表中的任何 e1 和 e2 元素，e1.compareTo(e2) 不得抛出 ClassCastException）

        Collections.sort(list, new Comparator<String>()
        {
            @Override
            public int compare(String o1, String o2)
            {
	            if(o1 == null || o2 == null)
					return 0;
                return o1.toUpperCase().compareTo(o2.toUpperCase());
            }
        });