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

余瑜鱼鱼鱼2026-01-12 9:46

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

  1. 检查是否为同一对象引用，若是则返回true
  2. 检查传入对象是否为null，若是则返回false
  3. 检查对象类型是否匹配，若传入对象不是Card类型则返回false
  4. 根据业务逻辑进行属性比较，如本例中只需比较花色和数值是否相同
  5. 比较引用类型属性时也要使用equals方法，如本例中的suit比较
  6. 通常可使用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));
        }
    }

感谢您的观看!

相关推荐
好奇龙猫2 小时前
【大学院-筆記試験練習：线性代数和数据结构（5）】
数据结构·线性代数
爱吃生蚝的于勒2 小时前
【Linux】进程间通信之匿名管道
linux·运维·服务器·c语言·数据结构·c++·vim
寻星探路2 小时前
【算法专题】哈希表：从“两数之和”到“最长连续序列”的深度解析
java·数据结构·人工智能·python·算法·ai·散列表
!停3 小时前
C语言单链表
c语言·数据结构·算法
!停3 小时前
C语言栈和队列的实现
开发语言·数据结构
蓝桉~MLGT3 小时前
中级软考（软件工程师）第三章知识点——数据结构与数据运算
数据结构
代码游侠3 小时前
学习笔记——ESP8266 WiFi模块
服务器·c语言·开发语言·数据结构·算法
0和1的舞者3 小时前
Python 中四种核心数据结构的用途和嵌套逻辑
数据结构·python·学习·知识
乌萨奇也要立志学C++14 小时前
【洛谷】递归初阶 三道经典递归算法题（汉诺塔 / 占卜 DIY/FBI 树）详解
数据结构·c++·算法
热门推荐
01GitHub 镜像站点02Labelme从安装到标注：零基础完整指南03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04Linux下V2Ray安装配置指南05Claude Code 2.1.2 升级报错？别折腾了，一行命令搞定06jdk21下载、安装（Windows、Linux、macOS）07【踩坑笔记】50系显卡适配的 PyTorch 安装08KGG转MP3工具|非KGM文件|解密音频09Overleaf编译超时，超出免费计划编译时限（已解决）102025-04-03 Latex学习1——本地配置Latex + VScode环境