Java中hashcode,equals和==

hashcode方法返回该对象的哈希码值。

hashCode()方法可以用来来提高Map里面的搜索效率的,Map会根据不同的hashCode()来放在不同的位置,Map在搜索一个对象的时候先通过hashCode()找到相应的位置,然后再根据equals()方法判断这个位置上的对象与当前要插入的对象是不是同一个。若两个对象equals相等,但不在一个区间,根本没有机会进行比较,会被认为是不同的对象。

所以,Java对于eqauls方法和hashCode方法是这样规定的:

1、如果两个对象相同,那么它们的hashCode值一定要相同,也告诉我们重写equals方法,一定要重写hashCode方法;

2、如果两个对象的hashCode相同,它们并不一定相同

hashCode()和equals()定义在Object类中,这个类是所有java类的基类,所以所有的java类都继承这两个方法。

注意到hashCode方法前面有个native的修饰符,这表示hashCode方法是由非java语言实现的,说明是一个本地方法,它的实现是根据本地机器相关的。具体的方法实现在外部,返回内存对象的地址。

/**
    * Returns a hash code value for the object. This method is
    * supported for the benefit of hashtables such as those provided by
    * <code>java.util.Hashtable</code>.
    * <p>
    * The general contract of <code>hashCode</code> is:
    * <ul>
    * <li>Whenever it is invoked on the same object more than once during
    *    an execution of a Java application, the <tt>hashCode</tt> method
    *    must consistently return the same integer, provided no information
    *    used in <tt>equals</tt> comparisons on the object is modified.
    *    This integer need not remain consistent from one execution of an
    *    application to another execution of the same application.
    * <li>If two objects are equal according to the <tt>equals(Object)</tt>
    *    method, then calling the <code>hashCode</code> method on each of
    *    the two objects must produce the same integer result.
    * <li>It is <em>not</em> required that if two objects are unequal
    *    according to the {@link java.lang.Object#equals(java.lang.Object)}
    *    method, then calling the <tt>hashCode</tt> method on each of the
    *    two objects must produce distinct integer results.  However, the
    *    programmer should be aware that producing distinct integer results
    *    for unequal objects may improve the performance of hashtables.
    * </ul>
    * <p>
    * As much as is reasonably practical, the hashCode method defined by
    * class <tt>Object</tt> does return distinct integers for distinct
    * objects. (This is typically implemented by converting the internal
    * address of the object into an integer, but this implementation
    * technique is not required by the
    * Java<font size="-2"><sup>TM</sup></font> programming language.)
    *
    * @return  a hash code value for this object.
    * @see    java.lang.Object#equals(java.lang.Object)
    * @see    java.util.Hashtable
    */
    public native int hashCode();

在java类中可以重写这两个方法,下面是String类中这两个类的实现。

/**
    * Compares this string to the specified object.  The result is {@code
    * true} if and only if the argument is not {@code null} and is a {@code
    * String} object that represents the same sequence of characters as this
    * object.
    *
    * @param  anObject
    *        The object to compare this {@code String} against
    *
    * @return  {@code true} if the given object represents a {@code String}
    *          equivalent to this string, {@code false} otherwise
    *
    * @see  #compareTo(String)
    * @see  #equalsIgnoreCase(String)
    */
    public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = count;
        if (n == anotherString.count) {
        char v1[] = value;
        char v2[] = anotherString.value;
        int i = offset;
        int j = anotherString.offset;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
            return false;
        }
        return true;
        }
    }
    return false;
    }

内容版权声明:除非注明,否则皆为本站原创文章。

转载注明出处:https://www.heiqu.com/27e1439feed7f396ffafbe5c876edb44.html