==、equals()、hashCode()源码及原理分析

最新推荐文章于 2023-12-16 00:52:39 发布
最新推荐文章于 2023-12-16 00:52:39 发布
阅读量311 收藏 1
点赞数
本文深入解析Java中对象比较的方法，包括==操作符比较地址、equals方法比较内容以及hashCode方法的作用和重要性。并通过实例演示了如何正确重写equals和hashCode方法以确保逻辑一致性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. == 

　　java中的==是比较两个对象在JVM中的地址。源码如下：

public class ComAddr{
    public static void main(String[] args) throws Exception {
        String s1 = "nihao";
        String s2 = "nihao";
        String s3 = new String("nihao");
        System.out.println(s1 == s2);    //    true
        System.out.println(s1 == s3);    //    false
    }
}

上述代码中：

　　(1)s1 == s2为true，是因为s1和s2都是字符串字面值"nihao"的引用，指向同一块地址，所以相等。

　　(2)s1 == s3为false，是因为通过new产生的对象在堆中，s3是堆中变量的引用，而是s1是指向字符串字面值"nihao"的引用，地址不同所以不相等。

(https://www.cnblogs.com/xudong-bupt/p/3960177.html)

2、equals() 

equals是根类Obeject中的方法。源代码如下：

public boolean equals(Object obj) {
    return (this == obj);
}

可见默认的equals方法，直接调用==，比较对象地址。

 　 不同的子类，可以重写此方法，进行两个对象的equals的判断。

　　String类源码中重写的equals方法如下，

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

举例解释（http://blog.youkuaiyun.com/reggergdsg/article/details/53819293）：

  1. static void hashcodeTest(){  
  2.       
  3.     String str = "yangcq";  
  4.       
  5.     // 第一步 = (int)'y'  
  6.     // 第二步 = (31 * (int)'y') + (int)'a'  
  7.     // 第三步 = 31 * ((31 * (int)'y') + (int)'a') + (int)'n'  
  8.     // 第四步 = 31 * (31 * ((31 * (int)'y') + (int)'a') + (int)'n') + (int)'g'  
  9.     // 第五步 = 31 * (31 * (31 * ((31 * (int)'y') + (int)'a') + (int)'n') + (int)'g') + (int)'c'  
  10.     // 第六步 = 31 * (31 * (31 * (31 * ((31 * (int)'y') + (int)'a') + (int)'n') + (int)'g') + (int)'c') + (int)'q'  
  11.       
  12.     // 上面的过程，也可以用下面的方式表示  
  13.       
  14.     // 第一步 = (int)'y'  
  15.     // 第二步 = 31 * (第一步的计算结果) + (int)'a'  
  16.     // 第三步 = 31 * (第二步的计算结果) + (int)'n'  
  17.     // 第四步 = 31 * (第三步的计算结果) + (int)'g'  
  18.     // 第五步 = 31 * (第四步的计算结果) + (int)'c'  
  19.     // 第六步 = 31 * (第五步的计算结果) + (int)'q'  
  20.       
  21.     int hashcode = 31 * (31 * (31 * (31 * ((31 * (int)'y') + (int)'a') + (int)'n') + (int)'g') + (int)'c') + (int)'q';  
  22.     System.out.println("yangcq的hashcode = " + hashcode);        // yangcq的hashcode = -737879313  
  23.     System.out.println("yangcq的hashcode = " + str.hashCode());  // yangcq的hashcode = -737879313  
  24.       
  25. }  

　从上面的代码中可以看到，

　　(1)String类中的equals首先比较地址，如果是同一个对象的引用，可知对象相等，返回true。

　　(2)若果不是同一个对象，equals方法挨个比较两个字符串对象内的字符，只有完全相等才返回true，否则返回false。

3、HashCode（） 

引用：https://www.cnblogs.com/dolphin0520/p/3681042.html

说通俗一点：Java中的hashCode方法就是根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。

有些朋友误以为默认情况下，hashCode返回的就是对象的存储地址，事实上这种看法是不全面的，确实有些JVM在实现时是直接返回对象的存储地址，但是大多时候并不是这样，只能说可能存储地址有一定关联。

在有些情况下，程序设计者在设计一个类的时候为需要重写equals方法，比如String类，但是千万要注意，在重写equals方法的同时，必须重写hashCode方法。为什么这么说呢？

package com.cxh.test1;
 
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
 
class People{
    private String name;
    private int age;
     
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
     
    public void setAge(int age){
        this.age = age;
    }
         
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}
 
public class Main {
 
    public static void main(String[] args) {
         
        People p1 = new People("Jack", 12);
        System.out.println(p1.hashCode());
             
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);
         
        System.out.println(hashMap.get(new People("Jack", 12)));
    }
}

在这里我只重写了equals方法，也就说如果两个People对象，如果它的姓名和年龄相等，则认为是同一个人。

　　这段代码本来的意愿是想这段代码输出结果为“1”，但是事实上它输出的是“null”。为什么呢？原因就在于重写equals方法的同时忘记重写hashCode方法。

　　虽然通过重写equals方法使得逻辑上姓名和年龄相同的两个对象被判定为相等的对象（跟String类类似），但是要知道默认情况下，hashCode方法是将对象的存储地址进行映射。那么上述代码的输出结果为“null”就不足为奇了。原因很简单，p1指向的对象和

　　System.out.println(hashMap.get(new People("Jack", 12)));这句中的new People("Jack", 12)生成的是两个对象，它们的存储地址肯定不同。下面是HashMap的get方法的具体实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

　　所以在hashmap进行get操作时，因为得到的hashcdoe值不同（注意，上述代码也许在某些情况下会得到相同的hashcode值，不过这种概率比较小，因为虽然两个对象的存储地址不同也有可能得到相同的hashcode值），所以导致在get方法中for循环不会执行，直接返回null。

　　因此如果想上述代码输出结果为“1”，很简单，只需要重写hashCode方法，让equals方法和hashCode方法始终在逻辑上保持一致性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.cxh.test1;
 
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
 
class People{
    private String name;
    private int age;
     
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
     
    public void setAge(int age){
        this.age = age;
    }
     
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()*37+age;
    }
     
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}
 
public class Main {
 
    public static void main(String[] args) {
         
        People p1 = new People("Jack", 12);
        System.out.println(p1.hashCode());
             
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);
         
        System.out.println(hashMap.get(new People("Jack", 12)));
    }
}

　　这样一来的话，输出结果就为“1”了。

　　下面这段话摘自Effective Java一书：

  • 在程序执行期间，只要equals方法的比较操作用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法必须始终如一地返回同一个整数。
  • 如果两个对象根据equals方法比较是相等的，那么调用两个对象的hashCode方法必须返回相同的整数结果。
  • 如果两个对象根据equals方法比较是不等的，则hashCode方法不一定得返回不同的整数。

　　对于第二条和第三条很好理解，但是第一条，很多时候就会忽略。在《Java编程思想》一书中的P495页也有同第一条类似的一段话：

　　“设计hashCode()时最重要的因素就是：无论何时，对同一个对象调用hashCode()都应该产生同样的值。如果在讲一个对象用put()添加进HashMap时产生一个hashCdoe值，而用get()取出时却产生了另一个hashCode值，那么就无法获取该对象了。所以如果你的hashCode方法依赖于对象中易变的数据，用户就要当心了，因为此数据发生变化时，hashCode()方法就会生成一个不同的散列码”。

　　下面举个例子：

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package com.cxh.test1;
 
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
 
class People{
    private String name;
    private int age;
     
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
     
    public void setAge(int age){
        this.age = age;
    }
     
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()*37+age;
    }
     
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}
 
public class Main {
 
    public static void main(String[] args) {
         
        People p1 = new People("Jack", 12);
        System.out.println(p1.hashCode());
         
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);
         
        p1.setAge(13);
         
        System.out.println(hashMap.get(p1));
    }
}

　　这段代码输出的结果为“null”，想必其中的原因大家应该都清楚了。

　　因此，在设计hashCode方法和equals方法的时候，如果对象中的数据易变，则最好在equals方法和hashCode方法中不要依赖于该字段。

　　以上属个人理解，如有不正之处，欢迎批评指正。


ForPan
关注
漫谈: Java equals和 hashCode 关系
weixin_44199502的博客
06-10 980
Override我们还是用上面String的方式去分析两个Worker对象的相等性:很显然, 通过==比较两者依然返回false, 而使用equals就能得出true: 我们通过源码分析即可:① this与传入对象的地址进行比较, 成立返回true;②如果传入对象为null(这里的this必定不为null)或者this的类型和传入对象的类型不相等的话直接 返回false;
Java 中 hashCode 和 equals 方法是什么？它们与 == 操作符有什么区别？
最新发布
2302_81141145的博客
03-12 647
哈希桶（Hash Bucket）是哈希表（Hash Table）中用来存储数据的一种结构。它是哈希表的核心组成部分，帮助解决哈希冲突问题。存储映射到相同哈希值的多个元素。每个哈希桶可以是一个简单的链表、数组、红黑树或其他数据结构，用来容纳冲突的元素。哈希桶通过哈希函数映射而成，数组的每个索引位置可以看作是一个桶。哈希桶是哈希表的基础单元，用于存储冲突的键值对。它通过链表、红黑树等结构解决了哈希冲突。Java 的HashMap利用哈希桶实现，结合链表和红黑树来优化性能。equals。
Java中equals()与hashCode()的原理与设计
12-22
1、何时需要重写equals() 　　当一个类有自己特有的“逻辑相等”概念（不同于对象身份的概念）。 　　2、为什么改写equals()的时候，总是要改写hashCode() 　　两个原则： 　　hashCode()的返回值和equals()的关系如下： 　　如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。 　　如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。 　　简单的说，“相等的对象必须具有相等的散列码”。 　　3、什么是equals()与如何设计equals()
equals和hashCode源码解析
乒乓狂魔的专栏
09-12 464
[size=medium]equals和hashCode网上也有很多的资料。这里只是记录下我目前的理解与认识。 大家会经常听到这样的话，当你重写equals方法时，尽量要重写hashCode方法，有些人却并不知道为什么要这样，待会就会给出源码说明这个原因。 首先来介绍下Object的equals和hashCode方法。如下：[/size] [code="java"] public na...
深入解析hashcode,hashMap源码
独孤——依人
09-10 5406
以下是关于HashCode的官方文档定义： [plain] view plaincopy hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点，例如，java.util.Hashtable 提供的哈希表。       hashCode 的常规协定是：    在 Java 应用程序执行期间，在同一对象上多次调用 hash
java中的==、equals()、hashCode()源码分析
请叫我大师兄
08-22 3017
1. ==  　　java中的==是比较两个对象在JVM中的地址。比较好理解。看下面的代码： public class ComAddr{ public static void main(String[] args) throws Exception { String s1 = "nihao"; String s2 = "nihao";
hashCode()方法 源码
weixin_43273005的博客
11-21 1028
（一）native关键字 Object类中的： public native int hashCode(); //native关键字表明该方法是原生函数，即该方法是用C/C++语言来实现的，并且被编译成了DLL，由Java去调用。 Java平台有个用户和本地C代码进行交互操作的API，称为Java Native Interface（JNI），即Java本地接口。 native方法，在加载库后才起作用。是与C++联合开发时用到的，Java自己开发不用。 native方法的实现步骤： 1.在Java中声明nat
深入分析Java源码及hashCode方法的实现
在描述中提到的“这是一个关于java源码分析,javahashcode源码,可以用来学习java实战项目案例，欢迎一起交流学习”则是对Java源码分析和hashCode方法源码学习的进一步说明，强调了学习这些内容对实战项目的重要性，并...
C#获得hashCode源码，可生成32位和64位，获得的结果不一样
11-04
标题提到的“C#获得hashCode源码，可生成32位和64位，获得的结果不一样”暗示了在不同环境或平台下，`GetHashCode`的实现可能产生不同的结果。 `GetHashCode`方法默认是由编译器生成的，但也可以由程序员重写以提供...
hashCode() 和 equals()的关系
global_coding的博客
06-26 1831
一.基础：hashCode() 和 equals() 简介在学习 hashCode() 和 equals() 之间的关系之前, 我们有必要先单独地了解他俩的特点.equals()equals() 方法用于比较两个对象是否相等，它与 == 相等比较符有着本质的不同。在万物皆对象的 Java 体系中，系统把判断对象是否相等的权力交给程序员。具体的措施是把 equals() 方法写到 Object 类中...
hashcode源码解析
龙池小生
04-22 816
hashcode源码： 源码解析：hash 默认为 0，value为hashcode对象的char[]类型 由第1456行可以得出，hashcode的计算公式为：s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 其中s[0]、s[1]为对应的ASCII码。 计算公式对应第1470-1472行的for循环。 参照源码，我们可以自己编写代码实现h...
HashCode源码解析
花驴的博客
11-09 4642
在实际的工作中我们经常会用到hashCode,不管是简单哈希还是一致性哈希,底层的哈希算法都是一样的,今天参考源码做一个回顾: 先看hashCode的源码: /** * Returns a hash code for this string. The hash code for a * {@code String} object is computed as * &l...
HashCode源码分析
weixin_43360297的博客
09-24 322
HashMap的源码分析 简介 在Java集合中，Map是一种特殊的集合，原因在于这种集合容器并不是保存的单个元素，而是一个个的key-value键值对。HashMap是基于哈希表的Map接口的实现，在项目开发中，这种集合使用是非常广泛的，本文主要就是对HashMap的底层原理做个剖析。 HashMap的特点 HashMap是基于哈希表的Map接口实现。 HashMap底层采用的是Entry数组...
hashCode源码分析
fengz7的博客
10-13 831
String的hashCode方法源码 public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { char val[] = value; for (int i = 0; i < value.length; i++) { h = 31 * h + val[i];
equals原理
wanwenjieGood的博客
06-20 2493
在java中，"=="和"equals()"区别是什么？ 恐怕大多数人都会回答，第一个是用来比较地址，第二个是用来比较内容的吧。这个回答并不准确 例如 输出的结果为false，而用String输出的却是true 这是为什么呢？ 查看object的qeuals方法发现 public boolean equals (Object x){ return this == x; } Object的...
String类的hashCode()方法源码分析
weixin_53622554的博客
12-16 1907
编译期间，字符串的最大长度不能超越65535个字节，即编译期间的String字符串的最大长度为65534个字节，不然就会编译报错。运行期间，String的最大长度就要看Integer.MAX_VALUE的值了，即：2^31 - 1个字节。不管怎样，String的最大长度就不能超过虚拟机当前最大内存设置。
hashCode()方法源码执行简要分析
qq_42907029的博客
10-03 246
执行代码 public class Demo06 { public static void main(String[] args) { String s="hello"; System.out.println(s.hashCode()); } } 以下是hashCode()源码 public int hashCode() { int h = hash; if (h == 0 && value.lengt
string.Equals(string)和==的原理
fanruinet的专栏
01-14 3709
  　　在我写了一篇毫无价值的文章之后，经过进一步研究，补充了这部分，搞明白了为什么会出现上次的结果。最后面灰色字体是上一篇文章，有错误，仅供参考，大家只看黑色字体就可以了。  　　写完了上一篇文章，我不得不接受批评。很明显，我没有读过《Applied Microsoft .NET Framework Programming》一书，不然就不会进行这样的测试了。而且，测试方法也写得不对。
你真的知道“==”、equals()、hashCode的区别吗？
weixin_45548912的博客
06-06 230
首先三者都可以用来比较，主要是比较的内容不同 ==： 如果是基本类型相比，就是比较他们的值是否相同，因为基本数据类型他们的值是直接存在栈中的 如果是引用数据类型比较，就是比较他们的内存地址是否相同，因为对象是存在堆中，而栈中存储的是它的引用内存地址 equals(): 只用于对象之间的比较 默认情况下，用的是Object类下的equals()方法，它是用来比较对象的地址值 如果在equals()方法被重写的情况下，就要按照重写的方法体去执行比较，比如说String类下的equals就被重写为比较两个对
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值