Java对象的比较

对象值的比较

“==” 与 “equals()”

p == q 表示的是p 和 q 身份是否相同，意思是 p 和 q 两个引用是否指向相同的对象。
p.equals(q) 表示的是 p 指向的对象 和 q 指向的对象的值是否相等
但是equals默认是

实例

先间一个Card类：

static class Card{
        public int rank ;
        public String suit;

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

然后new两个对象

public static void main(String[] args) {
        Card p = new Card(1,"红桃");
        Card q = new Card(2,"♥");
        Card o = p;
        System.out.println(p.equals(q));
        System.out.println(p.equals(o));
    }

输出结果：
false
true

由此可见，如果不重写 equals,默认的equals逻辑是使用“==”进行比较身份
重写equals后：

class Card {
    //扑克牌
    public String rank ;
    public String suit;

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

    @Override
    public  boolean equals(Object obj) {
        //首先需要比较身份是否相同
        if(this == obj){
            return true;
        }
        //判断obj是否为空
        if(obj == null) {
            return false;
        }
        //判断obj是否为 Card的实例
        if(!(obj instanceof Card)) {
            return false;
        }
        Card tmp = (Card) obj;
        //比较两张牌的花色和点数是否相同
        return this.rank.equals(((Card) obj).rank) && this.suit.equals(((Card) obj).suit);
    }
}

重写equals后再进行比较

public static void main(String[] args) {
        Card p = new Card("1","♥");
        Card q = new Card("1","♥");
        Card o = p;
        System.out.println(p.equals(q));
        System.out.println(p.equals(o));
    }

此时输出：
true
true

注意：
一般来说重写equals需要注意四个地方

• 如果引用指向同一个对象，则返回true
• 如果传入的是null，则直接返回flase
• 如果传入对象的类型不是Card则返回false
• 按照类的实现目标进行比较，如这里只需比较花色和点数是否相同

对象值大于、等于、小于的比较

创建了两个对象来比较大小，则需要专门的方法来完成

1. 实现了Comparable接口就要重写comparableTo方法
2. 实现了Comparator接口就要重写compare方法

Compareble接口：

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

接下来实现Compare接口：

package Java_0513;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Card implements Comparable<Card>{
    //扑克牌
    public String rank ;
    public String suit;

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

    @Override
    public  boolean equals(Object obj) {
        //首先需要比较身份是否相同
        if(this == obj){
            return true;
        }
        //判断obj是否为空
        if(obj == null) {
            return false;
        }
        //判断obj是否为 Card的实例
        if(!(obj instanceof Card)) {
            return false;
        }
        Card tmp = (Card) obj;
        //比较两张牌的花色和点数是否相同
        return this.rank.equals(((Card) obj).rank) && this.suit.equals(((Card) obj).suit);
    }

    //重写compareTo方法是因为使用Collections.sort方法时会调用Compareble接口的compareTo方法
    //重写后会调用实现Compareble接口的Card内中重写后的compareTo方法
    @Override
    public int compareTo(Card o) {
        //如果o指向的对象为空，则直接返回1
        if(o == null) {
            return 1;
        }
        //把牌面的大小转成数字并进行运算
        int rank1 = this.convertRank();
        int rank2 = o.convertRank();
        //如果从小到大比较就是 this - o;
        return rank1 - rank2;
    }

    //把牌面大小转成整数 3最大，4最小
    private int convertRank() {
        if("J".equals(rank)) {
            return 11;
        }
        if("Q".equals(rank)) {
            return 12;
        }
        if("K".equals(rank)) {
            return 13;
        }
        if("A".equals(rank)) {
            return 14;
        }
        if("1".equals(rank)) {
            return 15;
        }
        if("2".equals(rank)) {
            return 16;
        }
        if("3".equals(rank)) {
            return 17;
        }else{
            return Integer.valueOf(rank);
        }
    }

    @Override
    public String toString() {
        return "Card{" +
                "大小：" + rank + '\'' +
                ", 花色：" + suit + '\'' +
                '}';
    }
}

public class Compare{
    public static void main(String[] args) {
        //创建几张牌
        List<Card> cards = new ArrayList<>();
        cards.add(new Card("K","♥"));
        cards.add(new Card("8","♣"));
        cards.add(new Card("6","♦"));
        cards.add(new Card("3","♠"));
        cards.add(new Card("A","♥"));
        Collections.sort(cards);
        //每次使用System.out.println()
        //就会调用Object的toString方法
        //如果toString遇到字符串则会直接输出位字符串
        //如果遇到数字则会转换成字符串再输出
        //如果遇到对象则会直接输出Hash码
        //因此我们需要在Card中重写toString方法
        //使执行sout时调用Card中的toString方法
        System.out.println(cards);
    }
}

输出结果：
[Card{大小：6’, 花色：♦’}, Card{大小：8’, 花色：♣’}, Card{大小：K’, 花色：♥’}, Card{大小：A’, 花色：♥’}, Card{大小：3’, 花色：♠’}]

可以看到最终输出结果与我们预期的结果相符，完成了对象间的比较。

注意：

• 对于Comparable来说，必须要让Card类来实现Compareble接口，并且重写compareTo方法
• 对于Comparator来说，是创建一个新的类(CardComparator)，让这个类实现Comparator并重写compare方法然后完成对Card的排序

• 要想让Card类实现Compareble接口，就要修改Card类，但是我们不一定能修改的了Card类，也就是说使用Comparable时，我们想比较的类不一定修改的了，比如说某个类是库中的类，不是我自己写的，那么我就没有权限修改该类，再一个修改类可能导致其他的未知错误，导致内容混乱，所以按情况使用。
• Comparable只能指定一种比较规则，如果要用多种比较规则还得用Comparator。

最终结论：Comparator 比 Comparable 应用更加广泛。