Java6.0中Comparable接口与Comparator接口详解 中

Part III

接下来让我们看看Comparable和Comparator的强大功力：

   1: public class Person implements Comparable<Person> {

   2:  

   3:     private String name;

   4:     private int age;

   5:  

   6:     public String getName() {

   7:         return name;

   8:     }

   9:  

  10:     public void setName(String name) {

  11:         this.name = name;

  12:     }

  13:  

  14:     public int getAge() {

  15:         return age;

  16:     }

  17:  

  18:     public void setAge(int age) {

  19:         this.age = age;

  20:     }

  21:  

  22:     @Override

  23:     public int compareTo(Person p) {

  24:         if (this.age > p.age) {

  25:             return 1;

  26:         } else if (this.age < p.age) {

  27:             return -1;

  28:         }

  29:         return 0;

  30:     }

  31:  

  32: }

   1: public class CompareTest {

   2:  

   3:     public static void main(String[] args) {

   4:         Person p1 = new Person();

   5:         p1.setName("P1");

   6:         p1.setAge(20);

   7:  

   8:         Person p2 = new Person();

   9:         p2.setName("P2");

  10:         p2.setAge(30);

  11:  

  12:         System.out.println(p1.compareTo(p2));

  13:     }

  14:  

  15: }

运行的结果为：-1

读者看到这里一定会觉得很好笑，我不就实现了一个接口重写了个方法吗？然后又调用这个方法，而这个方法的返回值又是我自己定义的？那实现这个接口有什么意义呢？不实现这个接口我也可以给他一个compareTo的方法啊？而且对运行的结果没有影响！

没错，在这里确实还不能体现出Comparable接口的作用，但是别忘了我们的强大的Java类库，实现了Comparable接口的类当然是要结合类库中的其他类来使用！

下面我们先对Person类进行一下处理，添加了带参的构造器并重写了toString()方法，方便演示程序的运行结果：

   1: public class Person implements Comparable<Person> {

   2:  

   3:     private String name;

   4:     private int age;

   5:     

   6:     public Person() {

   7:         

   8:     }

   9:     

  10:     public Person(String name, int age) {

  11:         this.name = name;

  12:         this.age = age;

  13:     }

  14:  

  15:     public String getName() {

  16:         return name;

  17:     }

  18:  

  19:     public void setName(String name) {

  20:         this.name = name;

  21:     }

  22:  

  23:     public int getAge() {

  24:         return age;

  25:     }

  26:  

  27:     public void setAge(int age) {

  28:         this.age = age;

  29:     }

  30:  

  31:     @Override

  32:     public int compareTo(Person p) {

  33:         if (this.age > p.age) {

  34:             return 1;

  35:         } else if (this.age < p.age) {

  36:             return -1;

  37:         }

  38:         return 0;

  39:     }

  40:  

  41:     @Override

  42:     public String toString() {

  43:         return "Person [age=" + age + ", name=" + name + "]";

  44:     }

  45:  

  46: }

接下来我们定义一个无序的Person对象数组persons，并使用java.utils.Arrays工具类对其进行排序：

   1: import java.util.Arrays;

   2:  

   3: public class CompareTest {

   4:  

   5:     public static void main(String[] args) {

   6:         Person[] persons = {

   7:                 new Person("P1", 60),

   8:                 new Person("P2", 20),

   9:                 new Person("P3", 40)

  10:         };

  11:         

  12:         System.out.println(Arrays.toString(persons));

  13:         

  14:         Arrays.sort(persons);

  15:         

  16:         System.out.println(Arrays.toString(persons));

  17:     }

  18:  

  19: }

结果如下：

[Person [age=60, name=P1], Person [age=20, name=P2], Person [age=40, name=P3]]
[Person [age=20, name=P2], Person [age=40, name=P3], Person [age=60, name=P1]]

 

没错，无序的对象数组进过处理后按照age的大小来进行排序，这就是实现Comparable接口所带来的效果。读者如果对此有疑惑，可以尝试不实现Comparable接口，来进行排序。