【数据结构】Java对象的比较

这篇具有很好参考价值的文章主要介绍了【数据结构】Java对象的比较。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

作者主页:paper jie_博客

本文作者:大家好,我是paper jie,感谢你阅读本文,欢迎一建三连哦。

本文录入于《JAVA数据结构》专栏,本专栏是针对于大学生,编程小白精心打造的。笔者用重金(时间和精力)打造,将javaSE基础知识一网打尽,希望可以帮到读者们哦。

其他专栏:《算法详解》《C语言》《javaSE》等

内容分享:本期将会分享java数据结构中的对象比较

目录

priorityQueue中如何插入对象

元素的比较

基本类型的比较

对象类型的直接比较

对象正确的比较方式

重写equals方法

基于Comparble接口类的比较

基于比较器比较

集合框架中priorityQueue的比较方式


priorityQueue中如何插入对象

我们知道,优先级队列在插入元素时有一个要求:需要可以比较的对象才能插入。这里我们需要知道怎样插入自定义类型对象:

比如我们插入这个student对象:

class student {
    int age;
    String name;

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

public class Test {
    public static void main(String[] args) {
        PriorityQueue<student> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(new student(12,"小猪佩奇"));
        priorityQueue.offer(new student(12,"小猪乔治"));
    }

在运行后发现它会报类型不兼容的异常,这是因为在堆中插入元素,为了满足堆的性质,需要进行对象的比较,但是我们的student类型对象时不能直接比较的,所以会报错

【数据结构】Java对象的比较,# JAVA数据结构,JAVA,数据结构,java

元素的比较

基本类型的比较

在Java中,基本类型的对象是可以直接进行比较大小的

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

对象类型的直接比较

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指向的是同一个对象
}
}

这里我们知道,直接进行对象比较的是地址,只有相同才会返回true,不同就会报错。但是这里为毛==可以比较呢?这就得提到Object类了,因为自定义类也会继承Object类,这个类中提供了equal方法,==的情况下就是用的Object的equal方法。但是这个方式比较的就是引用对象的地址,没有比较对象的内容,这就头疼了。

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

对象正确的比较方式

重写equals方法

class student {
    int age;
    String name;

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

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

如果指向一个对象,返回true

如果传入的是null或者不是student,返回false

按照类的成员对象比较,只要成员对象相同就返回true

注意下调其他引用类型的比较也要调用equals

这里的缺陷就是:equals只能按照相等来比较,不能比较大小

基于Comparble接口类的比较

Comparable接口的源码:

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

对用户自定义类型,想要按照大小比较时,在定义类的时候,实现Comparable接口即可。然后在类中实现compareTo方法:

class student implements Comparable<student>{
    int age;
    String name;

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

    @Override
    public int compareTo(student o) {
        if(o == null) {
            return 1;
        }
        return this.age - o.age;
    }
}

基于比较器比较

用户自定义比较器类,需要实现Comparator接口:

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

这里要注意区分Comparable和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包

集合框架中priorityQueue的比较方式

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

1. Comparble是默认的内部比较方式,如果用户插入自定义类型对象时,该类对象必须要实现Comparble接口,并覆写compareTo方法

2. 用户也可以选择使用比较器对象,如果用户插入自定义类型对象时,必须要提供一个比较器类,让该类实现Comparator接口并覆写compare方法。 

JDK中的源码:


// 用户如果没有提供比较器对象,使用默认的内部比较,将comparator置为null
public PriorityQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
} 
// 如果用户提供了比较器,采用用户提供的比较器进行比较
public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
// Note: This restriction of at least one is not actually needed,
// but continues for 1.5 compatibility
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.queue = new Object[initialCapacity];
this.comparator = comparator;
}
private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }
private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (key.compareTo((E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = key;
    }

    @SuppressWarnings("unchecked")
    private void siftUpUsingComparator(int k, E x) {
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (comparator.compare(x, (E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = x;
    }

画图分析:

【数据结构】Java对象的比较,# JAVA数据结构,JAVA,数据结构,java文章来源地址https://www.toymoban.com/news/detail-715316.html


到了这里,关于【数据结构】Java对象的比较的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java 数据结构

    Java 数据结构 Java 提供了丰富的数据结构来处理和组织数据。 Java 的 java.util 包中提供了许多这些数据结构的实现,可以根据需要选择合适的类。 以下是一些常见的 Java 数据结构: 数组(Arrays) 数组(Arrays)是一种基本的数据结构,可以存储固定大小的相同类型的元素。 i

    2024年02月22日
    浏览(34)
  • Java基础--数据结构

    Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类: 枚举(Enumeration)、位集合(BitSet)、向量(Vector)、栈(Stack)、字典(Dictionary)、哈希表(Hashtable)、属性(Properties) 以上这些类是传统遗留的,在Java2中引入了一种新的框架-集合框架

    2023年04月14日
    浏览(34)
  • Java 数据结构集合

    详细请转到@pdai的博客 1.1 数组 (Array) 数组的优点: 存取速度快 数组的缺点: 事先必须知道数组的长度 插入删除元素很慢 空间通常是有限制的 需要大块连续的内存块 插入删除元素的效率很低 源码分析: 1、底层数据结构是Object 2、构造函数包括无参构造和有参数构造,有参构

    2024年01月24日
    浏览(41)
  • java 数据结构- 图

    表示多对多的关系时,这里我们就用到了图 图的常用概念 顶点 边 路径 无向图 有向图 带权图(边带权值的图也叫做网) 图的表示方式有两种:二维数组表示(邻接矩阵);链表表示(邻接表) 邻接矩阵 邻接矩阵是表示图形中顶点之间相邻关系的矩阵,对于n个顶点的图而

    2024年02月14日
    浏览(34)
  • Java数据结构

    java数据结构有: 1、数组                                2、列表  (List) 3、集合(Set)                   4、栈 (Stack)                                   5、队列  (Queue)                6、树 (Tree)                                  7、堆 (Heap)       

    2024年02月08日
    浏览(36)
  • 数据结构——链表(java)

    1.1 定义 链表是一种物理存储结构上非连续存储结构,数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 如图所示: 1.2 链表分类 单向、双向;带头、不带头;循环、非循环 重点 :单向不带头非循环、双向不带头非循环(集合类底层) 如图:单项带头非循环链表结

    2024年02月09日
    浏览(42)
  • Java数据结构学习和源码阅读(线性数据结构)

    链表的数据结构 一组由节点组成的数据结构,每个元素指向下一个元素,是线性序列。 最简单的链表结构: 数据 指针(存放执行下一个节点的指针) 不适合的场景: 需要循环遍历将导致时间复杂度的提升 链表分类—单向链表 链表结构: 数据 指针 Next(指向下一个节点)

    2024年02月12日
    浏览(43)
  • Java 与数据结构:队列

    队列是一种线性数据结构,它可以看作是一种特殊的线性表。队列具有“先进先出”的特点,即先进入队列的元素先被取出。队列有两个基本操作:入队和出队,入队即将元素加入队列的末尾,出队即从队列的头部取出元素。 队列可以用数组或链表来实现。使用数组实现的队

    2024年02月05日
    浏览(31)
  • 【Java 数据结构】顺序表

    篮球哥温馨提示:编程的同时不要忘记锻炼哦! 目录 1、什么是顺序表? 2、模拟实现ArrayList 2.1 模拟实现前的约定 2.2 构造方法 2.3 add方法 2.4 contains 方法 2.5 indexOf 方法 2.6 get 方法 2.7 set 方法 2.8 remove 方法 2.9 getSize 和 clear 方法 3、ArrayList 的学习 3.1 ArrayList的成员属性 3.2 Arr

    2024年02月20日
    浏览(31)
  • 【Java 数据结构】二叉树

    树是一种 非线性 的数据结构,它是由n(n=0)个有限结点组成一个具有层次关系的集合。 把它叫做树是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的 。 有一个特殊的结点,称为根结点,根结点没有前驱结点 除根结点外,其余结点被分成M(M 0)个互不相交的

    2024年02月20日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包