`

Comparable和Comparator接口

算法设计模式Blog 
阅读更多

当需要排序的集合或数组不是单纯的数字型时，通常可以使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序

Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String Integer自己就可以完成比较大小操作）

而Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。
    comparable是通用的接口，用户可以实现它来完成自己特定的比较，而comparator可以看成一种算法的实现，在需要容器集合collection需要比较功能的时候，来指定这个比较器，这可以看出一种设计模式  
   comparable应该比较固定，和一个具体类相绑定，而comparator比较灵活，它可以被用于各个需要比较功能的类使用。可以说前者属于“静态绑定”，而后者可以“动态绑定”。
　　一个类实现了Camparable接口表明这个类的对象之间是可以相互比较的。如果用数学语言描述的话就是这个类的对象组成的集合中存在一个全序。这样，这个类对象组成的集合就可以使用Sort方法排序了。
　　而Comparator的作用有两个：
　　1. 如果类的设计师没有考虑到Compare的问题而没有实现Comparable接口，可以通过　Comparator来实现比较算法进行排序
　　2. 为了使用不同的排序标准做准备，比如：升序、降序或其他什么序
用法：
实现comparable类的实例就是可以排序的，重写compareTo()，只要调用sort(Object[] a)方法就可以，如果没有实现comparable接口，却调用sort(Object[] a)方法就会报错，因为sort()里面用到的mergeSort()方法将a转化成Comparable类型调用compareTo(T o)方法。
例子：
一。实现comparable接口

Java代码 复制代码
  1. import java.util.Arrays;    
  2. public class User implements Comparable {    
  3. private String id;   
  4. private int age;    
  5. public User(String id，int age) {   
  6.     this.id = id;   
  7.     this.age = age;   
  8. }    
  9. public int getAge() {   
  10.     return age;   
  11. }    
  12. public void setAge(int age) {   
  13.     this.age = age;   
  14. }    
  15. public String getId() {   
  16.     return id;   
  17. }    
  18. public void setId(String id) {   
  19.     this.id = id;   
  20. }    
  21. public int compareTo(Object o) {   
  22.     return this.age - ((User) o).getAge();   
  23. }    
  24. /**  
  25.    * 测试方法  
  26.    */  
  27. public static void main(String[] args) {   
  28.     User[] users = new User[] { new User("a", 30), new User("b", 20) };   
  29.     Arrays.sort(users);   
  30.     for (int i = 0; i < users.length; i++) {   
  31.       User user = users[i];   
  32.       System.out.println(user.getId() + " " + user.getAge());   
  33.     }   
  34. }    
  35. }   
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[i];
      System.out.println(user.getId() + " " + user.getAge());
    }
} 
}


二。comparator接口

Java代码 复制代码
  1. public class Person {   
  2. String firstname,lastname;   
  3. Boolean sex;   
  4. Integer age;   
  5. public Person(String firstname,String lastname,Boolean sex,Integer age) {   
  6.     this.firstname = firstname;   
  7.     this.lastname = lastname;   
  8.     this.sex = sex;   
  9.     this.age = age;   
  10. }   
  11. public String getFirstName() {   
  12.      return firstname;   
  13.    }   
  14.   
  15.    public String getLastName() {   
  16.      return lastname;   
  17.    }   
  18.    public Boolean getSex() {   
  19.       return sex;   
  20.     }   
  21.   
  22.     public Integer getAge() {   
  23.       return age;   
  24.     }   
  25.   
  26. //为了输入方便，重写了toString()   
  27.   
  28. public String toString()   
  29.     {   
  30.       return firstname +" "+lastname+" "+(sex.booleanValue()?"男":"女")+" "+age;   
  31.     }   
  32. }   
  33. //end person   
public class Person {
String firstname,lastname;
Boolean sex;
Integer age;
public Person(String firstname,String lastname,Boolean sex,Integer age) {
    this.firstname = firstname;
    this.lastname = lastname;
    this.sex = sex;
    this.age = age;
}
public String getFirstName() {
     return firstname;
   }

   public String getLastName() {
     return lastname;
   }
   public Boolean getSex() {
      return sex;
    }

    public Integer getAge() {
      return age;
    }

//为了输入方便，重写了toString()

public String toString()
    {
      return firstname +" "+lastname+" "+(sex.booleanValue()?"男":"女")+" "+age;
    }
}
//end person


下面是要实现比较器

Java代码 复制代码
  1. public class Comparators {   
  2. public static java.util.Comparator getComparator() {   
  3.     return new java.util.Comparator() {   
  4.   
  5.       public int compare(Object o1, Object o2) {   
  6.         if (o1 instanceof String) {   
  7.           return compare( (String) o1, (String) o2);   
  8.         }   
  9.        else if (o1 instanceof Integer) {   
  10.           return compare( (Integer) o1, (Integer) o2);   
  11.         }   
  12.   
  13.        else if (o1 instanceof Person) {   
  14.       return compare( (Person) o1, (Person) o2);   
  15.     }   
  16.   
  17.         else {   
  18.           System.err.println("未找到合适的比较器");   
  19.           return 1;   
  20.   
  21.         }   
  22.       }   
  23.   
  24.       public int compare(String o1, String o2) {   
  25.         String s1 = (String) o1;   
  26.         String s2 = (String) o2;   
  27.         int len1 = s1.length();   
  28.         int len2 = s2.length();   
  29.         int n = Math.min(len1, len2);   
  30.         char v1[] = s1.toCharArray();   
  31.         char v2[] = s2.toCharArray();   
  32.         int pos = 0;   
  33.   
  34.         while (n-- != 0) {   
  35.           char c1 = v1[pos];   
  36.           char c2 = v2[pos];   
  37.           if (c1 != c2) {   
  38.             return c1 - c2;   
  39.           }   
  40.           pos++;   
  41.         }   
  42.         return len1 - len2;   
  43.       }   
  44.   
  45.       public int compare(Integer o1, Integer o2) {   
  46.         int val1 = o1.intValue();   
  47.         int val2 = o2.intValue();   
  48.         return (val1 < val2 ? -1 : (val1 == val2 ? 0 : 1));   
  49.   
  50.       }   
  51.       public int compare(Boolean o1, Boolean o2) {   
  52.   
  53.          return (o1.equals(o2)? 0 : (o1.booleanValue()==true?1:-1));   
  54.   
  55.        }   
  56.   
  57.       public int compare(Person o1, Person o2) {   
  58.         String firstname1 = o1.getFirstName();   
  59.         String firstname2 = o2.getFirstName();   
  60.         String lastname1 = o1.getLastName();   
  61.         String lastname2 = o2.getLastName();   
  62.         Boolean sex1 = o1.getSex();   
  63.         Boolean sex2 = o2.getSex();   
  64.         Integer age1 = o1.getAge();   
  65.         Integer age2 = o2.getAge();   
  66.         return (compare(firstname1, firstname2) == 0 ?   
  67.                 (compare(lastname1, lastname2) == 0 ? (compare(sex1, sex2) == 0 ? (compare(age1, age2) == 0 ? 0 :   
  68.                  compare(age1, age2)) :   
  69.                  compare(sex1, sex2)) :   
  70.                  compare(lastname1, lastname2)) :   
  71.                 compare(firstname1, firstname2));   
  72.   
  73.       }   
  74.   
  75.     };   
  76. }   
  77.   
  78. }  
public class Comparators {
public static java.util.Comparator getComparator() {
    return new java.util.Comparator() {

      public int compare(Object o1, Object o2) {
        if (o1 instanceof String) {
          return compare( (String) o1, (String) o2);
        }
       else if (o1 instanceof Integer) {
          return compare( (Integer) o1, (Integer) o2);
        }

       else if (o1 instanceof Person) {
      return compare( (Person) o1, (Person) o2);
    }

        else {
          System.err.println("未找到合适的比较器");
          return 1;

        }
      }

      public int compare(String o1, String o2) {
        String s1 = (String) o1;
        String s2 = (String) o2;
        int len1 = s1.length();
        int len2 = s2.length();
        int n = Math.min(len1, len2);
        char v1[] = s1.toCharArray();
        char v2[] = s2.toCharArray();
        int pos = 0;

        while (n-- != 0) {
          char c1 = v1[pos];
          char c2 = v2[pos];
          if (c1 != c2) {
            return c1 - c2;
          }
          pos++;
        }
        return len1 - len2;
      }

      public int compare(Integer o1, Integer o2) {
        int val1 = o1.intValue();
        int val2 = o2.intValue();
        return (val1 < val2 ? -1 : (val1 == val2 ? 0 : 1));

      }
      public int compare(Boolean o1, Boolean o2) {

         return (o1.equals(o2)? 0 : (o1.booleanValue()==true?1:-1));

       }

      public int compare(Person o1, Person o2) {
        String firstname1 = o1.getFirstName();
        String firstname2 = o2.getFirstName();
        String lastname1 = o1.getLastName();
        String lastname2 = o2.getLastName();
        Boolean sex1 = o1.getSex();
        Boolean sex2 = o2.getSex();
        Integer age1 = o1.getAge();
        Integer age2 = o2.getAge();
        return (compare(firstname1, firstname2) == 0 ?
                (compare(lastname1, lastname2) == 0 ? (compare(sex1, sex2) == 0 ? (compare(age1, age2) == 0 ? 0 :
                 compare(age1, age2)) :
                 compare(sex1, sex2)) :
                 compare(lastname1, lastname2)) :
                compare(firstname1, firstname2));

      }

    };
}

}



//测试

Java代码 复制代码
  1. public class Main {   
  2. public Main() {   
  3. }   
  4. public static void main(String[] args) {   
  5.     Person[] person = new Person[] {   
  6.          new Person("ouyang", "feng", Boolean.TRUE, new Integer(27)),   
  7.          new Person("zhuang", "gw", Boolean.TRUE, new Integer(27)),   
  8.          new Person("zhuang", "gw", Boolean.FALSE, new Integer(27)),   
  9.          new text.Person("zhuang", "gw", Boolean.FALSE, new Integer(2))   
  10.      };   
  11.      for (int i = 0; i < person.length; i++) {   
  12.        System.out.println("before sort=" + person[i]);   
  13.      }   
  14.      java.util.Arrays.sort(person, Comparators.getComparator());   
  15.     for (int i = 0; i < person.length; i++) {   
  16.       System.out.println("after sort=" + person[i]);   
  17.     }   
  18.   
  19. }   
  20.   
  21. }  
public class Main {
public Main() {
}
public static void main(String[] args) {
    Person[] person = new Person[] {
         new Person("ouyang", "feng", Boolean.TRUE, new Integer(27)),
         new Person("zhuang", "gw", Boolean.TRUE, new Integer(27)),
         new Person("zhuang", "gw", Boolean.FALSE, new Integer(27)),
         new text.Person("zhuang", "gw", Boolean.FALSE, new Integer(2))
     };
     for (int i = 0; i < person.length; i++) {
       System.out.println("before sort=" + person[i]);
     }
     java.util.Arrays.sort(person, Comparators.getComparator());
    for (int i = 0; i < person.length; i++) {
      System.out.println("after sort=" + person[i]);
    }

}

}


另一个从网上摘的例子：
1，comparator

Java代码 复制代码
  1. import java.util.Arrays;      
  2. import java.util.Comparator;      
  3.      
  4. public class SampleComparator implements Comparator {      
  5.      
  6.   public int compare(Object o1, Object o2) {      
  7.     return toInt(o1) - toInt(o2);      
  8.   }      
  9.      
  10.   private int toInt(Object o) {      
  11.     String str = (String) o;      
  12.     str = str.replaceAll("一", "1");      
  13.     str = str.replaceAll("二", "2");      
  14.     str = str.replaceAll("三", "3");      
  15.     //       
  16.     return Integer.parseInt(str);      
  17.   }      
  18.      
  19.   /**    
  20.    * 测试方法    
  21.    */     
  22.   public static void main(String[] args) {      
  23.     String[] array = new String[] { "一二", "三", "二" };      
  24.     Arrays.sort(array, new SampleComparator());      
  25.     for (int i = 0; i < array.length; i++) {      
  26.       System.out.println(array[i]);      
  27.     }      
  28.   }      
  29.      
  30. }  
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[i]);   
    }   
  }   
  
}

 

2，comparable

Java代码 复制代码
  1. import java.util.Arrays;      
  2.      
  3. public class User implements Comparable {      
  4.      
  5.   private String id;      
  6.   private int age;      
  7.      
  8.   public User(String id, int age) {      
  9.     this.id = id;      
  10.     this.age = age;      
  11.   }      
  12.      
  13.   public int getAge() {      
  14.     return age;      
  15.   }      
  16.      
  17.   public void setAge(int age) {      
  18.     this.age = age;      
  19.   }      
  20.      
  21.   public String getId() {      
  22.     return id;      
  23.   }      
  24.      
  25.   public void setId(String id) {      
  26.     this.id = id;      
  27.   }      
  28.      
  29.   public int compareTo(Object o) {      
  30.     return this.age - ((User) o).getAge();      
  31.   }      
  32.      
  33.   /**    
  34.    * 测试方法    
  35.    */     
  36.   public static void main(String[] args) {      
  37.     User[] users = new User[] { new User("a", 30), new User("b", 20) };      
  38.     Arrays.sort(users);      
  39.     for (int i = 0; i < users.length; i++) {      
  40.       User user = users[i];      
  41.       System.out.println(user.getId() + " " + user.getAge());      
  42.     }      
  43.   }      
  44.      
  45. }    
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[i];   
      System.out.println(user.getId() + " " + user.getAge());   
    }   
  }   
  
}


Java代码 复制代码
  1. import java.util.Arrays;      
  2. import java.util.Comparator;      
  3.      
  4. public class UserComparator implements Comparator {      
  5.      
  6.   public int compare(Object o1, Object o2) {      
  7.     return ((User) o1).getAge() - ((User) o2).getAge();      
  8.   }      
  9.      
  10.   /**    
  11.    * 测试方法    
  12.    */     
  13.   public static void main(String[] args) {      
  14.     User[] users = new User[] { new User("a", 30), new User("b", 20) };      
  15.     Arrays.sort(users, new UserComparator());      
  16.     for (int i = 0; i < users.length; i++) {      
  17.       User user = users[i];      
  18.       System.out.println(user.getId() + " " + user.getAge());      
  19.     }      
  20.   }      
  21.      
  22. }    
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());   
    }   
  }   
  
}



从http://hi.baidu.com/kinny/blog/item/4b3eba7e93c453380cd7da16.html 摘的一段：
1.对象本身实现Comparable接口,那么该类的实例就是可以排序的.
有关Comparable: http://blog.csdn.net/treeroot/archive/2004/09/09/99613.aspx
只要实现了Comparable接口,就可以调用Collections的sort方法对集合中的元素排序.

2.指定一个Comparator,也就是实现了Comparator的类的一个实例.
但是Java本身只提供了一个Comparator的实现,就是Collections.reverseOrder().
该方法返回的是一个已经实现了Comparable接口的反序.

看一下Comparator的全部内容:

public interface Comparator {
　　int compare(Object o1, Object o2);
　　boolean equals(Object obj);
}
定义了两个方法,其实我们一般都只需要实现compare方法就行了,因为类都是默认从Object继承
所以会使用Object的equals方法.
Comparator一般都作为一个匿名类出现,对于没有实现Comparable的对象的集合,排序的时候
需要指定一个Comparator.

分享到：
| 手工打包JAR
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    详解Java中Comparable和Comparator接口的区别

    * 一个类实现了Comparator接口，那么它就是一个“比较器”。其它的类，可以根据该比较器去排序。 * * 综上所述：Comparable是内部比较器，而Comparator是外部比较器 */ ``` Java 中的 Comparable 和 ...

    java中Comparable和Comparator的区别

    在Java编程语言中，Comparable和Comparator接口是两个重要的概念，它们都用于对象的排序，但有着不同的使用场景和特点。本文将深入探讨这两个接口的区别，以及它们在实际开发中的应用。 首先，我们来了解一下...

    Java中Comparable和Comparator的区别

    在Java编程语言中，Comparable和Comparator接口是两个非常重要的组件，它们主要用来进行对象的比较和排序。了解它们之间的区别对于提升代码的可维护性和灵活性至关重要。 Comparable接口来源于java.lang包，它定义...

    comparator接口与Comparable接口的区别

    Comparator接口与Comparable接口是Java语言中两个重要的接口，它们都是用于比较和排序自定义类的对象的大小的。虽然它们两个都是用于比较的接口，但是它们有着不同的实现方式和应用场景。 相同之处：Comparator接口...

    Comparable接口和Comparator使用示例

    Comparable 接口和 Comparator 使用示例 在 Java 编程语言中，比较和排序是非常常见的操作。Comparable 接口和 Comparator 是两种常用的比较和排序方式。在本文中，我们将通过实例代码，详细介绍 Comparable 接口和...

    Comparable&Comparator区别

    #### 三、Comparator接口解析 ##### 1. 概念介绍 `Comparator`接口同样位于`java.lang`包中，它提供了更灵活的方式来比较不同类型的对象。当我们希望根据特定标准（比如按照年龄降序）对对象进行排序时，可以实现`...

    Java Comparable及Comparator接口区别详解

    Java Comparable及Comparator接口区别详解 Java 中的 Comparable 和 Comparator 接口都是用来比较对象大小的，但是它们之间有着非常重要的区别。 首先，让我们来了解一下 Comparable 接口。Comparable 接口位于 ...

    Comparable和Comparator区分1

    Comparator接口的灵活性在于，我们可以为同一类型的对象创建多个不同的比较器，从而实现多维度、多条件的排序。 总结一下，Comparable接口适用于对象本身具有排序意义的情况，比如根据对象的属性进行自然排序；而...

    对比Java中的Comparable排序接口和Comparator比较器接口

    在Java编程语言中，Comparable和Comparator接口用于对对象进行比较和排序。这两个接口在很多情况下都能派上用场，但它们的应用场景和实现方式有所不同。 首先，Comparable接口是排序接口，意味着一个类如果实现了...

    java 中Comparable与Comparator详解与比较

    在Java编程语言中，Comparable和Comparator接口用于比较对象的顺序，尤其在进行排序操作时非常关键。两者虽然目的相似，但使用方式和应用场景有所区别。 Comparable接口定义在`java.lang`包中，它只有一个方法`...

    Java中Comparable和Comparator 2种实现方式学习

    在Java编程语言中，排序是常见的操作，而`Comparable`和`Comparator`接口则是实现对象排序的两种主要方式。这篇文章将深入探讨这两种实现方式及其在实际编程中的应用。 首先，`Comparable`接口位于`java.lang`包下...

    浅析Java中comparator接口与Comparable接口的区别

    在Java编程语言中，Comparable和Comparator接口都用于比较对象，但它们之间存在一些关键区别，这对于理解和优化代码的可扩展性至关重要。 首先，Comparable接口是一个排序接口，它定义了一个单一的方法`compareTo(T...

    Comparable与Comparator的区别

    Comparator接口位于`java.util`包下，用于提供一种外部比较的方式，即不改变对象本身，而是通过一个专门的比较器对象来决定两个对象的大小关系。这种设计模式被称为策略模式，它可以灵活地改变对象的排序策略。 当...

    Java Comparable和Comparator对比详解

    Java Comparable和Comparator对比...在实际项目开发过程中，我们经常需要对某个对象或者某个集合中的元素进行排序，使用 Comparable 接口和 Comparator 接口可以实现自定义的排序规则，提高代码的灵活性和可维护性。

    Comparable与Comparator的区别Java开

    在Java编程语言中，`Comparable`接口和`Comparator`接口是两种重要的排序机制，它们用于对集合中的对象进行比较和排序。理解它们的区别对于任何Java开发者来说都是至关重要的。 首先，`Comparable`接口位于`java....

    Java 比较接口comparable与comparator区别解析

    Java 语言中提供了两个比较接口： Comparable 和 Comparator，这两个接口都是用于比较对象的大小顺序的，但它们有着不同的使用场景和实现方式。在本文中，我们将详细介绍这两个接口的区别和使用方法。 Comparable ...

    java排序Comparator和Comparable

    在Java编程语言中，排序是数据处理中一个非常常见的需求，而`Comparator`和`Comparable`接口则是实现排序的关键工具。这两个接口都是用于比较对象，但它们的应用场景和使用方式有所不同。 首先，`Comparable`接口是...

    Comparable接口和Comparator接口的比较

    Comparable接口和Comparator接口是Java中用于排序的关键组件，它们在数据结构如数组、集合和映射的排序过程中扮演着重要角色。接下来我们将深入探讨这两个接口的特性、用途以及它们之间的区别。 1. Comparable接口...

Magicbox
Global site tag (gtag.js) - Google Analytics