精华内容
下载资源
问答
  • 2020-06-08 19:22:27

    Java 语言规范要求 equals 方法具有下面的特性:

    1、自反性:对于任何非空引用x,x.equals(x)应该返回true。
    2、对称性:对于任何引用x和y,当且仅当y.equals(x)返回true,x.equals(y)也应该返回true。
    3、传递性:对于任何引用x、y和z,如果x.equals(y)返回true,y.equals(z)返回true,则x.equals(z)也应该返回true。
    4、一致性:如果x和y引用对象没有发生变化,反复调用x.equals(y)应该返回同样的结果。
    5、非空性:对于任意非空引用x,x.equals(null)应该返回false。

    这些规则十分合乎情理,从而避免了类库实现者在数据结构中定位一个元素时还要考虑调用 x.equals(y), 还是调用 y.equals(x) 的问题。

    完结!

    更多相关内容
  • hashcode 和 equals 方法是用来鉴定2个对象是否相等。 一般来讲,equals这个方法是给用户调用的,如果你想判断2个对象是否相等,你可以重写equals方法,然后在代码中调用 ,就可以判断他们是否相等了。简单来讲,...

          hashcode 和 equals 方法是用来鉴定2个对象是否相等。

          一般来讲,equals这个方法是给用户调用的,如果你想判断2个对象是否相等,你可以重写equals方法,然后在代码中调用 ,就可以判断他们是否相等了。简单来讲,equals方法主要是用来判断从表面上看或者从内容上看,2个对象是不是相等。 举个例子,有个学生类,属性只有姓名和性别,那么我们可以认为只要姓名和性别相等,那么就说这2个对象是相等的。

      如下:

    package utils;
    
    public class Student {	
    	private int id;
    	private String name;
    	
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + id;
    		return result;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Student other = (Student) obj;
    		if (id != other.id)
    			return false;
    		return true;
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    }
    

      测试类

    package utils;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Test {
    	public static void main(String[] args) {
    		Map<Student,String> map = new HashMap<Student,String>();
    	
    		Student e = new Student();
    		e.setId(1);
    		e.setName("lol");
    		
    		Student e1 = new Student();
    		e1.setId(1);
    		e1.setName("lol");
    		//商业逻辑是对象中值相等就相等,所以我们需要重写它的 hashCode方法
    		map.put(e, "1421801Z");
    		map.put(e1, "1421801Z");
    		System.out.println(map.toString());
    		
    	}
    }
    

      结果:

      没有重写HashCode 和 equals 方法

      

      重写HashCode 和 equals 方法

      

     

    总结分析:

      HashCode 方法是根据实体类中某些属性来重写的,上面的id 就是学生的学号(主键)。

      equals 方法的比较类型如上。

    HashCode 和 equals 方法是map、set容器用来解决重复值得一个工具,当map、set在添加东西进去的时候,首先它会

    调用HashCode 方法,由于每个对象都有唯一的Hash码所以是不同的,但是我们可以通过重写HashCode 来达到当“值”相等的情况下,默认相等。

     

    然后再去调用equals 方法判断两者是否相等。

     

    转载于:https://www.cnblogs.com/py1994/p/6680949.html

    展开全文
  • 重写equals方法规范

    2019-11-15 14:10:38
    下图重写equals方法 重写equals、hashCode、toString(雇员经理例子) Employee类 package com.cxf.EqualsHashCodeDemo; import java.time.LocalDate; import java.util.Objects; public class Employee { ...

    规则:

    在这里插入图片描述

    注意点:

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    下图重写equals方法

    重写equals、hashCode、toString(雇员经理例子)

    Employee类

    package com.cxf.EqualsHashCodeDemo;
    
    import java.time.LocalDate;
    import java.util.Objects;
    
    public class Employee {
        private String name;
        private double salsry;
        private LocalDate hireDay;
    
        public Employee(String name,double salsry,int year,int month,int day){
            this.name = name;
            this.salsry = salsry;
            hireDay = LocalDate.of(year,month,day);
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getSalsry() {
            return salsry;
        }
    
        public void setSalsry(double salsry) {
            this.salsry = salsry;
        }
    
        public LocalDate getHireDay() {
            return hireDay;
        }
    
        public void setHireDay(LocalDate hireDay) {
            this.hireDay = hireDay;
        }
    
        public void raiseSalary(double byPercent){
            double raise = salsry * byPercent / 100;
            salsry += raise;
        }
    
        @Override
        public boolean equals(Object otherObject) {
            if (this == otherObject) return true;
            if (otherObject == null || getClass() != otherObject.getClass()) return false;
            Employee other = (Employee) otherObject;
            return Objects.equals(name,other.name) && salsry == other.salsry
                    && Objects.equals(hireDay,other.hireDay);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name, salsry, hireDay);
        }
    
        @Override
        public String toString() {
            return getClass().getName() + "Employee{" +
                    "name='" + name + '\'' +
                    ", salsry=" + salsry +
                    ", hireDay=" + hireDay +
                    '}';
        }
    }
    

    Manager类

    package com.cxf.EqualsHashCodeDemo;
    
    
    public class Manager extends Employee {
    
        private double bonus;
    
        public Manager(String name, double salsry, int year, int month, int day) {
            super(name, salsry, year, month, day);
            bonus = 0;
        }
    
        public double getSalary() {
            double baseSalary = super.getSalsry();
            return baseSalary + bonus;
        }
    
        public void setBonus(double bonus){
            this.bonus = bonus;
        }
    
        @Override
        public boolean equals(Object otherObject){
            if (!super.equals(otherObject)) return false;
            Manager other = (Manager) otherObject;
            return bonus == other.bonus;
        }
    
        @Override
        public int hashCode() {
            return super.hashCode() + 17 * new Double(bonus).hashCode();
        }
    
        @Override
        public String toString(){
            return super.toString() + "[bonus=" + bonus + "]";
        }
    }
    

    测试

    package com.cxf.EqualsHashCodeDemo;
    
    public class EqualsTest {
        public static void main(String[] args) {
            Employee emp1 = new Employee("Lucy",75000,1987,12,15);
            Employee emp2 = emp1;
            Employee emp3 = new Employee("Lucy",75000,1987,12,15);
            Employee bob = new Employee("Bob",50000,1989,10,1);
    
            System.out.println("emp1 == emp2: " + (emp1 == emp2));
            System.out.println("emp1 == emp3: " + (emp1 == emp3));
            System.out.println("emp1.equals(emp3): " + (emp1.equals(emp3)));
            System.out.println("emp1.equals(bob): " + (emp1.equals(bob)));
            System.out.println("bob.toString(): " + bob.toString());
    
            Manager man1 = new Manager("Tom",80000,1987,12,15);
            Manager boss = new Manager("Tom",80000,1987,12,15);
            boss.setBonus(5000);
            System.out.println("============================================================");
            System.out.println("boss.toString(): " + boss);
            System.out.println("man1.equals(boss): " + man1.equals(boss));
            System.out.println("emp1.hashCode(): " + emp1.hashCode());
            System.out.println("emp3.hashCode(): " + emp3.hashCode());
            System.out.println("bob.hashCode(): " + bob.hashCode());
            System.out.println("man1.hashCode(): " + man1.hashCode());
        }
    }
    
    展开全文
  • Java中equals()方法详细解析

    千次阅读 2021-03-07 04:27:56
    本文主要内容:覆盖equals() 方法需要遵守哪些通用规定什么时候该重写equals()方法重写equals()方法有哪些特征重写一个equals()方法的步骤为什么重写equals()方法时要先重写hashCode()方法我们知道equals()方法是顶级...

    本文主要内容:

    覆盖equals() 方法需要遵守哪些通用规定

    什么时候该重写equals()方法

    重写equals()方法有哪些特征

    重写一个equals()方法的步骤

    为什么重写equals()方法时要先重写hashCode()方法

    我们知道equals()方法是顶级类 Object下的一个非 final方法,我们在使用的每个Java类都是要继承Object类的,那么任何一个类在覆盖这些方法的时候,都有责任遵守这个约定.

    1 、覆盖equals时要遵循的约定

    类的每个实例本质是唯一的,也就是每个 new Object()这个这个类的实例是唯一一个,在创建一个对象实例则不是相同的

    不关心类是否提供了逻辑相等的测试功能。使用Random生成随机数时,不需要关系是否生成了两个逻辑数是否相同,直接就是不同的对象

    9b2b51e2f7a9

    image.png

    输出:

    9b2b51e2f7a9

    image.png

    超类已经重写了equals()方法,从超类继承过来的行为对于子类也是合适的。

    例如Map实现了equals方法则直接可以使用equals方法比对两个map是否相等

    9b2b51e2f7a9

    image.png

    9b2b51e2f7a9

    image.png

    类是私有的或是包级别私有的,可以确定它的equals方法永远不会被调用

    2、什么时候该重写equals方法

    如果类具有自己特有的“”逻辑特性“”,而且超类还没有覆盖equals以实现期望的行为. 及我们不想知道它是否在内存中指向的是否一个对象,我们想判断它的逻辑值是否相等

    例如: 一个雇员实体类里面有员工姓名、薪水等,我想知道2个雇员对象是否是逻辑上相等

    3.如何重写一个equals方法了

    覆盖Object方法中equals方法需要遵循以下几个规范

    自反性. 对于任何非null的引用值x, x.equals(x)必须返回true. 通俗的讲自己跟自己比较返回true

    对称性 对于任何非null的引用值x和y,当且仅当y.equals(x)返回true时,x.equals(y)也必须返回true

    传递性 对于任何非null的引用值x、y、z,如果x.equals(y)返回true并且y.equals(z)也返回true,那么x.equals(z)也必须返回true

    一致性 对于任何非null的引用值x和y,只要equals的比较操作在对象中所用的信息没有被修改,多次调用x.equals(y)就会一致的返回true,或者一致的返回false

    非空性 对于任何非null的引用值x,x.equals(null)必须返回false

    如何实现一个equals()方法:

    1.使用==操作符检查“”参数是否为这个对象的引用”

    2.使用 instanceof 操作符检查"检查参数是否为正确的类型"

    3.把参数转换成正确的类型

    4.对于该类中的没给 “关键”域,检查参数中的域是否与该对象中对应的域相匹配相匹配

    package com.minglangx.object;

    import java.util.Date;

    import java.util.Objects;

    public class Employee {

    private String name;

    private double salary;

    private Date hireDay;

    @Override

    public boolean equals(Object obj) {

    // 如果为同一对象的不同引用,则相同

    if (this == obj) {

    return true;

    }

    // 如果传入的对象为空,则返回false

    if (obj == null) {

    return false;

    }

    // // 如果两者属于不同的类型,不能相等 这种情况只能是对象具有相同的实现才能使用

    // if (getClass() != obj.getClass()) {

    // return false;

    // }

    if( !(obj instanceof Employee) ) {

    return false;

    }

    // 类型相同, 比较内容是否相同

    Employee other = (Employee) obj;

    return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay);

    }

    }

    4为什么重写equals方法之前要重写hashCode方法

    因为 Object规范中说到: 相等的对象必须具有相等的散列码

    因为hashCode散列码的目的是为了HashSet、HashMap、HashTable比较的时候缩小范围空间,它只是返回一个散列整数然后根据散列码去散列桶中查找对象区间。它不保证对象是否是相等的

    展开全文
  • equals()方法的规范

    2021-07-06 16:38:31
    这里需要注意: 如果在两个参数都为null时需要返回true,那么应该使用Objects.equals(1,2) 如果不能接受有参数为null,或者两个参数不会为null,则使用a.equals(b) (当有一个参数为null时,a.equals(b)将会抛出...
  • equals方法规范的5个特性: 自反性:就是自己反过来跟自己比,要返回true;比如x.equals(x) == true 对称性:就是x.equals(y) == true时,也要y.equals(y) == true 传递性:就是x.equals(y) == true,同时y.equals(z...
  • 本文结合《Effective Java》第三章条目8《覆盖equals时请遵守通用约定》和自己的理解及实践,讲解了在覆盖equals时需要遵守的规范,文章发布于专栏Effective Java,欢迎读者订阅。
  • Equals比较规范

    2017-09-25 20:52:13
    public class Programminghabit { public static void ... * 两个字符串进行比较的时候,我们通常使用equals方法进行比较,虽然java虚拟机对字符串做了 * 优化,但是我们不能保证任何时候==都成立, * if(s1!=null&
  • Java规范重写equals方法

    2021-04-07 10:17:20
    近期在写Java代码时,经常忘记规范地重写equals方法,遂记录一下。 二. 解决方法 首先需要明确一点,equlas()方法是Object类的成员方法。 假设有一个Person类,我们要重写它的equals()方法,自己重写的代码如下所示...
  • equals标准写法

    2019-09-26 15:21:43
    equals标准写法 @Overridepublic boolean equals(Object obj) { //为了提高效率 if(this == obj){ return true; } //为了提供程序的健壮性 //我先判断一下,obj是不是学生的一个对...
  • (1)只要覆写equals,就必须覆写hashCode。 说明:因为Set存储的是不重复的对象,依据hashCode和equals进行判断,所以Set存储的对象必须覆写这两种方法。 (2)如果自定义对象作为Map的键,那么必须覆写hashCode...
  • 在看阿里巴巴Java开发手册手册时,看到了有关hashCode()和equals()方法的使用规范。 只要重写 equals,就必须重写 hashCode。 因为 Set 存储的是不重复的对象,依据 hashCode 和 equals 进行判断,所以 Set ...
  • equals方法详解

    千次阅读 2022-03-18 21:21:21
    Object 类中的 equals 方法是用于检测一个对象是否等于另外一个对象。在Object类中实现的 equals 方法将确定两个对象是否具有相同的引用(内存地址)。如果两个对象具有相同的引用,那么他们一定是相等的,看看下面...
  • Java equals方法判明

    2020-12-19 22:06:16
    `Object`类中的`equals`方法用于检测一个对象是否等于另一个对象。
  • Object.equals(other) 规范

    2019-06-20 21:08:56
    自反性:对于任何非空引用x,x.equals(x)应该返回true。 对称性:对于任何引用x和y,当且仅当y.equals(x)返回true,x.equals(y)也应该返回true。 传递性:对于任何引用x、y和z,如果x.equals(y)返回true,y.equals(z...
  • 当符合以下条件时不需要重写equals方法: 1.一个类的每一个实例本质上都是唯一的。 2.不关心一个类是否提供了“逻辑相等”的测试功能 3.超类已经改写了equals方法,并且从超类继承过来的行为对于子类也是合适的。...
  • equals 与 == 操作符

    2021-06-07 05:39:03
    ## 4、重写 equals 方法有什么官方规范 1. 自反性:x.equals(x) = true; 2. 对称性:如果有x.equals(y) = true,那么一定有y.equals(x) = true; 3. 传递性:对任意的x,y,z。如果有x.equals(y) = y.equals(z) = true,...
  • JAVA语言规范要求equals方法的特征JAVA语言规范要求equals方法的特征 JAVA语言规范要求equals方法的特征 自反性:对于任何非空引用x,x.equals(x)应该返回true 对称性:对于任一引用x和y,当且仅当y.equals(x)...
  • 两段代码的效果是一样的,那为什么编程规范里要把null提前呢? 假如你少写了个等号,写成a = null是不会报错的,但是null = o,会报错,所以习惯写null == o更好 “abc”.equals(str) 和 str.equals(“abc”) ...
  • Java深入理解equals

    2022-03-20 20:46:59
    Java深入理解equals 在Java中Object类中的equals方法用于检测一个对象是否等于另一个对象。注意:这里的等于指的是两个对象的引用是否相等,即所谓的地址,这看起来好像没啥问题;不就是两个对象引用相等,则两对象...
  • 基础数据类型只有==,没有equals方法,比较的是值 2 引用数据类型 ==比较的是引用类型对象在内存中存放的地址。准确的说是堆内存中的地址 equals() 是基类Object自带的方法,我们写的每个类都会有这个默认的方法,...
  • Java中,只有8种基本类型不是对象,例如:4种整形类型(byte, short, int,long),2种浮点类型(flout, double),boolean, char不是对象,其他的所有类型,...下面,我们首先学习一下Object中的equals方法. 判断两个对象相等...
  • 使用equals方法的时候可以将字符串常量放在前面避免可能发生的NullPointerException。
  • 在聊Java中的equals方法

    2021-02-27 20:46:08
    java规范equals方法特征自反性(对于任何非空引用x, x.equals(x) 返回true;)对称性(对于任何引用x, y, 当且仅当y.equals(x) 返回true, x.equals(y)返回true;)传递性(对于任何引用x, y, z, 若x.equals(y)返回true, y...
  • equals()超类Object中有这个equals()方法,该方法主要用于比较两个对象是否相等。该方法的源码如下:public boolean equals(Object obj) {return (this == obj);}我们知道所有的对象都拥有标识(内存地址)和状态(数据...
  • 相对于C++,Java并没有重载操作符,所以对于非基本类型都需要使用equals方法比较相等性.Object提供了equals方法比较两个对象,但对于用户自定义类而言Object提供的版本仅仅比较两个对象的引用是否相同,这在很多情况下并...
  • equals

    2019-03-14 11:39:23
    equals() 超类Object中有这个equals()方法,该方法主要用于比较两个对象是否相等。该方法的源码如下: public boolean equals(Object obj) { return (this == obj); } 我们知道所有的对象都拥有标识(内存...
  • 常量.equals(变量)

    2020-10-18 21:42:41
    常量.equals(变量) 变量.equals(常量),变量为null 会产生NullPointerException 例:正确用法 ```java String result = scanner.next(); if ("Y".equals(result) || "y".equals(result)) { //students.remove...
  • Java中如何避免equals方法的隐藏陷阱

    千次阅读 2016-09-07 14:33:24
    本文描述重载equals方法的技术,这种技术即使是具现类的子类增加了字段也能保证equal语义的正确性。 在《Effective Java》的第8项中,Josh Bloch描述了当继承类作为面向对象语言中的等价关系的基础问题,要保证...
  • Java基础-equals的编写

    2021-09-17 12:12:18
    编写equals 如何正确编写equals()方法?equals()方法要求我们必须满足以下条件: 自反性(Reflexive):对于非null的x来说,x.equals(x)必须返回true; 对称性(Symmetric):对于非null的x和y来说,如果x.equals(y...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,743
精华内容 37,497
关键字:

equals规范