Comparator和Comparable在排序中的应用

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

一、Comparator

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

接口方法：

  /**
   * @return o1小于、等于或大于o2，分别返回负整数、零或正整数。
   */
  int compare(Object o1, Object o2);

案例：

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]);
    }
  }

}

 二、Comparable

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

接口方法：

  /**
   * @return 该对象小于、等于或大于指定对象o，分别返回负整数、零或正整数。 
   */
  int compareTo(Object o);

假设对象User，需要按年龄排序：

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;
  }

}

改造后的对象：

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());
    }
  }

}

项目中用到的排序。

public void ascSortByPONumber() {
Collections.sort(results, new Comparator<QuoteAndFindingsSearchResultsVO>() {
public int compare(QuoteAndFindingsSearchResultsVO arg0, QuoteAndFindingsSearchResultsVO arg1) {
return arg1.getPoNumber().compareTo(arg0.getPoNumber());
}
});
}

public void descSortByPONumber() {
Collections.sort(results,new Comparator<QuoteAndFindingsSearchResultsVO>() {
public int compare(QuoteAndFindingsSearchResultsVO arg0, QuoteAndFindingsSearchResultsVO arg1) {
return arg0.getPoNumber().compareTo(arg1.getPoNumber());
}
});
}

三、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(数组a);它也使我理所应当的认为：Arrays这个类完全实现这个sort的方法，而实际上并非如此，先看下sort的原型：public static <T extends Comparable<? super T>> void sort(List<T> list)，蓝色部分即是说你要排序的这个集合元素已经实现了接口Comparable，等等，我好像没有实现任何Comparable接口，事实上，String类和所有的包装类对象在java API中已经实现了这个接口。参考API：

      public final class String extends implements , <>,

      如果你尝试为没有实现Comparable接口的元素排序，编译器会出错：The generic method sort(List<T>) of type Collections is not applicable for the arguments(ArrayList<你刚编写的类>). The inferred type 你刚编写的类is not a valid substitute for the bounded parameter <T extends Comparable<? super T>>。

        此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序，类的 compareTo 方法被称为它的自然比较方法。实现此接口的对象列表（和数组）可以通过Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射表中的键或有序集合中的元素，无需指定比较器。对于类C的每一个 e1 和 e2 来说，当且仅当 (e1.compareTo((Object)e2) == 0) 与 e1.equals((Object)e2) 具有相同的布尔值时，类 C 的自然排序才叫做与 equals 一致。注意，null 不是任何类的实例，即使 e.equals(null) 返回 false，e.compareTo(null) 也会抛出 NullPointerException。强烈推荐（虽然不是必需的）使自然排序与 equals 一致。这是因为在使用其自然排序与 equals 不一致的元素（或键）时，没有显式比较器的有序集合（和有序映射表）行为表现“怪异”。尤其是，这样的有序集合（或有序映射表）违背了根据 equals 方法定义的集合（或映射表）的常规协定。例如，如果将两个键 a 和 b 添加到一个没有使用显式比较器的有序集合中，使得 (!a.equals((Object)b) && a.compareTo((Object)b) == 0)，则第二个 add 操作返回 false（有序集合的大小没有增加），因为从有序集合的角度来看，a 和 b 是等效的。   实现了comparable接口的类，其对象可以作为SortedMap的key，或者SortedSet的元素。

       我们只能在类中实现compareTo()一次，不可能说经常来修改类的代码实现自己想要的排序，因此如果要以不同于compareTo()方法中指定的顺序排序我们的类对象，那么该怎么办呢？大家一定注意到Collections.sort()有一个重载版本。 public static <T> void sort(List<T> list, Comparator<? super T> c)根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较（也就是说，对于列表中的任意 e1 和 e2 元素，c.compare(e1, e2) 不得抛出 ClassCastException）。此排序被保证是稳定的：不会因调用 sort 而对相等的元素进行重新排序。 Comparator<? super T> c 第二个参数是实现了接口Comparator的实例对象。注意这两者的区别，Comparable 接口的方法：public int compareTo(T o)，绝不会是Object; 只有一个参数，而Comparator接口却有两个参数：int compare(T o1, T o2);

     Comparator 可以通过 Collections类的reverseOrder()这个方法强势返回对Comparable排序的倒转，如：Arrays.sort(a, Collections.reverseOrder()); 如果是String，就是按照逆字典顺序进行排序。

      这两个接口和集合类本身无关，但通常和集合内的元素有关，因为集合的排序要用到它们中的方法。一个类的实例要想实现排序，必须实现Comparable，或者提供相应的Comparator。说清楚这两者的来历与大概的作用，以及共同点，那么再说下他们两者的区别。只是Comparable（可比较的）是在集合内部定义的方法实现的排序，比如，两个人要比较身高，分辨高矮是人类固有的能力，两个人只要站到一起就能分出谁高谁矮。Comparator（比较器）是在集合外部实现的排序。所以，如想实现排序，就需要在集合外定义Comparator接口的方法compare()或在集合内实现Comparable接口的方法compareTo()，Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String Integer自己就可以完成比较大小操作）而Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。还有个地方就是，实现Comparable只能定义一种比较方法，但是有时候会对一个集合进行不同的排序方法，此时就可以提供别各种各样的Comparator来对集合排序，而对于要排序的元素不需要更改，所以我觉得Comparator提供了更多的灵活性。使用这种策略来比较时，如何进行比较和两个对象本身无关，而是由第三者（即比较器）来完成的。只要实现Comparator接口，任何一个对象都可能成为一个“比较器”，但比较器并不是比较自己的实例，而是比较另外两个对象，比较器在这里充当“仲裁者”的角色，这也就是为什么compare()方法需要两个参数。比如，两个人要比较谁智商更高，靠他们自身无法进行，这时要借助一个比较器（比如，智商测试题）。那么先看一个非常简单易懂的示例：

import java.util.*;
public class Pockets {
   public static void main(String[] args) {
      String[] sa = {"nickel", "button", "key", "lint"};
      Sorter s = new Sorter();    //新建一个排序器
      for(String s2: sa){ System.out.print(s2 + " "); }   
      Arrays.sort(sa, s);    //这个排序器s是与sa这个类对象是相关。
      System.out.println();
      for(String s2:sa){ System.out.print(s2+" "); }
     }
   static class Sorter implements Comparator<String>{  //注意红色的部分就是你要去排序的类，如果你文不对题，硬让这个类去排序一个未知的class Dog的类，会报错：The method sort(T[], Comparator<? super T>) in the type Arrays is not applicable for the arguments (UU[], Pockets.Sorter)
      public int compare(String a, String b){
         return a.compareTo(b);
      }
   }
}

        再在更加复杂的概念上理解这个排序机制，在网上找到一个例子，维护一个简单的员工数据库，每个员工是一个Employee类的实例。Employee类可定义为：

public class Employee {    
    private String num;
    private String name;
    private int age;
    private int salary;
    
    public Employee(String num, String name) {
        this.num = num;
        this.name = name;
    }
    
    public void setName(String newNum) {
        num = newNum;
    }

    public void setAge(int newAge) {
        age = newAge;
    }

    public void setSalary(int newSalary) {
        salary = newSalary;
    }

    public String getNum() {
        return num;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public int getSalary() {
        return salary;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("Employee Information：");
        sb.append("\n");
        sb.append("Number：");
        sb.append(getNum());
        sb.append("\n");
        sb.append("Name：");
        sb.append(getName());
        sb.append("\n");
        sb.append("Age：");
        sb.append(getAge());
        sb.append("\n");
        sb.append("Salary：");
        sb.append(getSalary());
        sb.append("\n");
        return sb.toString();
    }
}

EmployeeDatabase类创建Employee类的实例，并把它们存入集合：
Java code

import java.util.*;

public class EmployeeDatabase {    
    public static void main(String[] args) {        
        List<Employee> allEmployees = new ArrayList<Employee>();
        
        Employee employee1 = new Employee("AAA", "Barack Omaba");
        employee1.setAge(50);
        employee1.setSalary(9999);
        allEmployees.add(employee1);
        
        Employee employee2 = new Employee("BBB", "George Bush");
        employee2.setAge(60);
        employee2.setSalary(5999);
        allEmployees.add(employee2);
        
        System.out.println(allEmployees);

    }

}

       现在，你需要检索所有员工，并让他们按一定顺序显示（比如按年龄递增），这时需要用到Collections.sort()方法。Collections.sort()有两种策略：一种是让集合元素本身实现Comparable接口，另一种是使用用户提供的比较器（即Comparator）。使用第一种策略时，必须修改元素类的定义，让它实现Comparable，因此，你必须把Employee类修改为：

public class Employee implements Comparable<Employee> {    
    public int compareTo(Employee another) {
        return getAge() - another.getAge();
    }    
    // 其余部分不变
}

      说明一下，因为compareTo()方法约定：本对象大于另一个对象时，返回大于0的整数，小于时返回小于0的整数，等于时返回0。所以，可以直接返回两者年龄的差，来实现按年龄比较。这样就可以在main()方法中使用Collections.sort(allEmployees);来对员工按年龄排序了。但是，这种排序是非常不灵活的：第一，需要修改集合元素类Employee，而很多情况下，我们没有办法修改公共的类。第二，没有办法实现多种方式排序，如按编号，按姓名，按薪水等等。这时需要使用另一种策略，即Comparator。Comparator使用其compare()方法返回的整数来比较两个对象，规则和compareTo()一样。如同样实现年龄比较，使用Comparator时，无需修改Employee类，可以在排序的时候定义相应的比较器。使用Collections.sort()方法的另一个版本：
Collections.sort(allEmployees, new Comparator<Employee>() {
    public int compare(Employee one, Employee another) {
        return one.getAge() - another.getAge();
    }
});

这里使用了匿名内部类，实际上相当于先定义一个比较器类，如：

class EmployeeComparator implements Comparator<Employee> {    
    public int compare(Employee one, Employee another) {
        return one.getAge() - another.getAge();
    }
    
}

再使用：
Collections.sort(allEmployees, new EmployeeComparator());
可以看到，比较器完全独立于元素类Employee，因此可以非常方便地修改排序规则。你还可以定义一系列比较器，供排序时选择使用，如：

// 按薪水升序
class EmployeeSalaryAscendingComparator implements Comparator<Employee> {    
    public int compare(Employee one, Employee another) {
        return one.getSalary() - another.getSalary();
    }
    
}

// 按薪水降序
class EmployeeSalaryDescendingComparator implements Comparator<Employee> {
    
    public int compare(Employee one, Employee another) {
        return another.getSalary() - one.getSalary();
    }
    
}

相应的使用方法如：
Collections.sort(allEmployees, new EmployeeSalaryAscendingComparator());
Collections.sort(allEmployees, new EmployeeSalaryDescendingComparator());

       使用Comparator时，元素类无需实现Comparable，因此我们保持最初版本的Employee，但实际应用中，可以用Comparable的compareTo()方法来定义默认排序方式，用Comparator定义其他排序方式。实现其compare（T o1,T o2）有一个约定，就是 a.compare(b) == 0 和a.equals(b)要有相同的boolean结果。

　此篇博客整理自网络

　　

　　Collections and Collection

　　Collection是一个集合接口，Collections是一个包装类（或帮助类），这是二者最明显的区别。Collections提供了一 些static方法来对 Collection对象进行处理，比如：对Collection对象的复制、添加元素、修改元素、对元素进行排序、交换俩个元素的位置、取 Collection的子集等等操作。另外Collection是j2sdk中集合框架的根接口，所有的其他特殊类型的结合接口或者类都直接或间接的实现 了这个接口。

　　java.util.Collections   API >>

---

 1 public interface Collection<E> extends Iterable<E> { 2     int size(); 3     boolean isEmpty(); 4     boolean contains(Object o); 5     Iterator<E> iterator(); 6     Object[] toArray(); 7     <T> T[] toArray(T[] a); 8     boolean add(E e); 9     boolean remove(Object o);10     boolean containsAll(Collection<?> c);11     boolean addAll(Collection<? extends E> c);12     boolean removeAll(Collection<?> c);13     boolean retainAll(Collection<?> c);14     void clear();15     boolean equals(Object o);16     int hashCode();17 }

 

　　java.util.Collections   API >>

---

1 public class Collections {2   //注意Collections只是Collection集合接口的一个帮助类，并没有implements Collection  3   ... ...  4 }

 

　　Comparator and Comparable　

　　Comparator和Comparable都是接口，俩者之间可以说没什么关系。Comarator位于包java.util下，而Comparable位于包 java.lang下。通俗的说：Comparator是一个比较器，相当于一种工具，它定义了俩个方法，分别是 int compare(T o1, T o2)和 boolean (Object obj)，所以你可以通过实现这个接口来定义你所有需要的比较器，如比较俩个人的大小，对象人有姓名、性别、年龄等属性，你在定义这个比较器的时候就可以在compare方法中对传入的俩个参数（person1，person2）的年龄进行大小的比较，从而确定这俩个人的大小。 
　　Comparable接口是你要是定义的类要实现的一个接口（如果这个类的实例需要和同一类的别的实例比较大小，而这个大小关系你希望是你自己定义的），它只提供了 int compareTo(T o)方法，也就是说假如我定义了一个Person类，这个类实现了 Comparable接口，那么当我实例化Person类的person1后，我想比较person1和一个现有的Person对象person2的大小时，我就可以这样来调用：person1.comparTo(person2),通过返回值就可以判断了；而此时如果你定义了一个 PersonComparator（实现了Comparator接口）的话，那你就可以这样：PersonComparator comparator= new PersonComparator();comparator.compare(person1,person2);。

　　java.lang.Comparable API >>

---

1 public interface Comparable<T> {2     public int compareTo(T o);3 }

　   此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
　　实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射表中的键或有序集
合中的元素，无需指定比较器。

　java.util.Comparator API >>

---

1 public interface Comparator<T> {2     int compare(T o1, T o2);3     boolean equals(Object obj);4 }

 　　比较函数强行对某些对象 collection 进行整体排序。可以将 Comparator 传递给 sort 方法（如 Collections.sort），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如 TreeSet 或 TreeMap）的顺序。

 

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

　　Comparator和Comparable的区别如下：

Comparable用在对象本身，说明这个对象是可以被比较的，也就是说可以被排序的。（String和Integer之所以可以比较大小，是因为它们都实现了Comparable接口，并实现了compareTo()方法）。

Comparator用在对象外面，相当于定义了一套排序算法来排序。

　　
　　　java.lang.String  API >>

---

 

 1 public final class String implements java.io.Serializable, Comparable<String>, CharSequence{
　　　　... ...
　　　　//String和Integer之所以可以比较大小，是因为它们都实现了Comparable接口，并实现了compareTo()方法 2     public int compareTo(String anotherString) { 3     int len1 = count; 4     int len2 = anotherString.count; 5     int n = Math.min(len1, len2); 6     char v1[] = value; 7     char v2[] = anotherString.value; 8     int i = offset; 9     int j = anotherString.offset;10 11     if (i == j) {12         int k = i;13         int lim = n + i;14         while (k < lim) {15         char c1 = v1[k];16         char c2 = v2[k];17         if (c1 != c2) {18             return c1 - c2;19         }20         k++;21         }22     } else {23         while (n-- != 0) {24         char c1 = v1[i++];25         char c2 = v2[j++];26         if (c1 != c2) {27             return c1 - c2;28         }29         }30     }31     return len1 - len2;32     }33 }

 

　　下面通过具体的例子来理解Comparator和Comparable的区别：

　　 Comparator实例如下：

 

 1 class Name implements Comparable<Name>{   2     public String firstName,lastName;   3     public Name(String firstName,String lastName){   4         this.firstName=firstName;   5         this.lastName=lastName;   6     }   7     //实现接口  8     public int compareTo(Name o) {            9         int lastCmp=lastName.compareTo(o.lastName);  10         return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));  11     }    12     //便于输出测试  13     public String toString(){                14         return firstName+" "+lastName;  15     }  16 } 

 

 1 public class NameSort {   2      public static void main(String[] args) {   3          Name nameArray[] = {   4             new Name("John", "Lennon"),   5             new Name("Karl", "Marx"),   6             new Name("Groucho", "Marx"),   7             new Name("Oscar", "Grouch")   8         };  9         Arrays.sort(nameArray);  10         System.out.println(Arrays.toString(nameArray));;  11     }  12 } 

　　运行结果：[Oscar Grouch, John Lennon, Groucho Marx, Karl Marx]
　　Comparable实例如下：

 

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

 

　　运行结果：b 20
　　　　　　　a 30