对象的比较（数据结构系列12）

于 2023-04-05 21:21:36 发布
阅读量321 收藏
点赞数
分类专栏： 数据结构 Java 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61599986/article/details/129912080
版权

目录

前言：

1.PriorityQueue

1.1PriorityQueue的特性

1.2PriorityQueue的构造器

1.3大根堆的创建

1.4PriorityQueue中函数的说明

2.java中对象的比较

2.1基本类型的比较

2.2对象的比较

2.2.1覆写基类的equals

2.2.2基于Comparable接口类的比较

2.2.3基于比较器比较

2.2.4三种方式对比

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

4.top—K问题

结束语：

前言：

1.PriorityQueue

1.1PriorityQueue的特性

我们先来简单的了解一下什么是PriorityQueue，然后再来了解java中的对象比较。

在java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的，小编会在后续中给大家来介绍什么是线程安全什么是线程不安全的，我们现在先以PriorityQueue为例进行讲解。

我们先来看一下他是继承自哪些接口的。

我们可以看到他是继承自Queue这个接口的，所以我们以后在使用过程中可以直接使用Queue来定义一个优先级队列出来。 

如下所示：
 

import java.util.PriorityQueue;
import java.util.Queue;

public class Test1 {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        //使用接口
        Queue<Integer> priorityQueue1 = new PriorityQueue<>();
    }
}

关于PriorityQueue的使用我们需要注意这几方面的问题。

1.使用时必须要导入PriorityQueue所在的包，如下所示：

import java.util.PriorityQueue;

2.PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出ClassCastException异常。

如下所示：
 

package 优先级队列;

import java.util.PriorityQueue;
class Student{
    public int age;
    public String name;
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
}
public class Test {
    public static void main(String[] args) {
        //下面的是可以的
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(1);
        priorityQueue.offer(2);
        //下面的是插入了两个类，两个类之间是不可以比较大小的
        PriorityQueue<Student> priorityQueue2 = new PriorityQueue<>();
        priorityQueue2.offer(new Student(13,"张三"));
        priorityQueue2.offer(new Student(14,"张三"));
    }
}

3.不能插入null对象，否则就会抛出NullPointerException。

package 优先级队列;

import java.util.PriorityQueue;

public class Test1 {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(null);
    }
}

4.没有容量限制，可以插入任意多个元素，  其内部可以自动扩容。但是也不说真的就是没有任何容量限制，最大容量为堆的大小。

5.插入和删除元素的时间复杂度为O(log2N)。

6.PriorityQueue 底层使用了堆数据结构。

7.PriorityQueue默认情况下是小堆——即每次获取到的元素都是最小的元素。

如下所示：

import java.util.PriorityQueue;
import java.util.Queue;

public class Test2 {
    public static void main(String[] args) {
        Queue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(12);
        priorityQueue.offer(2);
        priorityQueue.offer(89);
        //底层是最小堆实现的
        System.out.println("堆顶元素是：" + priorityQueue.poll());//2
    }
}

结果如下所示：

1.2PriorityQueue的构造器

构造器功能介绍
PriorityQueue()创建一个空的优先级队列，默认容量是11
PriorityQueue（int initialCapacity）创建一个初始容量为initialCapacity的优先级队列，注意：initialCapacity不能小于1，否则就会抛IIIegalArgumentException异常。
PriorityQueue（Collection<？extends E> c）用一个集合来创建优先级队列。

PriorityQueue（Collection<？extends E> c）的实例如下所示：
代码如下所示：

import java.util.*;

public class Test3 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        Queue<Integer> priorityQueue = new PriorityQueue<>(list);
        //先构造list里面的在去构造自己的
        priorityQueue.offer(23);
        System.out.println("堆顶元素为：" + priorityQueue.poll());//1
    }
}

结果如下所示：

1.3大根堆的创建

我们在了解上述PriorityQueue的基本知识之后，我们知道它的底层是由小根堆构成的，那么我们如果是要构建一个大跟堆要怎么构建呢？

我们可以提供一个比较器，如下述代码所示：

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;


class IntCmp implements Comparator<Integer>{

    @Override
    public int compare(Integer o1, Integer o2) {
        return o2.compareTo(o1);//由于比较类型是Integer，也可以写作o2 - o1
        //如果是小根堆就是o1 - o2;
    }
}
public class Test4 {
    public static void main(String[] args) {
        //提供一个从大到小排序的比较器。
        IntCmp intCmp = new IntCmp();
        Queue<Integer> priorityQueue = new PriorityQueue<>(intCmp);
        priorityQueue.offer(1);
        priorityQueue.offer(2);
        priorityQueue.offer(4);
        System.out.println("堆顶元素为：" + priorityQueue.poll());
    }
}

结果如下所示：

我们发现堆顶元素是最大的，这样我们就通过一个比较器来实现了大根堆的构建了。 

1.4PriorityQueue中函数的说明

函数名功能介绍
boolean offer(E e)

插入元素e，插入成功后返回true，如果e对象为空，抛出空指针异常，当空间不够的时候会自动扩容

E peek()获取优先级最高的元素，如果优先级队列为空，则返回null
E poll()

移除优先级队列最高的元素并返回，如果优先级队列为空，则返回null 

int size()获取有效元素的个数
void clear()清空
boolean isEmpty()检测优先级队列是否为空，空返回true

代码实例如下所示：

import java.util.PriorityQueue;
import java.util.Queue;

public class Test5 {
    public static void main(String[] args) {
        Queue<Integer> priorityQueue = new PriorityQueue<>();
        //插入元素
        priorityQueue.offer(1);
        priorityQueue.offer(2);
        priorityQueue.offer(3);
        priorityQueue.offer(4);
        priorityQueue.offer(5);
        priorityQueue.offer(6);

        //查看优先级队列的队首元素
        System.out.println("peek一次的队首元素为：" + priorityQueue.peek());//1
        System.out.println("peek两次的队首元素为：" + priorityQueue.peek());//1
        //弹出优先级队列的队首元素
        System.out.println("第一次弹出队首元素为：" + priorityQueue.poll());//1
        System.out.println("第二次弹出队首元素为：" + priorityQueue.poll());//2
        //优先级队列的有效元素个数
        System.out.println("队列中有效元素的个数为：" + priorityQueue.size());//4
        //判断是否为空
        System.out.println("clear之前队列是否为空：" + priorityQueue.isEmpty());//false
        //清空
        priorityQueue.clear();
        //判断是否为空
        System.out.println("clear之后队列是否为空：" + priorityQueue.isEmpty());//true
    }
}


结果如下所示：

 

2.java中对象的比较

2.1基本类型的比较

代码如下所示：

public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;;
        System.out.println("a == b : " + (a == b));//true
        System.out.println("a > b : " + (a > b));//false
        System.out.println("a < b : " + (a < b));//false

        char c = 'A';
        char d = 'B';
        System.out.println("c == d : " + (c == d));//false
        System.out.println("c > d : " + (c > d));//false
        System.out.println("c < d : " + (c < d));//true
    }
}

结果如下所示：

2.2对象的比较

2.2.1覆写基类的equals

我们直接根据代码来说明问题。

代码如下所示：

class Student{
    public int age;
    public String name;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student1 = new Student(14,"张三");
        Student student2 = new Student(14,"张三");
//        System.out.println(student1 > student2);
//        System.out.println(student1 < student2);
        System.out.println(student1 == student2);//false
    }
}

结果如下所示：

在自定义对象中我们是不可以使用 > 和 < 来进行比较的，如下所示：

这里我们就有很多人好奇了，为什么==就可以比较而>和 < 就不可以比较了？我们在继续往下看。 

我们根据上述的代码可以看出来student1 和student2 用== 来进行比较是不相等的，但是在我们主观上认为student1和student2是同一个人的话那这个比较的结果就与我们预期的不符，那么为什么会出现这种情况呢？其实我们在进行对象之间的比较的时候我们是根据给每一个对象分配的地址来进行比较的，那么我们给他们分配的地址可定是不一样的，所以就会导致我们的比较结果出现问题，那么我们如果要比较两个地址空间内的内容是否一样我们该怎么进行比较呢？

我们之前也有过了解我们可以根据equals来进行比较，equals是专门用来比较两个地址空间内的内容是否一样的，一样则返回true，不同则返回false。

但是我们在使用之前得重写它的一些方法，否则还是会出现上述的问题，因为对于用户自定义实现的类型，都默认继承自Object类。在Object类中提供了equals方法，而==默认情况下调用的就是equals方法。

当我们重写了equals方法之后就可以进行比较了。快捷方法是在自定义类中使用Alt + Insert选择下面的这个方法一路回车就好了。

 

 

 

 

生成的equals方法，其中他是和hashCode是同时出现的，这个我们后面在给大家细说。

 

代码如下所示:

import java.util.Objects;

class Student{
    public int age;
    public String name;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student1 = new Student(14,"张三");
        Student student2 = new Student(14,"张三");
//        System.out.println(student1 > student2);
//        System.out.println(student1 < student2);
//        System.out.println(student1 == student2);//false
        System.out.println(student1.equals(student2));
    }
}

结果如下所示：
 

但是我们又会发现equals的一个缺点就是我们只能判断里面的值是否相同，但是不能判断谁大谁小，这样我们就引入了另一种比较方式，基于Comparable接口的比较。 

2.2.2基于Comparable接口类的比较

什么是Comparable接口呢? Comparable接口就是JDK提供的一种泛型的比类接口。具体的源码实现如下所示：

中间的红框内容我们可以直接理解为下面的这些：
返回值：

  • <0：表示this指向的对象小于o指向的对象。
  • ==0：表示this所指向的对象等于o指向的对象。
  • >0：表示this所指向的对象大于o所指向的对象。 

对于我们上述代码中自己实现的自定义类Student来说要想用Comparable来进行比较的话我们就只需要实现Comparable接口即可，然后在类中重写CompareTo方法。

代码如下所示：

class Student1 implements Comparable<Student1>{
    public int age;
    public String name;

    public Student1(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public int compareTo(Student1 o) {
        return o.age - this.age;
    }
}
public class Test3 {
    public static void main(String[] args) {
        Student1 student1 = new Student1(14,"李四");
        Student1 student12 = new Student1(14,"李四");
        System.out.println(student1.compareTo(student12));
    }
}

结果如下所示：

 

2.2.3基于比较器比较

我们如果是按照上述的Comparable接口进行比较的话我们就会把方法写死了，我们就只能按一个来进行比较，比如上述中的Student是按照age来进行排序的，按照比较器方式进行比较，具体步骤如下：

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

代码如下所示：

import java.util.Comparator;

class Student2{
    public int age;
    public String name;

    public Student2(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

//按照年龄进行比较
class AgeInCmp implements Comparator<Student2> {

    @Override
    public int compare(Student2 o1, Student2 o2) {
        return o1.age - o2.age;
    }
}
//按照姓名进行比较
class NameInCmp implements Comparator<Student2> {

    @Override
    public int compare(Student2 o1, Student2 o2) {
        return o1.name.compareTo(o2.name);
    }
}

public class Test4 {
    public static void main(String[] args) {
        Student2 student21 = new Student2(14,"李四");
        Student2 student22 = new Student2(14,"张四");
        AgeInCmp ageInCmp = new AgeInCmp();
        NameInCmp nameInCmp = new NameInCmp();
        System.out.println(ageInCmp.compare(student21,student22));
        System.out.println(nameInCmp.compare(student21,student22));
    }
}


结果如下所示：

 

2.2.4三种方式对比

覆写的方法说明
Object.equals因为所有类都是继承自Object的，所以直接覆写即可，不过只能比较相等与否
Comparable.compareTo

需要手动实现接口，侵入性比较，但一旦实现，每次用该类都有顺序，属于内部顺序，不够灵活。

Comparator.Compara需要实现一个比较器对象，对待比较类的侵入性弱，但对于算法代码实现侵入性强

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

集合框架中的PriorityQueue底层使用结构，因此其内部的元素，必须要能够比较大小，PriorityQueue采用了Comparator和Comparable两种方式。

  • Comparable是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparable接口，并覆写ComparaTo方法。
  • 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现Comparator接口并覆写compare方法。

我们可以使用比较器创建大跟堆。

1.我们可以采用传比较器的方法来进行构建。

代码如下所示：

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
class InCmp implements Comparator<Integer> {

    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}
public class Test6 {
    public static void main(String[] args) {
        //1.采用传送传感器来进行比较
        InCmp inCmp = new InCmp();
        Queue<Integer> priorityQueue = new PriorityQueue<>(inCmp);
        priorityQueue.offer(1);
        priorityQueue.offer(2);
        priorityQueue.offer(3);
        System.out.println("堆的根结点是：" + priorityQueue.peek());
    }
}


结果如下所示：

2.我们也可以采用匿名内部类法。

代码如下所示：

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

public class Test7 {
    public static void main(String[] args) {
        //2.匿名内部类法
        Queue<Integer> priorityQueue = new PriorityQueue<>(
                new Comparator<Integer>() {
                    @Override
                    public int compare(Integer o1, Integer o2) {
                        return o2 - o1;
                    }
                }
        );
        priorityQueue.offer(1);
        priorityQueue.offer(2);
        priorityQueue.offer(3);
        System.out.println("堆的根结点是：" + priorityQueue.peek());
    }
}


结果如下所示：

3.lambda表达式法。

这个大家先做一个了解，后期小编会主要和大家讲解的。

代码如下所示：

import java.util.PriorityQueue;
import java.util.Queue;

public class Test8 {
    public static void main(String[] args) {
        //3.lambda表达式
        Queue<Integer> priorityQueue = new PriorityQueue<>
                (((o1, o2) -> {return o2.compareTo(o1);}));
        priorityQueue.offer(1);
        priorityQueue.offer(2);
        priorityQueue.offer(3);
        System.out.println("堆的根结点是：" + priorityQueue.peek());
    }
}

 

结果如下所示：

4.top—K问题

问题描述：即求数据集合中前k个最大的元素或者是最小元素，一般情况下数据量都比较大。

比如专业前十名，世界500强，富豪榜，游戏中前100的活跃玩家等。

我们就可以用优先级队列来解决这个问题了，我们将这些建成大跟堆来弹出前k个元素。

代码如下所示：

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
class InCmp implements Comparator<Integer> {

    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}
public class Test1 {
    public static void find_Top_k(int[] array, int k) {
        int[] ret = new int[array.length];
        InCmp inCmp = new InCmp();
        Queue<Integer> maxHeap = new PriorityQueue<>(inCmp);
        for (int i = 0; i < array.length; i++) {
            maxHeap.offer(array[i]);
        }
        System.out.println("前" + k + "个是：");
        for (int i = 0; i < k; i++) {
            System.out.print(maxHeap.poll() + " ");
        }
    }
    public static void main(String[] args) {
        int[] array = {1,22,1,2,3,4,51,47,43,15,55,5,6,7,64};
        int k = 4;
        find_Top_k(array,k);
    }
}


结果如下所示：

 


结束语：

好啦这节小编就与大家分享到这里啦，里面有些可能大家还是有些看不懂，不重要大家可以先记着它，后期小编会一个一个给大家解释的，希望对大家有所帮助，想要学习的同学记得关注小编和小编一起学习吧！如果文章中有任何错误也欢迎各位大佬及时为小编指点迷津（在此小编先谢过各位大佬啦！）

努力敲代码的小白✧٩(ˊωˋ*)و✧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构对象的基本概念.docx
10-25
数据结构对象的基本概念 数据结构对象的基本概念是计算机科学中的一门基础课程，对于学习编程和软件开发至关重要。本文将对数据结构对象的基本概念进行详细的解释，并对相关的知识点进行总结和分析。 一、数据结构...
对象比较的三种方式
qq_44363212的博客
11-17 3175
1.关于对象值相等的比较 1.1 == / equals p == q表示的是p和q两个引用指向同一个对象 p.equals(q)表示p指向的对象和q指向的对象是否是值语意相等的 public class Card{ public int rank; public String suit; public Card(int rank,String s...
Java中对象的比较
m0_63635730的博客
02-28 992
Java对象比较
对象的比较
如风暖阳的博客
07-18 512
对象的比较
Java中两个对象的比较 equals()方法和==号的区别
热门推荐
BlueSky_USC的博客
07-07 2万+
在Java中，时不时我们会把两个对象进行，然而得到的结果却不是我们想的结果，这是怎么回事呢？ 一、两种形式的比较：比较时，我们要弄清楚是哪一种比较。       1.值类型比较       即内容相同，我们就认为是相等的。比如：int i=5；int j =5；此时我们说i和j相等，其实指的是i和j的内容相同。       2.引用类型比较      但在Java中，除了
Java数据结构和算法系列文章，源码.zip
最新发布
06-17
图数据结构则用于表示对象之间的复杂关系。 算法则是解决问题的步骤或方法，包括排序、搜索、图算法等。排序算法如冒泡排序、快速排序、归并排序、堆排序等，各有优缺点，适用于不同的场景。搜索算法如二分查找、...
JavaScript实现数据结构
01-02
10. 字符串（String）：虽然字符串在JavaScript中被视为不可变对象，但它也是一种特殊的数据结构，可以进行各种字符串操作，如拼接、查找、替换等。 了解了这些基本的数据结构之后，我们可以利用它们设计和实现各种...
js数据结构与算法.zip
06-16
数组是最基础的数据结构，它是一系列元素的有序集合，可以通过索引来访问。JavaScript的对象则是一种键值对的集合，提供了灵活的存储方式。链表是一种非连续的内存结构，每个元素称为节点，包含数据和指向下一个节点...
简单数据结构实现.zip
06-17
6. **图**：图是由顶点和边构成的数据结构，用于表示对象间的关系。图的实现包括邻接矩阵和邻接表。在C和C++中，可以使用二维数组或链表实现，Java和Python有图的库如networkx或Graph类。 7. **排序和查找算法**：...
java对象的值进行比较
panruola的博客
02-21 3030
1.首先在对象类进行equals和hashCode方法重写 （Alt+Insert快速导入） 2.使用equals对值进行比较 System.out.println("args = [" + ad1.equals(ad2) + "]")
JavaScript如何比较两个数组的内容是否相同
zwbHUST的博客
09-29 2995
今天意外地发现JavaScript是不能用==或===操作符直接比较两个数组是否相等的。 alert([]==[]); // false alert([]===[]); // false 以上两句代码都会弹出false。 因为JavaScript里面Array是对象，==或===操作符只能比较两个对象是否是同一个实例，也就是是否是同一个对象引用。目前JavaScript没有内置的...
js中对象之间的比较
xiazeqiang2018的博客
07-17 7812
对象之间是无法直接进行比较的，我在写代码的过程中经常犯这个错误，可以将两个对象转换成json字符串格式，即利用JSON.stringify(obj)再进行比较。 const obj = { id: 0, name: '张三', age: 12 } const objToStr = JSON.stringify(obj) 同时，也可以用JSON.parse装换回...
对象的比较/引用的比较
weiAX95的博客
01-20 956
对象的比较并非是值的比较, ,即使两个对象包含相同的值, 他们也是不相等的 例 var o = {x:1},p={x:1}//创建相同属性的两个对象 o === p //false:两个单独对象永远不相等 var a = [],b = [] //两个单独的空数组 a === b //false 两个单独的数组用不相等 我们通常将对象称为引用类型 
深入Java对象的比较
weixin_33937778的博客
06-02 303
深入Java对象的比较   一、简单类型比较   Java中，比较简单类型变量用“==”，只要两个简单类型值相等即返回ture，否则返回false；   二、引用类型比较   引用类型比较比较变态，可以用“==”，也可以用“equals()”来比较，equals()方法来自于Object类，每个自定义的类都可以重写这个方法。Object类中的equals()方法仅仅通过“==”来比...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力敲代码的小白✧٩(ˊωˋ*)و✧

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值