精华内容
下载资源
问答
  • JavahashCode 的作用

    2017-12-27 17:37:01
    JavahashCode 的作用

     Java 中 hashCode 的作用


    - HashCode的官方文档定义 -

    hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点,例如,java.util.Hashtable 提供的哈希表。   
      
    hashCode 的常规协定是:   
    在 Java 应用程序执行期间,在同一对象上多次调用 hashCode 方法时,必须一致地返回相同的整数,前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。   
    如果根据 equals(Object) 方法,两个对象是相等的,那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。   
    以下情况不 是必需的:如果根据 equals(java.lang.Object) 方法,两个对象不相等,那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是,程序员应该知道,为不相等的对象生成不同整数结果可以提高哈希表的性能。   
    实际上,由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。(这一般是通过将该对象的内部地址转换成一个整数来实现的,但是 JavaTM 编程语言不需要这种实现技巧。)   
      
    当equals方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。  

    看不懂没关系,咱们把关键的地方扣出来:

    1、hashCode的存在主要是用于查找的快捷性,如Hashtable,HashMap等,hashCode是用来在散列存储结构中确定对象的存储地址的;
    2、如果两个对象相同,就是适用于equals(java.lang.Object) 方法,那么这两个对象的hashCode一定要相同;
    3、如果对象的equals方法被重写,那么对象的hashCode也尽量重写,并且产生hashCode使用的对象,一定要和equals方法中使用的一致,否则就会违反上面提到的第2点;
    4、两个对象的hashCode相同,并不一定表示两个对象就相同,也就是不一定适用于equals(java.lang.Object) 方法,只能够说明这两个对象在散列存储结构中,如Hashtable,他们“存放在同一个篮子里”。

    - hashCode是用于查找使用的,而equals是用于比较两个对象的是否相等的 -

    例如内存中有这样的位置  
    0  1  2  3  4  5  6  7    
    而我有个类,这个类有个字段叫ID,我要把这个类存放在以上8个位置之一,如果不用hashcode而任意存放,那么当查找时就需要到这八个位置里挨个去找,或者用二分法一类的算法。  
    但如果用hashcode那就会使效率提高很多。  
    我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID%8,然后把我们的类存放在取得得余数那个位置。比如我们的ID为9,9除8的余数为1,那么我们就把该类存在1这个位置,如果ID是13,求得的余数是5,那么我们就把该类放在5这个位置。这样,以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。  
      
    2.但是如果两个类有相同的hashcode怎么办那(我们假设上面的类的ID不是唯一的),例如9除以8和17除以8的余数都是1,那么这是不是合法的,回答是:可以这样。那么如何判断呢?在这个时候就需要定义 equals了。  
    也就是说,我们先通过 hashcode来判断两个类是否存放某个桶里,但这个桶里可能有很多类,那么我们就需要再通过 equals 来在这个桶里找到我们要的类。  
    那么。重写了equals(),为什么还要重写hashCode()呢?  
    想想,你要在一个桶里找东西,你必须先要找到这个桶啊,你不通过重写hashcode()来找到桶,光重写equals()有什么用啊  
    


    - 案列 -

    public class HashTest {  
        private int i;  
      
        public int getI() {  
            return i;  
        }  
      
        public void setI(int i) {  
            this.i = i;  
        }  
      
        public int hashCode() {  
            return i % 10;  
        }  
      
        public final static void main(String[] args) {  
            HashTest a = new HashTest();  
            HashTest b = new HashTest();  
            a.setI(1);  
            b.setI(1);  
            Set<HashTest> set = new HashSet<HashTest>();  
            set.add(a);  
            set.add(b);  
            System.out.println(a.hashCode() == b.hashCode());  
            System.out.println(a.equals(b));  
            System.out.println(set);  
        }  
    }  

    输出结果:
    true  
    false  
    [com.ubs.sae.test.HashTest@1, com.ubs.sae.test.HashTest@1]  


    以上这个示例,我们只是重写了hashCode方法,从上面的结果可以看出,虽然两个对象的hashCode相等,但是实际上两个对象并不是相等;,我们没有重写equals方法,那么就会调用object默认的equals方法,是比较两个对象的引用是不是相同,显示这是两个不同的对象,两个对象的引用肯定是不定的。这里我们将生成的对象放到了HashSet中,而HashSet中只能够存放唯一的对象,也就是相同的(适用于equals方法)的对象只会存放一个,但是这里实际上是两个对象a,b都被放到了HashSet中,这样HashSet就失去了他本身的意义了。

    此时我们把equals方法给加上:


    public class HashTest {  
        private int i;  
      
        public int getI() {  
            return i;  
        }  
      
        public void setI(int i) {  
            this.i = i;  
        }  
      
        <span style="color:#3366FF;"><strong>public boolean equals(Object object) {  
            if (object == null) {  
                return false;  
            }  
            if (object == this) {  
                return true;  
            }  
            if (!(object instanceof HashTest)) {  
                return false;  
            }  
            HashTest other = (HashTest) object;  
            if (other.getI() == this.getI()) {  
                return true;  
            }  
            return false;  
        }</strong></span>  
      
        public int hashCode() {  
            return i % 10;  
        }  
      
        public final static void main(String[] args) {  
            HashTest a = new HashTest();  
            HashTest b = new HashTest();  
            a.setI(1);  
            b.setI(1);  
            Set<HashTest> set = new HashSet<HashTest>();  
            set.add(a);  
            set.add(b);  
            System.out.println(a.hashCode() == b.hashCode());  
            System.out.println(a.equals(b));  
            System.out.println(set);  
        }  
    }  

    输出结果:

    true  
    true  
    [com.ubs.sae.test.HashTest@1]  

    从结果我们可以看出,现在两个对象就完全相等了,HashSet中也只存放了一份对象。

    原文地址:http://blog.csdn.net/fenglibing/article/details/8905007  点击打开链接

    展开全文
  • JavahashCode的作用

    2016-09-22 11:42:16
    JavahashCode的作用

    以下是关于HashCode的官方文档定义:

        hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点,例如,java.util.Hashtable 提供的哈希表。   
          
        hashCode 的常规协定是:   
        在 Java 应用程序执行期间,在同一对象上多次调用 hashCode 方法时,必须一致地返回相同的整数,前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。   
        如果根据 equals(Object) 方法,两个对象是相等的,那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。   
        以下情况不 是必需的:如果根据 equals(java.lang.Object) 方法,两个对象不相等,那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是,程序员应该知道,为不相等的对象生成不同整数结果可以提高哈希表的性能。   
        实际上,由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。(这一般是通过将该对象的内部地址转换成一个整数来实现的,但是 JavaTM 编程语言不需要这种实现技巧。)   
          
        当equals方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。  

    以上这段官方文档的定义,我们可以抽出成以下几个关键点:

    1、hashCode的存在主要是用于查找的快捷性,如Hashtable,HashMap等,hashCode是用来在散列存储结构中确定对象的存储地址的;

    2、如果两个对象相同,就是适用于equals(Java.lang.Object) 方法,那么这两个对象的hashCode一定要相同;

    3、如果对象的equals方法被重写,那么对象的hashCode也尽量重写,并且产生hashCode使用的对象,一定要和equals方法中使用的一致,否则就会违反上面提到的第2点;

    4、两个对象的hashCode相同,并不一定表示两个对象就相同,也就是不一定适用于equals(java.lang.Object) 方法,只能够说明这两个对象在散列存储结构中,如Hashtable,他们“存放在同一个篮子里”


    再归纳一下就是hashCode是用于查找使用的,而equals是用于比较两个对象的是否相等的。以下这段话是从别人帖子回复拷贝过来的:

        1.hashcode是用来查找的,如果你学过数据结构就应该知道,在查找和排序这一章有  
        例如内存中有这样的位置  
        0  1  2  3  4  5  6  7    
        而我有个类,这个类有个字段叫ID,我要把这个类存放在以上8个位置之一,如果不用hashcode而任意存放,那么当查找时就需要到这八个位置里挨个去找,或者用二分法一类的算法。  
        但如果用hashcode那就会使效率提高很多。  
        我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID%8,然后把我们的类存放在取得得余数那个位置。比如我们的ID为9,9除8的余数为1,那么我们就把该类存在1这个位置,如果ID是13,求得的余数是5,那么我们就把该类放在5这个位置。这样,以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。  
          
        2.但是如果两个类有相同的hashcode怎么办那(我们假设上面的类的ID不是唯一的),例如9除以8和17除以8的余数都是1,那么这是不是合法的,回答是:可以这样。那么如何判断呢?在这个时候就需要定义 equals了。  
        也就是说,我们先通过 hashcode来判断两个类是否存放某个桶里,但这个桶里可能有很多类,那么我们就需要再通过 equals 来在这个桶里找到我们要的类。  
        那么。重写了equals(),为什么还要重写hashCode()呢?  
        想想,你要在一个桶里找东西,你必须先要找到这个桶啊,你不通过重写hashcode()来找到桶,光重写equals()有什么用啊  

    最后,我们来看一个具体的示例吧:

    public class HashTest {  
        private int i;  
      
        public int getI() {  
            return i;  
        }  
      
        public void setI(int i) {  
            this.i = i;  
        }  
      
        public int hashCode() {  
            return i % 10;  
        }  
      
        public final static void main(String[] args) {  
            HashTest a = new HashTest();  
            HashTest b = new HashTest();  
            a.setI(1);  
            b.setI(1);  
            Set<HashTest> set = new HashSet<HashTest>();  
            set.add(a);  
            set.add(b);  
            System.out.println(a.hashCode() == b.hashCode());  
            System.out.println(a.equals(b));  
            System.out.println(set);  
        }  
    } 
    这个输出的结果:

        true  
        false  
        [com.ubs.sae.test.HashTest@1, com.ubs.sae.test.HashTest@1]  

    以上这个示例,我们只是重写了hashCode方法,从上面的结果可以看出,虽然两个对象的hashCode相等,但是实际上两个对象并不是相等;,我们没有重写equals方法,那么就会调用object默认的equals方法,是比较两个对象的引用是不是相同,显示这是两个不同的对象,两个对象的引用肯定是不定的。这里我们将生成的对象放到了HashSet中,而HashSet中只能够存放唯一的对象,也就是相同的(适用于equals方法)的对象只会存放一个,但是这里实际上是两个对象a,b都被放到了HashSet中,这样HashSet就失去了他本身的意义了。

    此时我们把equals方法给加上:

        public class HashTest {  
            private int i;  
          
            public int getI() {  
                return i;  
            }  
          
            public void setI(int i) {  
                this.i = i;  
            }  
          
            <span style="color:#3366FF;"><strong>public boolean equals(Object object) {  
                if (object == null) {  
                    return false;  
                }  
                if (object == this) {  
                    return true;  
                }  
                if (!(object instanceof HashTest)) {  
                    return false;  
                }  
                HashTest other = (HashTest) object;  
                if (other.getI() == this.getI()) {  
                    return true;  
                }  
                return false;  
            }</strong></span>  
          
            public int hashCode() {  
                return i % 10;  
            }  
          
            public final static void main(String[] args) {  
                HashTest a = new HashTest();  
                HashTest b = new HashTest();  
                a.setI(1);  
                b.setI(1);  
                Set<HashTest> set = new HashSet<HashTest>();  
                set.add(a);  
                set.add(b);  
                System.out.println(a.hashCode() == b.hashCode());  
                System.out.println(a.equals(b));  
                System.out.println(set);  
            }  
        }  

    此时得到的结果就会如下:

        true  
        true  
        [com.ubs.sae.test.HashTest@1]  

    从结果我们可以看出,现在两个对象就完全相等了,HashSet中也只存放了一份对象。

    展开全文
  • Javahashcode

    2017-08-31 21:30:42
    Hash是散列的意思,就是把任意长度的输入,通过散列算法变换成固定长度的输出,该输出就是散列值。关于散列值,有以下几个关键结论: 1、如果散列表中存在和散列原始输入K相等的记录,那么K必定在f(K)的存储位置...



    在此之前我们先来了解下什么是Hash:

    Hash是散列的意思,就是把任意长度的输入,通过散列算法变换成固定长度的输出,该输出就是散列值。关于散列值,有以下几个关键结论:

    1、如果散列表中存在和散列原始输入K相等的记录,那么K必定在f(K)的存储位置上

    2、不同关键字经过散列算法变换后可能得到同一个散列地址,这种现象称为碰撞

    3、如果两个Hash值不同(前提是同一Hash算法),那么这两个Hash值对应的原始输入必定不同


    然后讲下什么是HashCode,总结几个关键点:

    1、HashCode的存在主要是为了查找的快捷性,HashCode是用来在散列存储结构中确定对象的存储地址的

    2、如果两个对象equals相等,那么这两个对象的HashCode一定也相同

    3、如果对象的equals方法被重写,那么对象的HashCode方法也尽量重写

    4、如果两个对象的HashCode相同,不代表两个对象就相同,只能说明这两个对象在散列存储结构中,存放于同一个位置


    首先,想要明白hashCode的作用,你必须要先知道Java中的集合。

    总的来说,Java中的集合(Collection)有两类,一类是List,再有一类是Set。前者集合内的元素是有序的,元素可以重复;后者元素无序,但元素不可重复。那么这里就有一个比较严重的问题了:要想保证元素不重复,可两个元素是否重复应该依据什么来判断呢?这就是Object.equals方法了。但是,如果每增加一个元素就检查一次,那么当元素很多时,后添加到集合中的元素比较的次数就非常多了。也就是说,如果集合中现在已经有1000个元素,那么第1001个元素加入集合时,它就要调用1000次equals方法。这显然会大大降低效率。

    于是,Java采用了哈希表的原理。哈希(Hash)实际上是个人名,由于他提出一哈希算法的概念,所以就以他的名字命名了。哈希算法也称为散列算法,是将数据依特定算法直接指定到一个地址上。如果详细讲解哈希算法,那需要更多的文章篇幅,所以这里就不介绍了。初学者可以这样理解,hashCode方法实际上返回的就是对象存储的物理地址(实际可能并不是)。

    这样一来,当集合要添加新的元素时,先调用这个元素的hashCode方法,就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素,它就可以直接存储在这个位置上,不用再进行任何比较了;如果这个位置上已经有元素了,就调用它的equals方法与新元素进行比较,相同的话就不存了,不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大低了,几乎只需要一两次。


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

    如果两个对象相同,那么它们的hashCode值一定要相同。

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

    为什么重写eqauls一定要重写hashcode

    由于为了提高程序的效率才实现了hashcode方法,先进行hashcode的比较,如果不同,那没就不必在进行equals的比较了,这样就大大减少了equals比较的次数,这对比需要比较的数量很大的效率提高是很明显的,在上面hashcode作用中我就举了一个在集合中的使用的列子。

    其实简单的说就是为了保证同一个对象,保证在equals相同的情况下hashcode值必定相同,如果重写了equals而未重写hashcode方法,可能就会出现两个没有关系的对象equals相同的(因为equal都是根据对象的特征进行重写的),但hashcode确实不相同的。

    展开全文
  • javahashCode方法

    2017-09-01 17:41:32
    以下是关于HashCode的官方文档定义: [plain] view plain copy print?... hashCode 的常规协定是: 在 Java 应用程序执行期间,在同一对象上多次调用 hashCode 方法时,必须一致地返回相同的整数,前提

    以下是关于HashCode的官方文档定义:

    1. hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点,例如,java.util.Hashtable 提供的哈希表。   
    2.   
    3. hashCode 的常规协定是:   
    4. 在 Java 应用程序执行期间,在同一对象上多次调用 hashCode 方法时,必须一致地返回相同的整数,前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。   
    5. 如果根据 equals(Object) 方法,两个对象是相等的,那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。   
    6. 以下情况不 是必需的:如果根据 equals(java.lang.Object) 方法,两个对象不相等,那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是,程序员应该知道,为不相等的对象生成不同整数结果可以提高哈希表的性能。   
    7. 实际上,由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。(这一般是通过将该对象的内部地址转换成一个整数来实现的,但是 JavaTM 编程语言不需要这种实现技巧。)   
    8.   
    9. 当equals方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。  
    hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点,例如,java.util.Hashtable 提供的哈希表。 
    
    hashCode 的常规协定是: 
    在 Java 应用程序执行期间,在同一对象上多次调用 hashCode 方法时,必须一致地返回相同的整数,前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。 
    如果根据 equals(Object) 方法,两个对象是相等的,那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。 
    以下情况不 是必需的:如果根据 equals(java.lang.Object) 方法,两个对象不相等,那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是,程序员应该知道,为不相等的对象生成不同整数结果可以提高哈希表的性能。 
    实际上,由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。(这一般是通过将该对象的内部地址转换成一个整数来实现的,但是 JavaTM 编程语言不需要这种实现技巧。) 
    
    当equals方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。

    以上这段官方文档的定义,我们可以抽出成以下几个关键点:

    1、hashCode的存在主要是用于查找的快捷性,如Hashtable,HashMap等,hashCode是用来在散列存储结构中确定对象的存储地址的;

    2、如果两个对象相同,就是适用于equals(Java.lang.Object) 方法,那么这两个对象的hashCode一定要相同;

    3、如果对象的equals方法被重写,那么对象的hashCode也尽量重写,并且产生hashCode使用的对象,一定要和equals方法中使用的一致,否则就会违反上面提到的第2点;

    4、两个对象的hashCode相同,并不一定表示两个对象就相同,也就是不一定适用于equals(java.lang.Object) 方法,只能够说明这两个对象在散列存储结构中,如Hashtable,他们“存放在同一个篮子里”


    再归纳一下就是hashCode是用于查找使用的,而equals是用于比较两个对象的是否相等的。以下这段话是从别人帖子回复拷贝过来的:

    1. 1.hashcode是用来查找的,如果你学过数据结构就应该知道,在查找和排序这一章有  
    2. 例如内存中有这样的位置  
    3. 0  1  2  3  4  5  6  7    
    4. 而我有个类,这个类有个字段叫ID,我要把这个类存放在以上8个位置之一,如果不用hashcode而任意存放,那么当查找时就需要到这八个位置里挨个去找,或者用二分法一类的算法。  
    5. 但如果用hashcode那就会使效率提高很多。  
    6. 我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID%8,然后把我们的类存放在取得得余数那个位置。比如我们的ID为9,9除8的余数为1,那么我们就把该类存在1这个位置,如果ID是13,求得的余数是5,那么我们就把该类放在5这个位置。这样,以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。  
    7.   
    8. 2.但是如果两个类有相同的hashcode怎么办那(我们假设上面的类的ID不是唯一的),例如9除以8和17除以8的余数都是1,那么这是不是合法的,回答是:可以这样。那么如何判断呢?在这个时候就需要定义 equals了。  
    9. 也就是说,我们先通过 hashcode来判断两个类是否存放某个桶里,但这个桶里可能有很多类,那么我们就需要再通过 equals 来在这个桶里找到我们要的类。  
    10. 那么。重写了equals(),为什么还要重写hashCode()呢?  
    11. 想想,你要在一个桶里找东西,你必须先要找到这个桶啊,你不通过重写hashcode()来找到桶,光重写equals()有什么用啊  
    1.hashcode是用来查找的,如果你学过数据结构就应该知道,在查找和排序这一章有
    例如内存中有这样的位置
    0  1  2  3  4  5  6  7  
    而我有个类,这个类有个字段叫ID,我要把这个类存放在以上8个位置之一,如果不用hashcode而任意存放,那么当查找时就需要到这八个位置里挨个去找,或者用二分法一类的算法。
    但如果用hashcode那就会使效率提高很多。
    我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID%8,然后把我们的类存放在取得得余数那个位置。比如我们的ID为9,9除8的余数为1,那么我们就把该类存在1这个位置,如果ID是13,求得的余数是5,那么我们就把该类放在5这个位置。这样,以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。
    
    2.但是如果两个类有相同的hashcode怎么办那(我们假设上面的类的ID不是唯一的),例如9除以8和17除以8的余数都是1,那么这是不是合法的,回答是:可以这样。那么如何判断呢?在这个时候就需要定义 equals了。
    也就是说,我们先通过 hashcode来判断两个类是否存放某个桶里,但这个桶里可能有很多类,那么我们就需要再通过 equals 来在这个桶里找到我们要的类。
    那么。重写了equals(),为什么还要重写hashCode()呢?
    想想,你要在一个桶里找东西,你必须先要找到这个桶啊,你不通过重写hashcode()来找到桶,光重写equals()有什么用啊


    最后,我们来看一个具体的示例吧,

    1. public class HashTest {  
    2.     private int i;  
    3.   
    4.     public int getI() {  
    5.         return i;  
    6.     }  
    7.   
    8.     public void setI(int i) {  
    9.         this.i = i;  
    10.     }  
    11.   
    12.     public int hashCode() {  
    13.         return i % 10;  
    14.     }  
    15.   
    16.     public final static void main(String[] args) {  
    17.         HashTest a = new HashTest();  
    18.         HashTest b = new HashTest();  
    19.         a.setI(1);  
    20.         b.setI(1);  
    21.         Set<HashTest> set = new HashSet<HashTest>();  
    22.         set.add(a);  
    23.         set.add(b);  
    24.         System.out.println(a.hashCode() == b.hashCode());  
    25.         System.out.println(a.equals(b));  
    26.         System.out.println(set);  
    27.     }  
    28. }  
    public class HashTest {
    	private int i;
    
    	public int getI() {
    		return i;
    	}
    
    	public void setI(int i) {
    		this.i = i;
    	}
    
    	public int hashCode() {
    		return i % 10;
    	}
    
    	public final static void main(String[] args) {
    		HashTest a = new HashTest();
    		HashTest b = new HashTest();
    		a.setI(1);
    		b.setI(1);
    		Set<HashTest> set = new HashSet<HashTest>();
    		set.add(a);
    		set.add(b);
    		System.out.println(a.hashCode() == b.hashCode());
    		System.out.println(a.equals(b));
    		System.out.println(set);
    	}
    }

    这个输出的结果:

    1. true  
    2. false  
    3. [com.ubs.sae.test.HashTest@1, com.ubs.sae.test.HashTest@1]  
    true
    false
    [com.ubs.sae.test.HashTest@1, com.ubs.sae.test.HashTest@1]

    以上这个示例,我们只是重写了hashCode方法,从上面的结果可以看出,虽然两个对象的hashCode相等,但是实际上两个对象并不是相等;,我们没有重写equals方法,那么就会调用object默认的equals方法,是比较两个对象的引用是不是相同,显示这是两个不同的对象,两个对象的引用肯定是不定的。这里我们将生成的对象放到了HashSet中,而HashSet中只能够存放唯一的对象,也就是相同的(适用于equals方法)的对象只会存放一个,但是这里实际上是两个对象a,b都被放到了HashSet中,这样HashSet就失去了他本身的意义了。

    此时我们把equals方法给加上:

    1. public class HashTest {  
    2.     private int i;  
    3.   
    4.     public int getI() {  
    5.         return i;  
    6.     }  
    7.   
    8.     public void setI(int i) {  
    9.         this.i = i;  
    10.     }  
    11.   
    12.     <span style="color:#3366FF;"><strong>public boolean equals(Object object) {  
    13.         if (object == null) {  
    14.             return false;  
    15.         }  
    16.         if (object == this) {  
    17.             return true;  
    18.         }  
    19.         if (!(object instanceof HashTest)) {  
    20.             return false;  
    21.         }  
    22.         HashTest other = (HashTest) object;  
    23.         if (other.getI() == this.getI()) {  
    24.             return true;  
    25.         }  
    26.         return false;  
    27.     }</strong></span>  
    28.   
    29.     public int hashCode() {  
    30.         return i % 10;  
    31.     }  
    32.   
    33.     public final static void main(String[] args) {  
    34.         HashTest a = new HashTest();  
    35.         HashTest b = new HashTest();  
    36.         a.setI(1);  
    37.         b.setI(1);  
    38.         Set<HashTest> set = new HashSet<HashTest>();  
    39.         set.add(a);  
    40.         set.add(b);  
    41.         System.out.println(a.hashCode() == b.hashCode());  
    42.         System.out.println(a.equals(b));  
    43.         System.out.println(set);  
    44.     }  
    45. }  
    public class HashTest {
    	private int i;
    
    	public int getI() {
    		return i;
    	}
    
    	public void setI(int i) {
    		this.i = i;
    	}
    
    	public boolean equals(Object object) {
    		if (object == null) {
    			return false;
    		}
    		if (object == this) {
    			return true;
    		}
    		if (!(object instanceof HashTest)) {
    			return false;
    		}
    		HashTest other = (HashTest) object;
    		if (other.getI() == this.getI()) {
    			return true;
    		}
    		return false;
    	}
    
    	public int hashCode() {
    		return i % 10;
    	}
    
    	public final static void main(String[] args) {
    		HashTest a = new HashTest();
    		HashTest b = new HashTest();
    		a.setI(1);
    		b.setI(1);
    		Set<HashTest> set = new HashSet<HashTest>();
    		set.add(a);
    		set.add(b);
    		System.out.println(a.hashCode() == b.hashCode());
    		System.out.println(a.equals(b));
    		System.out.println(set);
    	}
    }
    此时得到的结果就会如下:

    1. true  
    2. true  
    3. [com.ubs.sae.test.HashTest@1]  
    true
    true
    [com.ubs.sae.test.HashTest@1]

    从结果我们可以看出,现在两个对象就完全相等了,HashSet中也只存放了一份对象。


    展开全文
  • javahashCode值计算

    千次阅读 2017-01-13 16:58:03
    JavahashCode值计算 JavaHashCode的源码: Scala的HashCode的源码: scala调用的也是String这个类: 测试代码: package hash; public class HashRandom { public static void main(String[] args)...
  • java——hashCode

    2019-05-22 10:51:14
    因此如果想上述代码输出结果为“1”,很简单,只需要重写hashCode方法,让equals方法和hashCode方法始终在逻辑上保持一致性。 @Override public int hashCode() { return name.hashCode()*37+age; } @...
  • println()这个方法为什么会输出hashcode? 本篇文章将了解:println()方法的源码,String.valueOf()方法的重载,toString()方法的源码。 首先我们要知道,任何类的都继承自Object类,也就都集成了Object类中的...
  • 死磕Javahashcode与equals方法 hashCode方法与equals方法来源于Java最基本的类Object,这两个方法常用于自定义类在Java集合类中,类对象的判断等;掌握理解该方法是程序员必备技能。 01 hashCode  ...
  • javahashCode的作用

    2015-11-17 09:52:48
    hashcode
  • java bitset BitSet类hashCode()方法 (BitSet Class hashCode() method) hashCode() method is available in java.util package.hashCode()方法在java.util包中可用。 hashCode() method is used to retrieve hash ...
  • JavaHashcode

    2017-03-29 13:24:10
    原文:... 以下是关于HashCode的官方文档定义: ...hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点,例如,java.util.Hashtable 提供的
  • uuid hashcode UUID类hashCode()方法 (UUID Class ...hashCode() method is available in java.util package. hashCode()方法在java.util包中可用。 hashCode() method is used to retrieve the hash code fo...
  • a,在 Java 应用程序执行期间,在对同一对象多次调用hashCode方法时,必须一致地返回相同的整数 b,如果根据equals(Object)方法,两个对象是相等的,那么对这两个对象中的每个对象调用hashCode方法都必须生成相同的...
  • JavahashCode详解

    2016-01-29 10:30:19
    (转载自大神冯立斌的博客,写得非常好,膜拜!) 以下是关于HashCode的官方文档定义:...支持该方法是为哈希表提供一些优点,例如,java.util.Hashtable 提供的哈希表。    hashCode 的常规协定是:  在 J
  • JavaHashCode

    2013-09-06 16:03:01
    ·HashCode就是根据对象存储在内存的地址计算出的一个值。这个值可以标识这个对象的位置。也可以对比两个引用变量是否指向同一个对象。 ·String重写了hashCode方法——改为根据字符序列计算hashCode值,所以...
  • java enum方法 枚举类hashCode()方法 (Enum Class hashCode() method) hashCode() method is available in java.lang package. hashCode()方法在java.lang包中可用。 hashCode() method is used to retrieve the ...
  • java,hashcode,equals

    2014-06-26 14:33:26
    以下是关于HashCode的官方文档定义: [plain] view plaincopyprint?...hashcode方法返回该对象的... hashCode 的常规协定是: 在 Java 应用程序执行期间,在同一对象上多次调用 hashCode 方法时,必须一
  • java——hashcode()

    2016-07-13 10:17:29
    Java的Object类中有一个方法: 1 public native int hashCode();  根据这个方法的声明可知,该方法返回一个int类型的数值,并且是本地方法,因此在Object类中并...
  • hashCode 与 equals (重要) 面试官可能会问你:“你重写过 hashcode 和 equals 么,为什么重写equals时必须重写hashCode方法?” hashCode()介绍 hashCode() 的作用是获取...hashCode() 定义在JDK的Object.java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,337
精华内容 27,734
关键字:

java输出hashcode

java 订阅