Java数据结构：从入门到精通(十)

回顾Java对象的⽐较

1. PriorityQueue中插⼊对象

上篇博客我们介绍了优先级队列的基本概念。需要特别注意的是，在插入元素时有两个关键要求：一是元素不能为null，二是元素之间必须能够进行比较。为了便于理解，我们之前仅以Integer类型为例进行了演示。那么问题来了：优先级队列是否支持插入自定义类型的对象呢？

java 复制代码

    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 TestPriorityQueue()
        {
            PriorityQueue<Card> p = new PriorityQueue<>();
            p.offer(new Card(1, "♠"));
            p.offer(new Card(2, "♠"));
        }
        public static void main(String[] args) {
            TestPriorityQueue();
        }
    }

优先级队列底层采用堆结构实现。当向堆中插入元素时，为了维护堆的特性，必须进行元素比较。由于Card类无法直接进行比较操作，因此会抛出异常。

2. 元素的⽐较

2.1 基本类型的⽐较

在Java中，基本类型的对象可以直接⽐较⼤⼩。

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 对象⽐较的问题

java 复制代码

    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类提供了equals方法。==运算符默认情况下调用的是equals方法，但该方法比较的是引用变量的地址而非对象内容。在某些情况下，这种比较方式可能不符合实际需求。

java 复制代码

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

3. 对象的⽐较

在这种情况下，当需要根据对象内容进行比较时（例如向优先级队列插入对象时需依据对象属性调整堆结构），应该如何处理呢？

3.1 覆写基类的equals

java 复制代码

    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方法的通用模式如下：

检查是否为同一对象引用，若是则返回true
检查传入对象是否为null，若是则返回false
检查对象类型是否匹配，若传入对象不是Card类型则返回false
根据业务逻辑进行属性比较，如本例中只需比较花色和数值是否相同
比较引用类型属性时也要使用equals方法，如本例中的suit比较
通常可使用IDE自动生成equals方法代码

需要注意的是：equals方法只能判断对象是否相等，无法实现大于或小于的比较。

3.2 基于Comparble接⼝类的⽐较

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

java 复制代码

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

对⽤⽤⼾⾃定义类型，如果要想按照⼤⼩与⽅式进⾏⽐较时：在定义类时，实现Comparble接⼝即

可，然后在类中重写compareTo⽅法。

java 复制代码

    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中的接⼝类，可以直接使⽤。

3.3 基于⽐较器⽐较

按照⽐较器⽅式进⾏⽐较，具体步骤如下：

⽤⼾⾃定义⽐较器类，实现Comparator接⼝

java 复制代码

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

注意：区分Comparable和Comparator。
覆写Comparator中的compare⽅法

java 复制代码

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?包中的泛型接⼝类，使⽤时必须导⼊对应的包。

3.4 三种⽅式对⽐

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

4. 观察源码当中PriorityQueue的⽐较⽅式

观察源码

5. 使⽤PriorityQueue创建⼤⼩堆，解决TOPK问题

java 复制代码

    //使⽤⽐较器创建⼩根堆
    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;
        }
    }

java 复制代码

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

感谢您的观看!