下面论述正确的是（）？_

快乐的一只小喵

hashCode()方法和equals()方法的作用其实是一样的，在Java里都是用来对比两个对象是否相等一致。

那么equals()既然已经能实现对比的功能了，为什么还要hashCode()呢？因为重写的equals()里一般比较的比较全面比较复杂，这样效率就比较低，而利用hashCode()进行对比，则只要生成一个hash值进行比较就可以了，效率很高。

那么hashCode()既然效率这么高为什么还要equals()呢？因为hashCode()并不是完全可靠，有时候不同的对象他们生成的hashcode也会一样（生成hash值得公式可能存在的问题），所以hashCode()只能说是大部分时候可靠，并不是绝对可靠，

所以我们可以得出：

1.equals()相等的两个对象他们的hashCode()肯定相等，也就是用equals()对比是绝对可靠的。

2.hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。

所有对于需要大量并且快速的对比的话如果都用equals()去做显然效率太低，所以解决方式是，每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用equal()去再对比了）,如果hashCode()相同，此时再对比他们的equals()，如果equals()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性！

所以选D

编辑于 2018-08-17 15:32:05 回复(40)

林小七七

hashCode的常规协定是：

在 Java 应用程序执行期间，在同一对象上多次调用hashCode方法时，必须一致地返回相同的整数，前提是对象上equals比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
如果根据equals(Object)方法，两个对象是相等的，那么在两个对象中的每个对象上调用hashCode方法都必须生成相同的整数结果。
以下情况不是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用hashCode方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。
所以改变equals方法时，一定要重写hascode方法

发表于 2018-06-03 16:37:38 回复(0)

智能风暴来袭

HashMap中主要是通过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就一样。

发表于 2017-08-19 16:45:57 回复(0)

velong

hashcode和equals的约定关系如下：

1、如果两个对象相等，那么他们一定有相同的哈希值（hash code）。

2、如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）

发表于 2017-08-19 16:50:18 回复(10)

要上天的小火箭

A：在hashmap中，key值是不可能重复的，由hashCode和equals方法共同判断key值是否相等。即使两个对象的hashCode相同相等，也不能说他们的key值相等。

B和D：如果x.equals(y)返回true,那么这两个对象的hashCode返回的整数结果必然相同。如果x.equals(y)返回false,则不一定；

反之，hashCode返回的值不相等，则equals方法返回值一定不相等。hashCode返回值相等，则不一定

C:hashCode的值是可以相同的。

发表于 2017-10-15 22:36:47 回复(1)

morphy

等价的(调用equals返回true)对象必须产生相同的散列码。不等价的对象，不要求产生的散列码不相同。

发表于 2017-08-18 21:25:08 回复(0)

u9板载

d选项有问题,如果只重写了equals方法,没有重写hashcode方法,创建两个值相同的对象,他们的equals返回true,但是他们的hashcode不同

User a = new User(1); User b = new User(1); System.out.println(a.equals(b));         //true System.out.println(a.hashCode() == b.hashCode());    //false

编辑于 2019-01-20 21:36:09 回复(4)

泽恩泽恩

D 如果是string的话，两个字符串对象相等，hashcode也不一样吧？

发表于 2017-09-11 13:52:46 回复(2)

lonecloud

1. 首先可以说明该题问法不是很准确：

A.以下为HashMap中的源码:

public V get(Object key) {
    Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value;
}

可以看到由于调用的getNode方法

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k; 
    //判断是否为第一个元素相等，并且是hashCode和equals方法是否相等  if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
      if (first.hash == hash && // always check first node    ((k = first.key) == key || (key != null && key.equals(k))))  return first; 
           //判断其第一个元素不为空，则循环  if ((e = first.next) != null) {  if (first instanceof TreeNode)  return ((TreeNode<K,V>)first).getTreeNode(hash, key); 
                //循环获取key，如果key的hash值等于其hash值并且（（key值==e.key）或者key的equals方法==k）  do { if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))  return e;
                } while ((e = e.next) != null);
        }
    } return null;
}

从上面代码可只，如果其两个对象hashcode相等的并且返回两个相等值有以下两个条件：

1. hashcode相等

2. key中用==相等或者key使用equals()方法比较相等

由于我们并不知道其equals方法怎么编写的所以A错误

B.中没有说明equals方法是是怎么实现的，这完全依赖其实现的方法

C中也是需要根据其具体实现的决定

D.如果a.equals(b)返回true，那么a,b两个对象的hashcode必须相同，

虽然说了a.equals(b)返回true,其主要还是需要看起两个类中equals方法是怎么实现的：例如如下例子：

public static class User{  private String name; @Override  public boolean equals(Object o) {  if (this == o) return true;  if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;  return Objects.equals(name, user.name);
    }  public User(String name) {  this.name = name;
    }
} public static void main(String[] args) {
    User user=new User("demo");
    User user2=new User("demo");
    System.out.println(user.hashCode()==user2.hashCode());//false    System.out.println(user.equals(user2));//true }

由上可知：以上四个选项均无正确答案：

总结：对于自己以后实现的类实现hashCode以及equals方法需要都同时实现，如果需要在Map等类中进行使用的时候最好两个都实现，最好不好只实现equals不实现hashCode，这样容易导致问题！

欢迎加入群里交流问题：416052025

发表于 2018-06-15 21:11:37 回复(1)

luckystar92

①对象相等则hashCode一定相等; ②hashCode相等则对象未必相等，须进一步查询equals是否相等

发表于 2017-08-22 15:27:00 回复(0)

牛客812784320号

hashCode()方法和equals()方法的作用其实是一样的，在Java里都是用来对比两个对象是否相等一致。

那么equals()既然已经能实现对比的功能了，为什么还要hashCode()呢？因为重写的equals()里一般比较的比较全面比较复杂，这样效率就比较低，而利用hashCode()进行对比，则只要生成一个hash值进行比较就可以了，效率很高。

那么hashCode()既然效率这么高为什么还要equals()呢？因为hashCode()并不是完全可靠，有时候不同的对象他们生成的hashcode也会一样（生成hash值得公式可能存在的问题），所以hashCode()只能说是大部分时候可靠，并不是绝对可靠，

所以我们可以得出：

1.equals()相等的两个对象他们的hashCode()肯定相等，也就是用equals()对比是绝对可靠的。

2.hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。

所有对于需要大量并且快速的对比的话如果都用equals()去做显然效率太低，所以解决方式是，每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用equal()去再对比了）,如果hashCode()相同，此时再对比他们的equals()，如果equals()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性！

所以选D

发表于 2021-10-20 22:58:03 回复(1)

interfaceone

应该说的是Object，没有override equals方法

发表于 2017-09-26 18:20:29 回复(1)

持续。。。。

D的前提是不能重写equals

public class text {
    public static void main(String[] args){
        a a = new a();
        a a1 = new a();
        System.out.println(a.equals(a1));//true
        //二者hashCode值不同
        System.out.println(a.hashCode());
        System.out.println(a1.hashCode());
    }
}

class a {
    @Override
    public boolean equals(Object obj) {
        return true;
    }
}

logo

编辑于 2022-04-22 17:58:33 回复(0)

四月是木鱼的满分作文

**题目，**出题人，没有正确选项。D不对的原因是可以重写equals方法

编辑于 2020-11-10 15:23:40 回复(0)

陈耿聪是个狠人

下面几组的hashCode均相等
"柳柴"与"柴柕" hashCode=851553
"志捘"与"崇몈" hashCode=786017
AB错

 public boolean equals(Object var1) {
        if (this == var1) { //两个对象是否相同
            return true;
        } else {
            if (var1 instanceof String) { //看看var是不是 String类型
                String var2 = (String)var1;     
                int var3 = this.value.length; 
                if (var3 == var2.value.length) { //判断4长度是否相同
                    char[] var4 = this.value;
                    char[] var5 = var2.value;
                    for(int var6 = 0; var3-- != 0; ++var6) { //每个字符数组 构成字符串 
                        if (var4[var6] != var5[var6]) { //匹配每个字符
                            return false;
                        }
                    }
                    return true;
                }
            }
            return false;
        }
    }

hashCode()源码

private int hash;
public int hashCode() {
      int var1 = this.hash;//赋值对象中原有的变量hash
      if (var1 == 0 && this.value.length > 0) {//如果原本没有hash则生成
          char[] var2 = this.value;
          for(int var3 = 0; var3 < this.value.length; ++var3) {
              var1 = 31 * var1 + var2[var3];
          }
          this.hash = var1;
      }
      return var1;
  }

我们可以看出每生成一个类的hashCode都会保存到对象中，以后再获取都是同一个
C错

编辑于 2020-05-18 17:47:32 回复(0)