Java对象的比较

一、关于对象值相等的比较

1）、 == 和 equals 的区别

1. p == q 表示的是 p 和 p 引用指向的是同一个对象
2. p.equals(q) 表示的是 p 指向的对象的值是否与 q 指向的对象的值相等

2）、equals 默认是调用 == 来比较身份的 ，可以手动重写 equals 方法，实现自定义规则比较
实现时 注意事项：

1. this 和 obj 是不是相同身份
2. obj 是否为 nill
3. obj 和 this 是不是相等类型
4. 对 obj 进行强制类型转换
5. 实现自定义规则比较

 @Override
        public boolean equals(Object obj) {
            // 1.看 this 和 Obj 的身份是否相等
            if (this == obj) {
                return true;
            }
            // 2. 看 obj 是否为空
            if (obj == null) {
                return false;
            }
            // 3.看 obj 和 this 类型是否相等
            if (!(obj instanceof Card)) {
                return false;
            }
            // 4.类型转换，将 obj 转换成 Card 类型
            Card other = (Card) obj;
            // 5.真正按照指定规则来进行
            return this.rank.equals(other.rank);
        }

二、 比较大小
1）、Comparable ：需要重写 compareTo 方法
需要手动实现接口，侵入性比较强，但一旦实现，每次用该类都有顺序，属于
内部顺序

public class TestComparable {
    static class Card implements Comparable<Card> {
        private String rank;
        private String suit;

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

        @Override
        public int compareTo(Card o) {
            int rank1 = this.convertRank();
            int rank2 = o.convertRank();
            return rank1 - rank2;
        }

        public int convertRank() {
            if ("A".equals(rank)) {
                return 14;
            }
            if ("K".equals(rank)) {
                return 13;
            }
            if ("Q".equals(rank)) {
                return 12;
            }
            if ("J".equals(rank)) {
                return 11;
            }
            // 将 string 转换成 integer
            return Integer.parseInt(rank);
        }

        @Override
        public String toString() {
            return "Card{" +
                    "rank='" + rank + '\'' +
                    ", suit='" + suit + '\'' +
                    '}';
        }
    }
    public static void main(String[] args) {
        List<Card> cards = new ArrayList<>();
        cards.add(new Card("A",""));
        cards.add(new Card("K",""));
        cards.add(new Card("J",""));
        cards.add(new Card("Q",""));

        Collections.sort(cards);
        System.out.println(cards);

    }
}

2）、Comparator：需要重写 compare 方法
需要实现一个比较器对象，对待比较类的侵入性弱，但对算法代码实现侵入性
强，使用更广泛

class Card {
    private String rank;
    private String suit;

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

    public int convertRank() {
        if ("A".equals(rank)) {
            return 14;
        }
        if ("K".equals(rank)) {
            return 13;
        }
        if ("Q".equals(rank)) {
            return 12;
        }
        if ("J".equals(rank)) {
            return 11;
        }
        return Integer.parseInt(rank);
    }

    @Override
    public String toString() {
        return "Card{" +
                "rank='" + rank + '\'' +
                ", suit='" + suit + '\'' +
                '}';
    }
}

class CardComparator implements Comparator<Card> {
    @Override
    public int compare(Card o1, Card o2) {
        int rank1 = o1.convertRank();
        int rank2 = o2.convertRank();
        return rank1 - rank2;
    }
}

public class TestComparator {

    public static void main(String[] args) {
        List<Card> cards = new ArrayList<>();
        cards.add(new Card("A","j"));
        cards.add(new Card("K","j"));
        cards.add(new Card("J","j"));
        cards.add(new Card("10","j"));
        Collections.sort(cards,new CardComparator());
        System.out.println(cards);
    }
}