关于对象值的比较顺序

认识 Comparable

public interface Comparable<E> {
    // 返回值:
    // < 0: 表示 this 指向的对象小于 o 指向的对象
    // == 0: 表示 this 指向的对象等于 o 指向的对象
    // > 0: 表示 this 指向的对象等于 o 指向的对象
    int compareTo(E o);
}

示例

package package11_3;
class Card implements Comparable<Card>{
    private int rank;
    private String suit;

    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
    //根据数值比较

    @Override
    public int compareTo(Card o) {
        if(o == null){
            return 1;
        }
        return rank - o.rank;
    }
}
public class Test_11_3{
    public static void main(String[] args) {
        Card p = new Card(1,"♣");
        Card q = new Card(2,"♣");
        Card o = new Card(1,"♦");
        System.out.println(p.compareTo(o));//==0表示牌相等
        System.out.println(p.compareTo(q));//<0,表示p的值比q的小
        System.out.println(q.compareTo(p));//>0,表示q的值比p的大
    }
}

上面的对象值比较是基于自然顺序的
下面我们介绍一些，关于对象的比较—基于比较器

public interface Comparator<T> {
    // 返回值:
    // < 0: 表示 o1 指向的对象小于 o2 指向的对象
    // == 0: 表示 o1 指向的对象等于 o2 指向的对象
    // > 0: 表示 o1 指向的对象等于 o2 指向的对象
    int compare(T o1, T o2);
}

比较器方法：

package package11_3;

import java.util.Comparator;

class Card1{
    private int rank;
    private String suit;

    public Card1(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    public int getRank() {
        return rank;
    }
}
public class CardComparator implements Comparator<Card1> {
    @Override
    public int compare(Card1 o1, Card1 o2) {
        if(o1 == o2){
            return 0;
        }
        if(o1 == null){
            return -1;
        }
        if(o2 == null){
            return 1;
        }
        return o1.getRank() - o2.getRank();
    }

    public static void main(String[] args) {
        Card1 p = new Card1(1,"♣");
        Card1 q = new Card1(2,"♣");
        Card1 o = new Card1(1,"♣");
        Comparator<Card1> comparator = new CardComparator();
        System.out.println(comparator.compare(p,o));
        System.out.println(comparator.compare(p,q));
        System.out.println(comparator.compare(q,p));
    }
}

比较

覆写的方法	说明
Object.equals()	因为所有的类都是继承自Object，所以直接覆写即可，不过只能比较是否相等
Comparable.compareTo	动手实现接口，侵入性比较强，但一旦实现，每次用该类都有顺序，属于内部顺序
Comparator.compare	需要实现一个比较器对象，对待比较类的侵入性较弱

和Java集合类的框架配合

1. 使用 contains 类似的方法，内部基本在调用元素的 equals 方法，所以要求元素覆写过 equals 方法
2. 使用 HashMap，key 的比较内部会调用 equals 方法，所以要求元素覆写过 equals 方法
3. 使用排序相关方法，内部需要进行比较，所以或者选择实现 Comparable 或者传入一个 Comparator
4. 使用 TreeMap，key 需要进行大小比较，所以或者选择实现 Comparable 或者传入一个 Comparator