Comparable和Comparator

Comparable和Comparator是由Java核心API提供的两个接口。Comparable译为可比较的，Comparator译为比较器。从他们的名字中，我们可以看出他们可以用某种方式来比较事物。但是它们到底是什么，它们之间的区别是什么？下面是回答这个问题的两个例子。简单的例子比较两个HDTV的大小。在阅读完代码之后，如何使用比较比较的比较器是显而易见的。

1. Comparable

Comparable需要一个类实现，以便能够比较这个类本生的不同对象。类本身必须实现接口以便能够比较其实例。实现所需的方法是compareTo（）。这是一个例子:

class HDTV implements Comparable<HDTV> {
    private int size;
    private String brand;
 
    public HDTV(int size, String brand) {
        this.size = size;
        this.brand = brand;
    }
 
    public int getSize() {
        return size;
    }
 
    public void setSize(int size) {
        this.size = size;
    }
 
    public String getBrand() {
        return brand;
    }
 
    public void setBrand(String brand) {
        this.brand = brand;
    }
 
    @Override
    public int compareTo(HDTV tv) {
 
        if (this.getSize() > tv.getSize())
            return 1;
        else if (this.getSize() < tv.getSize())
            return -1;
        else
            return 0;
    }
}
 
public class Main {
    public static void main(String[] args) {
        HDTV tv1 = new HDTV(55, "Samsung");
        HDTV tv2 = new HDTV(60, "Sony");
 
        if (tv1.compareTo(tv2) > 0) {
            System.out.println(tv1.getBrand() + " is better.");
        } else {
            System.out.println(tv2.getBrand() + " is better.");
        }
    }
}

结果：

Sony is better.

2. Comparator

在某些情况下，您可能不希望更改一个类并使其具有可比性。在这种情况下，如果您想比较基于某些属性/字段的对象，就可以使用Comparator。例如，可以根据“身高”或“年龄”来比较两个人（这不能用Comparable方式来做）。
实现的方法是compare()。现在让我们用另一种方式来比较那些电视的大小。比较器的一个常见用法是排序。Collections 和 Arrays类都提供了一种使用比较器的排序方法。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
 
class HDTV {
    private int size;
    private String brand;
 
    public HDTV(int size, String brand) {
        this.size = size;
        this.brand = brand;
    }
 
    public int getSize() {
        return size;
    }
 
    public void setSize(int size) {
        this.size = size;
    }
 
    public String getBrand() {
        return brand;
    }
 
    public void setBrand(String brand) {
        this.brand = brand;
    }
}
 
class SizeComparator implements Comparator<HDTV> {
    @Override
    public int compare(HDTV tv1, HDTV tv2) {
        int tv1Size = tv1.getSize();
        int tv2Size = tv2.getSize();
 
        if (tv1Size > tv2Size) {
            return 1;
        } else if (tv1Size < tv2Size) {
            return -1;
        } else {
            return 0;
        }
    }
}
 
public class Main {
    public static void main(String[] args) {
        HDTV tv1 = new HDTV(55, "Samsung");
        HDTV tv2 = new HDTV(60, "Sony");
        HDTV tv3 = new HDTV(42, "Panasonic");
 
        ArrayList<HDTV> al = new ArrayList<HDTV>();
        al.add(tv1);
        al.add(tv2);
        al.add(tv3);
 
        Collections.sort(al, new SizeComparator());
        for (HDTV a : al) {
            System.out.println(a.getBrand());
        }
    }
}

结果：

Panasonic
Samsung
Sony

通常，我们可以使用collections.reverseorder（）方法来降序。如下:

ArrayList<Integer> al = new ArrayList<Integer>();
al.add(3);
al.add(1);
al.add(2);
System.out.println(al);
Collections.sort(al);
System.out.println(al);
 
Comparator<Integer> comparator = Collections.reverseOrder();
Collections.sort(al,comparator);
System.out.println(al);

结果

[3,1,2]
[1,2,3]
[3,2,1]

3. 怎样选择?

简单地说，实现Comparable类将是可比较的，这意味着可以将实例进行比较。
一个类实现了Comparator将用于两种情况:1)它可以传递给一个方法,比如Collections.sort()或Arrays.sort(),允许精确控制排序顺序和2)也可以用来控制某些数据结构的顺序,如排序集(例如TreeSet)或分类地图(例如,TreeMap)。
例如，创建一个TreeSet。我们可以传递构造器比较器或者使对象类具有可比性。

TreeSet(Comparator comparator)

class Dog {
    int size;
 
    Dog(int s) {
        size = s;
    }
}
 
class SizeComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog d1, Dog d2) {
        return d1.size - d2.size;
    }
}
 
public class ImpComparable {
    public static void main(String[] args) {
        TreeSet<Dog> d = new TreeSet<Dog>(new SizeComparator()); // pass comparator
        d.add(new Dog(1));
        d.add(new Dog(2));
        d.add(new Dog(1));
    }
}

实现Comparable

class Dog implements Comparable<Dog>{
    int size;
 
    Dog(int s) {
        size = s;
    }
 
    @Override
    public int compareTo(Dog o) {
        return o.size - this.size;
    }
}
 
public class ImpComparable {
    public static void main(String[] args) {
        TreeSet<Dog> d = new TreeSet<Dog>();
        d.add(new Dog(1));
        d.add(new Dog(2));
        d.add(new Dog(1));
    }
}

1. Comparable
2. Comparator