Java中Comparable和Comparator区别小结

Java中Comparable和Comparator区别小结

源码比较：

Comparable：

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

Comparator

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

一·Comparable

    1.简介：

    Comparable是排序接口。若一个类实现了Comparable接口，意味着该类支持排序。

     实现了Comparable接口的类的对象的列表可以通过Collections.sort或Arrays.sort进行自动排序。

     从源码中可以看出，实现此对象可以用作有序映射中的键或有序集合中的集合，无需指定比较器。

     其中，T表示可以与此对象比较的那些对象的类型。

     此接口只有一个方法compare,比较次对象与指定对象的顺序，如果该对象小于，等于或大于指定对象，则分别返回负整数，零或正整数。

   2.编写代码：

条件：1.一个类。

      比如：

       

public class Person{    private String name;        private int age;          public String getName() {               return name;        }        public void setName(String name) {               this.name = name;        }          public int getAge() {               return age;        }          public void setAge(int age) {               this.age = age;        } }

 

      2.该类实现Comparable接口，实现接口中的方法

      

package comparable;   public class Person implements Comparable<Person>{        private String name;        private int age;          public String getName() {               return name;        }        public void setName(String name) {               this.name = name;        }          public int getAge() {               return age;        }          public void setAge(int age) {               this.age = age;        }        @Override        public int compareTo(Person o) {               return this.age-o.age;        } }

 

      3.实例化几个该类的对象，进行比较排序

package comparable;   import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Iterator; import java.util.List;   import org.junit.Test;   public class TestConparable {        /**         * 数组型比较(本例中增强型for循环和普通for循环本质是一样的，只是为了增强知识的掌握)         */ @Test        public void test01() throws Exception {               // 准备好四个对象(数组型)               Person[] persons = new Person[] { new Person("张三", 12),                             new Person("李四", 15), new Person("zhangsan", 12),                             new Person("lisi", 11) };               // 排序前               for (Person person : persons) {                      System.out.print(person + "  ");               }               System.out.println();               // 进行排序               Arrays.sort(persons);               for (int i = 0; i < persons.length; i++) {                      System.out.print(persons[i] + "  ");               }        }               /**         * 集合型比较(本例中增强型for循环和迭代器本质是一样的，只是为了增强知识的掌握)         */ @Test        public void test02() throws Exception {               List<Person> list = new ArrayList<Person>();               list.add(new Person("张三", 12));               list.add(new Person("李四", 15));               list.add(new Person("zhangsan", 12));               list.add(new Person("lisi", 11));               Iterator<Person> it = list.iterator();               // 排序前               while (it.hasNext()) {                      Person person = (Person) it.next();                      System.out.print(person + "  ");               }               System.out.println();               // 排序               Collections.sort(list);               for (Person person : list) {                      System.out.print(person + "  ");               }          } }

4.运行结果：

二.Comparator

  1.简介：

    Comparator是比较接口，我们如果需要控制某个类的次序，而该类本身不支持排序（即没有实现Comparable接口），那么我们就可以建立一个“该类的比较器”来进行排序，这个“比较器”只需要实现Comparator接口即可。也就是说，我们可以通过实现Comparator来新建一个比较器，然后通过这个比较器对类进行排序，该接口定义如下：

   若一个类要实现Comparator接口：它一定要实现compareTo(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。

　　int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”。

   2.编写代码：

  条件：1.一个类，未实现比较接口。

package comparator; public class Person{        private String name;        private int age;     public Person(){               }     public Person(String name,int age){           this.name=name;           this.age=age;     }        public String getName() {               return name;        }        public void setName(String name) {               this.name = name;        }          public int getAge() {               return age;        }          public void setAge(int age) {               this.age = age;        }        @Override        public String toString() {               return "Person [name=" + name + ", age=" + age + "]";        } }

    2.构造一个“比较器”

package comparator; import java.util.Comparator; public class MyComparator implements Comparator<Person> {        @Override        public int compare(Person p1, Person p2) {               return p1.getAge() - p2.getAge();        } }

    3.进行比较

package comparator;   import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Iterator; import java.util.List; import org.junit.Test;     public class TestComparator {        /**         * 数组型比较(本例中增强型for循环和普通for循环本质是一样的，只是为了增强知识的掌握)         */        @Test        public void test01() throws Exception {        // 准备好四个对象(数组型)                      Person[] persons = new Person[] { new Person("张三", 12),                                    new Person("李四", 15), new Person("zhangsan", 12),                                    new Person("lisi", 11) };                      // 排序前                      for (Person person : persons) {                             System .out.print(person + "  ");                      }                      System.out.println();                      // 进行排序                      Arrays.sort(persons,new MyComparator());                      for (int i = 0; i < persons.length; i++) {                             System.out.print(persons[i] + "  ");                      }                      System.out.println();               }                          /**                * 集合型比较(本例中增强型for循环和迭代器本质是一样的，只是为了增强知识的掌握)                */               @Test               public void test02() throws Exception {                      List<Person> list = new ArrayList<Person>();                      list.add(new Person("张三", 12));                      list.add(new Person("李四", 15));                      list.add(new Person("zhangsan", 12));                      list.add(new Person("lisi", 11));                      Iterator<Person> it = list.iterator();                      // 排序前                      while (it.hasNext()) {                             Person person = (Person) it.next();                             System.out.print(person + "  ");                      }                      System.out.println();                      // 排序                      Collections.sort(list,new MyComparator());                      for (Person person : list) {                             System.out.print(person + "  ");                      }               } }

      4.运行结果：

三，异同分析：

Comparable	comparator	解释
源代码： public interface Comparable<T> { public int compareTo(T o); }	源代码： public interface Comparator<T> { int compare(T o1, T o2);     boolean equals(Object obj); }	1.实现方法不同，传入的参数相同，参数个数不同。但是，返回值是一样的。
实现形式： Public class Person implements comparable<Person>{ …        @Override        public int compareTo(T o) {               return this.x-o.x;        } }	实现方式： public class Person{ ….} public class MyComparator implements Comparator<Person> {        @Override        public int compare(T o1, T o2) {        return o1.getx() - o2.getx();        }   }	2.实现方式不同，前者是在本类中实现，后者是类外部实现，保障了本类代码不篡改的前提下。
测试代码： Arrays.sort(Object[] a); Collections.sort(List<T> list);	测试代码： Arrays.sort(T[] a, Comparator<? super T> c) Collections.sort(List<T> list, Comparator<? super T> c)	3.测试代码方式不同，前者是一个参数直接传入数组或者集合对象， 后者是两个参数，先传入待比较数组或者集合对象，再传入比较器

总结：

    1.Comparable是一种“内部比较器”，Comparator是一种“外部比较器”。

2.Comparator中的equals方法可以不实现，也可以实现。Java中，规定，接口中的方法都要实现，equals方法因为是Object类中的，是每个类都与生俱来的方法。

3. 两种方法各有优劣， 用Comparable 简单， 只要实现Comparable接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。 用Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了， 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。

 

参考文档：https://www.cnblogs.com/xujian2014/p/5215082.html

   本内容由安康学院“雨季”原创。