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);

1.2 对象比较的问题

class Card 
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) 
        this.rank = rank;
    this.suit = suit;
    

public class TestPriorityQueue 
    public static void main(String[] args) 
    Card c1 = new Card(1, "♠");
    Card c2 = new Card(2, "♠");
    Card c3 = c1;
    //System.out.println(c1 > c2); // 编译报错
    System.out.println(c1 == c2); // 编译成功 ----> 打印false，因为c1和c2指向的是不同对象
    //System.out.println(c1 < c2); // 编译报错
    System.out.println(c1 == c3); // 编译成功 ----> 打印true，因为c1和c3指向的是同一个对象

c1 、 c2 和 c3 分别是 Card 类型的引用变量，上述代码在比较编译时： c1 > c2 编译失败 c1== c2 编译成功 c1 < c2 编译失败从编译结果可以看出， Java 中引用类型的变量不能直接按照 > 或者 < 方式进行比较 。那为什么 == 可以比较？因为： 对于用户实现自定义类型，都默认继承自 Object 类，而 Object 类中提供了 equal 方法，而 == 默认情况下调 用的就是 equal 方法，但是该方法的比较规则是： 没有比较引用变量引用对象的内容，而是直接比较引用变量的地 址，但有些情况下该种比较就不符合题意。

// Object中equal的实现，可以看到：直接比较的是两个引用变量的地址
public boolean equals(Object obj) 
    return (this == obj);

2. 对象的比较

有些情况下，需要比较的是对象中的内容，比如：向优先级队列中插入某个对象时，需要对按照对象中内容来调整堆，那该如何处理呢？

2.1 覆写基类的equals

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 this.rank == c.rank && suit.equals(c.suit);

【注意】 一般覆写 equals 的套路就是上面演示的 1. 如果指向同一个对象，返回 true 2. 如果传入的为 null ，返回 false 3. 如果传入的对象类型不是 Card ，返回 false 4. 按照类的实现目标完成比较，例如这里只要花色和数值一样，就认为是相同的牌 5. 注意下调用其他引用类型的比较也需要 equals ，例如这里的 suit 的比较，覆写基类equal 的方式虽然可以比较，但缺陷是： equal 只能按照相等进行比较，不能按照大于、小于的方式进行 比较。

2.2 基于Comparble接口类的比较

Comparble是 JDK 提供的泛型的比较接口类，源码实现具体如下：

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

对用用户自定义类型，如果要想按照大小与方式进行比较时： 在定义类时，实现 Comparble 接口即可，然后在类 中重写 compareTo 方法。

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 比较大

Compareble 是 java.lang 中的接口类，可以直接使用。

2.3 基于比较器比较

按照比较器方式进行比较，具体步骤如下： 用户自定义比较器类，实现 Comparator 接口

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

【注意】区分 Comparable 和 Comparator 。覆写 Comparator 中的 compare 方法

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 包中的泛型接口类，使用时必须导入对应的包

2.4 三种比较方式

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

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

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

4. top-k问题

top-k 问题：最大或者最小的前 k 个数据。比如：世界前 500 强公司

4.1 使用PriorityQueue创建大小堆，解决TOPK问题

//使用比较器创建小根堆
class LessIntComp implements Comparator<Integer>
    @Override
    public int compare(Integer o1, Integer o2) 
        return o1 - o2;
    


//使用比较器创建大根堆
class GreaterIntComp implements Comparator<Integer>
    @Override
    public int compare(Integer o1, Integer o2) 
        return o2 - o1;
    


public class TestDemo<E> 
    //求最小的K个数，通过比较器创建大根堆
    public static int[] smallestK(int[] array, int k) 
        if(k <= 0) 
            return new int[k];
        
        GreaterIntComp greaterCmp = new GreaterIntComp();
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(greaterCmp);
        //先将前K个元素，创建大根堆
        for(int i = 0; i < k; i++) 
            maxHeap.offer(array[i]);
        
        //从第K+1个元素开始，每次和堆顶元素比较
        for (int i = k; i < array.length; i++) 
            int top = maxHeap.peek();
            if(array[i] < top) 
                maxHeap.poll();
                maxHeap.offer(array[i]);
            
        
        //取出前K个
        int[] ret = new int[k];
        for (int i = 0; i < k; i++) 
            int val = maxHeap.poll();
            ret[i] = val;
        
        return ret;
    

    public static void main(String[] args) 
        int[] array = 4,1,9,2,8,0,7,3,6,5;
        int[] ret = smallestK(array,3);
        System.out.println(Arrays.toString(ret));

4.2 例题

OJ：面试题 17.14. 最小K个数

设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可。

解题思路

堆排序 堆排序即利用堆的思想来进行排序，总共分为两个步骤： 1. 建堆升序：建大堆降序：建小堆 2. 利用堆删除思想来进行排序 建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

创建一个最大堆，将数组中的元素放入堆中，为了维持堆中只有k个元素，只要堆中元素大于k个，就将堆顶poll（最大堆的堆顶的最大的元素），最后创建一个数组接受堆中的元素。

    public int[] smallestK(int[] arr, int k) 
        // 1.改造JDK的最小堆为此时的最"大"堆
        Queue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() 
            @Override
            public int compare(Integer o1, Integer o2) 
                return o2 - o1;
            
        );
        for (int i : arr) 
            queue.offer(i);
            if (queue.size() > k) 
                queue.poll();
            
        
        // 此时队列中保存了最小的k个数字
        int[] result = new int[k];
        for (int i = 0; i < k; i++) 
            result[i] = queue.poll();
        
        return result;

Java对象的比较数据结构

对象值相等的比较

== & equals

== 是用来比较对象身份的，而 equals 一般是用来比较对象的内容的
但equals 若没有手动重写，默认执行的就是 object 版本中的 equals，比较规则也是在比较身份

举例：

class Card{
    private String rank;    //点数
    private String suit;    //花色

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

1.== 比较：

public static void main(String[] args) {
    Card s1 = new Card("5","♠");
    Card s2 = new Card("5","♠");
    Card s3 = s1;
    System.out.print("s1 == s3: ");
    System.out.println(s1 == s3);
    System.out.print("s1 == s2: ");
    System.out.println(s1 == s2);
}

输出结果

对于用户实现自定义类型，都默认继承于 Object 类，而 Object 类中提供了 equals 方法，== 默认情况下调用的就是 equals 方法，比较规则是：没有比较引用变量引用对象的内容，而是直接比较引用变量的地址，因此 s1==s3 是 true，s1 == s2 是false

2.equals比较：

public static void main(String[] args) {
    Card s1 = new Card("5","♠");
    Card s2 = new Card("5","♠");
    Card s3 = s1;
    System.out.print("s1.equals(s3): ");
    System.out.println(s1.equals(s3));
    System.out.print("s1.equals(s2): ");
    System.out.println(s1.equals(s2));
}

输出结果：

一般来说 equals 是比较对象内容的，但若没有手动重写 equals 方法，则会使用 object 版本中的 equals 方法，默认比较规则是：比较对象的身份，没有比较对象的内容

手动重写 equals 方法：

@Override
public boolean equals(Object obj) {
    //按照值比较 this 和 obj
    //1.自己和自己比
    if(this == obj){
        return true;
    }
    //2.obj 为null，结果为null
    if(obj == null){
        return false;
    }
    //3.obj类型是不是当前的Card类型
    if(!(obj instanceof Card)){
        return false;
    }
    //4.比较内容
    Card other = (Card)obj;
    return this.rank.equals(other.rank) && this.suit.equals(other.suit);
}

此时再调用 equals 方法，输出结果：

重写 equals：

若指向同一个对象，返回 true
传入的参数为 null，结果为 null
如果传入的对象类型不匹配，返回 false
最后才是比较内容

缺点： equals 只能比较相等，不能比较大小

对象大小的比较

基于 Comparable 接口类

使用 Comparable 接口时，最好指定泛型参数，这样编译器就会自动的完成类型校验工作
若不写泛型参数，默认的 compareTo 方法的参数类型就是 Object 类型，此时需要程序猿手动实现类型转换

对于用户自定义类型，若想按照大小来进行比较：在定义类时，实现 Comparble 接口，在类中重写compareTo方法即可

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) {
        // 若认为 this 小于 o,返回 <0 的整数
        // 若认为 this 大于 o,返回 >0 的整数
        // 若认为 this 等于 o,返回 0
        if(o == null){
            //一般认为 this > null
            return 1;
        }
        // 点数取值 2-10,J Q K A
        int rank1 = this.getValue();
        int rank2 = o.getValue();
        return rank1 - rank2;
    }
    private int getValue(){
        // 把 String 类型的 rank 变成数字点数
        int value = 0;
        if("J".equals(rank)){
            value = 11;
        }
        else if("Q".equals(rank)){
            value = 12;
        }
        else if("K".equals(rank)){
            value = 13;
        }
        else if("A".equals(rank)){
            value = 14;
        }
        else {
            value = Integer.parseInt(rank);
        }
        return value;
    }
}

输出结果：

public static void main(String[] args) {
    Card s1 = new Card("5","♠");
    Card s2 = new Card("5","♣");
    Card s3 = s1;
    System.out.println(s1.compareTo(s2));
    System.out.println(s1.compareTo(s3));
}

基于 Comparator 比较器

使用方法和 Comparable 一样，先实现 Comparator 接口，再重写 Comparator 中的 compare 方法(需要修改这个类的代码)

class CardComparator implements Comparator<Card>{
    @Override
    public int compare(Card o1, Card o2) {
        if(o1 == o2){
            return 0;
        }
        if(o1 == null){
            return -1;
        }
        if(o2 == null){
            return 1;
        }
        int value1 = o1.getValue();
        int value2 = o2.getValue();
        return value1 - value2;
    }
}

输出结果：

public static void main(String[] args) {
    Card s1 = new Card("5","♠");
    Card s2 = new Card("11","♣");

    CardComparator comparator = new CardComparator();
    System.out.println(comparator.compare(s1,s2));
}

使用 Comparable 的时候，必须让要待比较类来实现 Comparable 接口，需要修改这个类的代码 (耦合性更强)
而使用 Comparator 的时候，是重新创建一个类来实现 Comparator 接口，不需要修改待比较类的代码

三种比较方式总结

方法：	说明
Object.equals	因为 Object 是所有子类的父类，所以直接重写即可，但只能比较相等
Comparable.compareTo	需要手动实现接口，侵入性较强，但一旦实现，每次用该类都有顺序，属于内部顺序
Comparator.compare	需要实现一个比较器对象，对待比较类的侵入性弱，但对算法代码实现侵入性强