黑马程序员技术交流社区

标题: Comparator与Comparable有什么区别呀？ [打印本页]
作者: 雷云红    时间: 2012-6-12 17:50
标题: Comparator与Comparable有什么区别呀？
Comparator与Comparable有什么区别呀？怎么用呀？高手用代码解决
作者: 田建    时间: 2012-6-12 17:58
comparable和Comparator  都可以用来实现排序：
Comparable是在集合内部定义的方法实现的排序，需在集合内实现Comparable接口的方法compareTo();
Comparator是在集合外部实现的排序，需要在集合外定义Comparator接口的方法compare();
Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String    Integer自己就可以完成比较大小操作）;   
Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。
作者: 王超    时间: 2012-6-12 18:01
下面两篇代码是分别用两个接口来实现了同样的目的

目的是：在TreeSet中加入对象元素，并对其中元素进行排序，假如出现学号相同则按名字字母的先后排序。
  1. import   java.util.Iterator;
  2. import   java.util.TreeSet;
  3. class   TreeSetTest
  4. {
  5. public   static   void   main(String[]   args)
  6. {
  7. TreeSet <Object>   ts=new   TreeSet <Object> ();

  9. ts.add(new   MyStudents(2, "Vida "));
  10. ts.add(new   MyStudents(4, "Lillian "));
  11. ts.add(new   MyStudents(2, "Lightmoon "));
  12. ts.add(new   MyStudents(1, "Chaner "));

  14. Iterator   it=ts.iterator();
  15. while(it.hasNext())
  16. {
  17. System.out.println(it.next());
  18. }

  20. }

  22. }

  24. class   MyStudents   implements   Comparable <Object>
  25. {
  26. int   number;
  27. String   name;
  28. MyStudents(int   number,String   name)
  29. {
  30. this.number=number;
  31. this.name=name;
  32. }
  33. public   String   toString()
  34. {
  35. return   "The   Student 's   information   is:   Number= "+number+ "   name= "+name;
  36. }
  37. public   int   compareTo(Object   o)
  38. {
  39. MyStudents   mst=(MyStudents)o;
  40. int   result;
  41. result=number   >   mst.number   ?   1   :   (number==mst.number   ?   0   :   -1);
  42. if(result==0)
  43. {
  44. return   result=name.compareTo(mst.name);
  45. }
  46. return   result;
  47. }
  48. }
复制代码
  1. import   java.util.*;
  2. class   TreeSetTest_1
  3. {
  4. public   static   void   main(String[]   args)
  5. {
  6. TreeSet <Object>   ts=new   TreeSet <Object> (new   MyStudents.MyStudentsComparator());

  8. ts.add(new   MyStudents(2, "Vida "));
  9. ts.add(new   MyStudents(4, "Lillian "));
  10. ts.add(new   MyStudents(2, "Lightmoon "));
  11. ts.add(new   MyStudents(1, "Chaner "));

  13. Iterator   it=ts.iterator();
  14. while(it.hasNext())
  15. {
  16. System.out.println(it.next());
  17. }

  19. }

  21. }

  23. class   MyStudents
  24. {
  25. int   number;
  26. String   name;
  27. MyStudents(int   number,String   name)
  28. {
  29. this.number=number;
  30. this.name=name;
  31. }
  32. public   String   toString()
  33. {
  34. return   "The   Student 's   information   is:   Number= "+number+ "   name= "+name;
  35. }

  37. static   class   MyStudentsComparator   implements   Comparator <Object>
  38. {
  39. public   int   compare(Object   o1,Object   o2)
  40. {
  41. MyStudents   mst1=(MyStudents)o1;
  42. MyStudents   mst2=(MyStudents)o2;
  43. int   result=mst1.number> mst2.number?1:(mst1.number==mst2.number?0:-1);
  44. if(result==0)
  45. {
  46. return   mst1.name.compareTo(mst2.name);
  47. }
  48. return   result;
  49. }

  51. }

  53. }
复制代码
一个是lang包下面的接口,一个是util包下面的接口,看起来两个是实现相同的目的,但两者还是有区别的,
1.Comparable <T> 只有一个要实现的方法叫CompareTo
而Comparator <T> 取有两个方法.一个是Compare和equals
2Comparable是一个参数的.而且他是系统调用的方法.所以他只能表示传入对象与当前对象的比较
而Comparator是两个参数的,虽然也是系统调用的方法,不过他的比较就可以不是当前对象于传入对象的比较了,范围就大多了.
作者: 郑冬    时间: 2012-6-12 18:03
当需要排序的集合或数组不是单纯的数字型时，通常可以使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序。
一、Comparator
强行对某个对象collection进行整体排序的比较函数，可以将Comparator传递给Collections.sort或Arrays.sort。
接口方法：
Java代码
  /**   * @return o1小于、等于或大于o2，分别返回负整数、零或正整数。   */  int compare(Object o1, Object o2);案例：Java代码
import java.util.Arrays;import java.util.Comparator;public class SampleComparator implements Comparator {  public int compare(Object o1, Object o2) {    return toInt(o1) - toInt(o2);  }  private int toInt(Object o) {    String str = (String) o;    str = str.replaceAll("一", "1");    str = str.replaceAll("二", "2");    str = str.replaceAll("三", "3");    //     return Integer.parseInt(str);  }  /**   * 测试方法   */  public static void main(String[] args) {    String[] array = new String[] { "一二", "三", "二" };    Arrays.sort(array, new SampleComparator());    for (int i = 0; i < array.length; i++) {      System.out.println(array);    }  }}二、Comparable
强行对实现它的每个类的对象进行整体排序，实现此接口的对象列表（和数组）可以通过Collections.sort或Arrays.sort进行自动排序。
接口方法：
Java代码
  /**   * @return 该对象小于、等于或大于指定对象o，分别返回负整数、零或正整数。    */  int compareTo(Object o);
假设对象User，需要按年龄排序：
Java代码
public class User {  private String id;  private int age;  public User(String id, int age) {    this.id = id;    this.age = age;  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }  public String getId() {    return id;  }  public void setId(String id) {    this.id = id;  }}改造后的对象：
Java代码
import java.util.Arrays;public class User implements Comparable {  private String id;  private int age;  public User(String id, int age) {    this.id = id;    this.age = age;  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }  public String getId() {    return id;  }  public void setId(String id) {    this.id = id;  }  public int compareTo(Object o) {    return this.age - ((User) o).getAge();  }  /**   * 测试方法   */  public static void main(String[] args) {    User[] users = new User[] { new User("a", 30), new User("b", 20) };    Arrays.sort(users);    for (int i = 0; i < users.length; i++) {      User user = users;      System.out.println(user.getId() + " " + user.getAge());    }  }}三、Comparator和Comparable的区别
先看一下使用Comparator对User集合实现排序的方式：
Java代码
  • 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;  
  •       System.out.println(user.getId() + " " + user.getAge());  
  •     }  
  •   }  
  •   
  • }  

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;      System.out.println(user.getId() + " " + user.getAge());    }  }}
一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准，比如升序、降序等
作者: 邱俊杰    时间: 2012-6-12 18:04
本帖最后由 邱俊杰 于 2012-6-12 18:05 编辑

Comparable  应该是集合自身就具备比较性，但是比较方式不是你想要的，这时候你就可以实现 Comparable，复写CompareTo方法，定义自己的比较方式，比如TreeSet集合是实现自然排序的。如果你不想自然排序就实现Comparable接口。

Comparator 集合存入的数据本身不具备比较性， Comparator能强制实现比较。只要在集合声明比较器就可以了， 个人理解、
作者: 郑冬    时间: 2012-6-12 18:04
这个问题百度可以解决
作者: 黄克帅    时间: 2012-6-12 18:05
当元素自身具备比较性时。元素可以实现comparable接口，重写compareTo方法。这种方式就是元素的自然顺序，或者叫默认数序。
当元素自身不具备比较性，或具备的比较性不是所需要的，这时就需要集合自身具备比较性，在集合初始化时就有了比较性。
即定义一个比较器： 实现comparator接口，重写compare方法
如果同时存在comparable和comparator  以比较器为主
作者: 逝去的记忆ヽ    时间: 2012-6-12 18:06
本帖最后由 逝去的记忆ヽ 于 2012-6-12 18:08 编辑

Comparator:强行对某个对象collection进行整体排序的比较函数，可以将Comparator传递给Collections.sort或Arrays.sort。

Comparable:强行对实现它的每个类的对象进行整体排序，实现此接口的对象列表（和数组）可以通过Collections.sort或Arrays.sort进行自动排序。


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





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2