java对象的比较

---

1.基本类型的比较

在java中，基本类型的对象可以直接比较大小

public class TestCompare {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		System.out.println(a > b);
		System.out.println(a < b);
		System.out.println(a == b);
		char c1 = 'A';
		char c2 = 'B';
		System.out.println(c1 > c2);
		System.out.println(c1 < c2);
		System.out.println(c1 == c2);
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b1 == b2);
		System.out.println(b1 != b2);
	}
}

2.对象的比较

有些情况，需要比较的是对象中的内容
2.1覆写基类的equal

public class Card {
	public int rank; // 数值
	public String suit; // 花色
	public Card(int rank, String suit) {
	this.rank = rank;
	this.suit = suit;
}
@Override
	public boolean equals(Object o) {
		// 自己和自己比较
		if (this == o) {
		return true;
	}
// o如果是null对象，或者o不是Card的子类
		if (o == null || !(o instanceof Card)) {
			return false;
		}
// 注意基本类型可以直接比较，但引用类型最好调用其equal方法
		Card c = (Card)o;
		return rank == c.rank&& suit.equals(c.suit);
	}
}

注意：一般覆写equals的套路如下：
(1)如果指向同一个对象，返回true
(2)如果传入的为null，返回false
(3)如果传入的对象不是Card，返回false
(4)按照类的实现目标完成比较，例如这里只要花色和数值一样，就认为是相同的牌
(5)注意调用其他引用类型的比较也需要equals，例如这里的suit比较

提醒：覆写基类equal的方式可以进行比较，但缺陷是：equal只能按照相等比较，不能按照大于小于的方式进行比较

3.基于Comparable接口类的比较

Comparable是JDK提供的泛型的比较接口类，多用于自定义对象的比较，源码实现具体如下：

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

对用用户自定义类型，如果要想按照大小与方式进行比较时：在定义类时，实现Comparable接口即可，然后在类中重写compareTo方法。另外，Comparable是java.lang中的接口类，可以直接使用。
使用条件：如果这个对象， 在比较的数据比较多，而且都采用相同的大小比较的方式时。 比如： 一个Card类， 在大多数情况下， 都是按照牌的数值进行大小比较的。 此时就可以让Card类实现Comparable接口。

public class Card implements Comparable<Card> {
	public int rank; // 数值
	public String suit; // 花色
	public Card(int rank, String suit) {
	this.rank = rank;
	this.suit = suit;
	}
// 根据数值比较，不管花色
// 这里我们认为 null 是最小的
@Override
	public int compareTo(Card o) {
		if (o == null) {
			return 1;
		}
		return rank - o.rank;
	}
	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 比较小
		System.out.println(q.compareTo(p));// > 0，表示 q 比较大
	}
}

4.基于比较器的比较

·用户自定义比较器类，实现Comparator接口

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

·覆写Comparator中的compare方法
使用条件：如果某一个类的对象， 在临时进行大小比较的时候， 使用的与默认的比较不一样的规则。 比如： 一个Card类， 大多数情况下， 都是使用的牌的数值进行大小比较的， 但是临时需要使用花色进行一次比较， 此时就可以使用 Comparator 临时完成了并重写compare方法定义比较规则。 而且， Comparator的优先级要高于Comparable。

import java.util.Comparator;
	class Card {
	public int rank; // 数值
	public String suit; // 花色
	public Card(int rank, String suit) {
	this.rank = rank;
	this.suit = suit;
	}
}
class CardComparator implements Comparator<Card> {
	// 根据数值比较，不管花色
	// 这里我们认为 null 是最小的
	@Override
	public int compare(Card o1, Card o2) {
		if (o1 == o2) {
			return 0;
		}
		if (o1 == null) {
			return -1;
		}
		if (o2 == null) {
			return 1;
		}
		return o1.rank - o2.rank;
	}
	public static void main(String[] args){
		Card p = new Card(1, "♠");
		Card q = new Card(2, "♠");
		Card o = new Card(1, "♠");
		// 定义比较器对象
		CardComparator cmptor = new CardComparator();
		// 使用比较器对象进行比较
		System.out.println(cmptor.compare(p, o)); // == 0，表示牌相等
		System.out.println(cmptor.compare(p, q)); // < 0，表示 p 比较小
		System.out.println(cmptor.compare(q, p)); // > 0，表示 q 比较大
	}
}

注意：Comparator是java.util 包中的泛型接口类，使用时必须导入对应的包。

5、三种方式的比较

6.集合框架中PriorityQueue的比较方式

集合框架中的PriorityQueue底层使用堆结构，因此其内部的元素必须要能够比大小，PriorityQueue采用了：
Comparble和Comparator两种方式。
(1)Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接
口，并覆写compareTo方法
(2) 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现
Comparator接口并覆写compare方法。