深入理解 Comparable 接口和 Comparator 接口以及Arrays.sort()

来源：互联网发布：kdl32w600d安装软件编辑：程序博客网时间：2024/06/16 16:03

compareTo(Object o)方法是java.lang.Comparable<T>接口中的方法，当需要对某个类的对象进行排序时，该类需要实现Comparable<T>接口的，必须重写public int compareTo(T o)方法，比如MapReduce中Map函数和Reduce函数处理的 <key,value>,其中需要根据key对键值对进行排序，所以，key实现了WritableComparable<T>接口，实现这个接口可同时用于序列化和反序列化。WritableComparable<T>接口(用于序列化和反序列化)是Writable接口和Comparable<T>接口的组合；
compare(Object o1,Object o2)方法是java.util.Comparator<T>接口的方法，它实际上用的是待比较对象的compareTo(Object o)方法。

1. 两种比较接口分析

在 “ 集合框架 ” 中有两种比较接口： Comparable 接口和 Comparator 接口。 Comparable 是通用的接口，用户可以实现它来完成自己特定的比较，而 Comparator 可以看成一种算法的实现，在需要容器集合实现比较功能的时候，来指定这个比较器，这可以看成一种设计模式，将算法和数据分离。

前者应该比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类使用。

一个类实现了 Camparable 接口表明这个类的对象之间是可以相互比较的。如果用数学语言描述的话就是这个类的对象组成的集合中存在一个全序。这样，这个类对象组成的集合就可以使用 Sort 方法排序了。

而 Comparator 的作用有两个：

1 、如果类的设计师没有考虑到 Compare 的问题而没有实现 Comparable 接口，可以通过 Comparator 来实现比较算法进行排序；

2 、为了使用不同的排序标准做准备，比如：升序、降序或其他什么序。

2 Comparable 接口

public interface Comparable<T> {

public int compareTo(T o);

}

java.lang. Comparable 接口定义类的自然顺序，实现该接口的类就可以按这种方式排序。

1 ） int compareTo(Object o): 比较当前实例对象与对象 o ，如果位于对象 o 之前，返回负值，如果两个对象在排序中位置相同，则返回 0 ，如果位于对象 o 后面，则返回正值。

2 ）在 Java 2 SDK 版本 1.4 中有二十四个类实现 Comparable 接口。下表展示了 8 种基本类型的自然排序。虽然一些类共享同一种自然排序，但只有相互可比的类才能排序。

类

排序

BigDecimal,BigInteger,Byte,Double, Float,Integer,Long,Short

按数字大小排序

Character

按 Unicode 值的数字大小排序

String

按字符串中字符 Unicode 值排序

利用 Comparable 接口创建自己的类的排序顺序，只是实现 compareTo() 方法的问题。通常就是依赖几个数据成员的自然排序。同时类也应该覆盖 equals() 和 hashCode() 以确保两个相等的对象返回同一个哈希码。

这个接口的作用：如果数组或者集合中的（类）元素实现了该接口的话 , 我们就可以调用 Collections.sort 和Arrays.sort 排序，或应用于有序集合 TreeSet 和 TreeMap 中。

下面设计一个有序的类 Person ，它实现 Comparable 接口，以年龄为第一关键字，姓名为第二关键字升序排序。

Person.java

package com.zj.sort.comparable;

public class Person implements Comparable<Person> {

private int age ;

private String name ;

public Person( int age, String name) {

this . age = age;

this . name = name;

}

public int compareTo(Person person) {

int cop = age - person.getAge();

if (cop != 0)

return cop;

else

return name .compareTo(person. name );

}

public int getAge() {

return age ;

}

public String getName() {

return name ;

}

public int hashCode() {

int result = 17;

result = 37 * result + age ;

result = 37 * result + name .hashCode();

return result;

}

public boolean equals(Object o) {

if (!(o instanceof Person))

return false ;

Person person = (Person) o;

return ( age == person. age ) && ( name .equals(person. name ));

}

public String toString() {

return ( age + "{" + name + "}" );

}

2.1 测试 Arrays.sort （）方法

ArraysSortUnit.java

package com.zj.sort.comparable;

import java.util.Arrays;

import com.zj.compare.Person;

public class ArraysSortUnit {

public static void main(String[] args) {

Person[] ps = { new Person(20, "Tom" ), new Person(20, "Jeff" ),

new Person(30, "Mary" ), new Person(20, "Ada" ),

new Person(40, "Walton" ), new Person(61, "Peter" ),

new Person(20, "Bush" ) };

System. out .println(Arrays.toString (ps));

Arrays.sort (ps);

System. out .println(Arrays.toString (ps));

}

结果：

[20{Tom}, 20{Jeff}, 30{Mary}, 20{Ada}, 40{Walton}, 61{Peter}, 20{Bush}]

[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]

2.2 测试 Collections.sort （）方法

CollctionsSortUnit.java

package com.zj.sort.comparable;

import java.util.Arrays;

import java.util.Collections;

import com.zj.compare.Person;

public class CollctionsSortUnit {

public static void main(String[] args) {

Person[] ps = { new Person(20, "Tom" ), new Person(20, "Jeff" ),

new Person(30, "Mary" ), new Person(20, "Ada" ),

new Person(40, "Walton" ), new Person(61, "Peter" ),

new Person(20, "Bush" ) };

System. out .println(Arrays.toString (ps));

Collections.sort (Arrays.asList (ps));

System. out .println(Arrays.toString (ps));

}

结果：

[20{Tom}, 20{Jeff}, 30{Mary}, 20{Ada}, 40{Walton}, 61{Peter}, 20{Bush}]

[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]

2.3 测试 TreeSet

TreeSetUnit.java

package com.zj.sort.comparable;

import java.util.TreeSet;

import com.zj.compare.Person;

public class TreeSetUnit {

public static void main(String[] args) {

TreeSet<Person> set = new TreeSet<Person>();

set.add( new Person(20, "Tom" ));

set.add( new Person(20, "Jeff" ));

set.add( new Person(30, "Mary" ));

set.add( new Person(20, "Ada" ));

set.add( new Person(40, "Walton" ));

set.add( new Person(61, "Peter" ));

set.add( new Person(20, "Bush" ));

System. out .println(set);

}

结果：

[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]

2.4 测试 TreeMap

TreeMapUnit.java

package com.zj.sort.comparable;

import java.util.TreeMap;

import com.zj.compare.Person;

public class TreeMapUnit {

public static void main(String[] args) {

TreeMap<Person, String> map = new TreeMap<Person, String>();

map.put( new Person(20, "Tom" ), "Tom" );

map.put( new Person(20, "Jeff" ), "Jeff" );

map.put( new Person(30, "Mary" ), "Mary" );

map.put( new Person(20, "Ada" ), "Ada" );

map.put( new Person(40, "Walton" ), "Walton" );

map.put( new Person(61, "Peter" ), "Peter" );

map.put( new Person(20, "Bush" ), "Bush" );

System. out .println(map);

}

结果：

{20{Ada}=Ada, 20{Bush}=Bush, 20{Jeff}=Jeff, 20{Tom}=Tom, 30{Mary}=Mary, 40{Walton}=Walton, 61{Peter}=Peter}

转自 http://www.blogjava.net/fastunit/archive/2008/04/08/191533.html

三、Comparator和Comparable的区别

先看一下使用Comparator对User集合实现排序的方式：

import  java.util.Arrays;
import  java.util.Comparator;

public   class  UserComparator  implements  Comparator {

   public   int  compare(Object o1, Object o2) {
     return  ((User) o1).getAge()  -  ((User) o2).getAge();
  }

   /**
   * 测试方法
    */
   public   static   void  main(String[] args) {
    User[] users  =   new  User[] {  new  User( " a " ,  30 ),  new  User( " b " ,  20 ) };
    Arrays.sort(users,  new  UserComparator());
     for  ( int  i  =   0 ; i  <  users.length; i ++ ) {
      User user  =  users[i];
      System.out.println(user.getId()  +   "   "   +  user.getAge());
    }
  }

}

一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准，比如升序、降序等

Arrays.sort(T[], Comparator < ? super T > c) 方法用于对象数组按用户自定义规则排序.
官方Java文档只是简要描述此方法的作用,并未进行详细的介绍,本文将深入解析此方法。
1. 简单示例
sort方法的使用非常的简单明了,下面的例子中,先定义一个比较Dog大小的Comparator,然后将其实例对象作为参数传给sort方法,通过此示例,你应该能够快速掌握Arrays.sort()的使用方法。

[java] view plain copy
import java.util.Arrays;  
import java.util.Comparator;  
   
class Dog{  
    int size;     
    public Dog(int s){  
        size = s;  
    }  
}  
   
class DogSizeComparator implements Comparator<Dog>{  
   
    @Override  
    public int compare(Dog o1, Dog o2) {  
        return o1.size - o2.size;  
    }  
}  
   
public class ArraySort {  
   
    public static void main(String[] args) {  
        Dog d1 = new Dog(2);  
        Dog d2 = new Dog(1);  
        Dog d3 = new Dog(3);  
   
        Dog[] dogArray = {d1, d2, d3};  
        printDogs(dogArray);  
   
        Arrays.sort(dogArray, new DogSizeComparator());   
        printDogs(dogArray);  
    }  
   
    public static void printDogs(Dog[] dogs){  
        for(Dog d: dogs)  
            System.out.print(d.size + " " );  
   
        System.out.println();  
    }  
}  

输出为:

[plain] view plain copy
2 1 3  
1 2 3  

2. 使用策略模式
这是策略模式(Strategy pattern)的一个完美又简洁的示例,值得一提的是为什么这种场景下适合使用策略模式.
总体来说,策略模式允许在程序执行时选择不同的算法.比如在排序时,传入不同的比较器(Comparator),就采用不同的算法.
根据上面的例子,假设你想要根据Dog的重量来进行排序,可以像下面这样,创建一个新的比较器来进行排序:

[java] view plain copy
class Dog{  
    int size;  
    int weight;  
   
    public Dog(int s, int w){  
        size = s;  
        weight = w;   
    }  
}  
   
class DogSizeComparator implements Comparator<Dog>{  
   
    @Override  
    public int compare(Dog o1, Dog o2) {  
        return o1.size - o2.size;  
    }  
}  
   
class DogWeightComparator implements Comparator<Dog>{  
   
    @Override  
    public int compare(Dog o1, Dog o2) {  
        return o1.weight - o2.weight;  
    }  
}  
   
public class ArraySort {  
   
    public static void main(String[] args) {  
        Dog d1 = new Dog(2, 50);  
        Dog d2 = new Dog(1, 30);  
        Dog d3 = new Dog(3, 40);  
   
        Dog[] dogArray = {d1, d2, d3};  
        printDogs(dogArray);  
   
        Arrays.sort(dogArray, new DogSizeComparator());   
        printDogs(dogArray);  
   
        Arrays.sort(dogArray, new DogWeightComparator());     
        printDogs(dogArray);  
    }  
   
    public static void printDogs(Dog[] dogs){  
        for(Dog d: dogs)  
            System.out.print("size="+d.size + " weight=" + d.weight + " ");  
   
        System.out.println();  
    }  
}  

执行结果:

[plain] view plain copy
size=2 weight=50 size=1 weight=30 size=3 weight=40  
size=1 weight=30 size=2 weight=50 size=3 weight=40  
size=1 weight=30 size=3 weight=40 size=2 weight=50  

Comparator 是一个接口,所以sort方法中可以传入任意实现了此接口的类的实例,这就是策略模式的主要思想.

3. 为何使用"super"
如果使用 "Comparator < T > c" 那是很简单易懂的,但是sort的第2个参数里面的 < ? super T > 意味着比较器所接受的类型可以是T或者它的超类. 为什么是超类呢? 答案是: 这允许使用同一个比较器对不同的子类对象进行比较.在下面的示例中很明显地演示了这一点:

[java] view plain copy
import java.util.Arrays;  
import java.util.Comparator;  
   
class Animal{  
    int size;  
}  
   
class Dog extends Animal{  
    public Dog(int s){  
        size = s;  
    }  
}  
   
class Cat extends Animal{  
    public Cat(int s){  
        size  = s;  
    }  
}  
   
class AnimalSizeComparator implements Comparator<Animal>{  
   
    @Override  
    public int compare(Animal o1, Animal o2) {  
        return o1.size - o2.size;  
    }  
    //in this way, all sub classes of Animal can use this comparator.  
}  
   
public class ArraySort {  
   
    public static void main(String[] args) {  
        Dog d1 = new Dog(2);  
        Dog d2 = new Dog(1);  
        Dog d3 = new Dog(3);  
   
        Dog[] dogArray = {d1, d2, d3};  
        printDogs(dogArray);  
   
        Arrays.sort(dogArray, new AnimalSizeComparator());    
        printDogs(dogArray);  
   
        System.out.println();  
   
        //when you have an array of Cat, same Comparator can be used.   
        Cat c1 = new Cat(2);  
        Cat c2 = new Cat(1);  
        Cat c3 = new Cat(3);  
   
        Cat[] catArray = {c1, c2, c3};  
        printDogs(catArray);  
   
        Arrays.sort(catArray, new AnimalSizeComparator());    
        printDogs(catArray);  
    }  
   
    public static void printDogs(Animal[] animals){  
        for(Animal a: animals)  
            System.out.print("size="+a.size + " ");  
   
        System.out.println();  
    }  
}  

输出结果:

[plain] view plain copy
size=2 size=1 size=3  
size=1 size=2 size=3  
size=2 size=1 size=3  
size=1 size=2 size=3  

4. 小结
与Arrays.sort()相关的信息总结如下:

通用: super 类
策略设计模式(strategy pattern);
归并排序(merge sort): 时间复杂度 n*log(n);
Java.util.Collections#sort(List < T > list, Comparator < ? super T > c)与Arrays.sort 使用类似的思想.

参考文献:
1. Arrays.sort(T[], java.util.Comparator)

相关阅读:

Example of Sorting Arrays
Java Design Pattern: Strategy
Comparable vs Comparator in Java
Top 10 Methods for Java Arrays

0 0