您的位置：首页 > 编程语言 > Java开发

Java中Comparable和Comparator区别小结

2017-11-15 15:09 423 查看

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;

       }

}[/b]

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

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

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航