How do we decide on the best implementation of `hashCode()` method for a collection (assuming that equals method has been overridden correctly) ?

Best implementation for hashCode method for a collection

I have this test code:

    import java.util.*;
    
    class MapEQ {
    
      public static void main(String[] args) {
       Map&lt;ToDos, String&gt; m = new HashMap&lt;ToDos, String&gt;();
       ToDos t1 = new ToDos(&quot;Monday&quot;);
       ToDos t2 = new ToDos(&quot;Monday&quot;);
       ToDos t3 = new ToDos(&quot;Tuesday&quot;);
       m.put(t1, &quot;doLaundry&quot;);
       m.put(t2, &quot;payBills&quot;);
       m.put(t3, &quot;cleanAttic&quot;);
       System.out.println(m.size());
    } }
    
    class ToDos{
    
      String day;
    
      ToDos(String d) { day = d; }
    
      public boolean equals(Object o) {
          return ((ToDos)o).day == this.day;
     }

    // public int hashCode() { return 9; }
    }


When `// public int hashCode() { return 9; }` is uncommented  `m.size()` returns 2, when it&#39;s left commented it returns three. Why?



Understanding the workings of equals and hashCode in a HashMap

To quote from [Guidelines and rules for GetHashCode][1]  by  Eric Lippert:

&gt; Rule: **Consumers of GetHashCode cannot rely upon it being stable over time or across appdomains**
&gt; 
&gt; Suppose you have a Customer object
&gt; that has a bunch of fields like Name,
&gt; Address, and so on. If you make two
&gt; such objects with exactly the same
&gt; data in two different processes, they
&gt; do not have to return the same hash
&gt; code. If you make such an object on
&gt; Tuesday in one process, shut it down,
&gt; and run the program again on
&gt; Wednesday, the hash codes can be
&gt; different.
&gt; 
&gt; This has bitten people in the past.
&gt; The documentation for
&gt; System.String.GetHashCode notes
&gt; specifically that two identical
&gt; strings can have different hash codes
&gt; in different versions of the CLR, and
&gt; in fact they do. **Don&#39;t store string hashes in databases and expect them to be the same forever, because they won&#39;t be.**

So what is the correct way to create a HashCode of a string that I can store in a database?   

(Please tell me I am not the first person to have left this bug in software I have written!)


  [1]: http://ericlippert.com/2011/02/28/guidelines-and-rules-for-gethashcode/

How do I create a HashCode in .net (c#) for a string that is safe to store in a database?

This is odd.  A co-worker asked about the implementation of myArray.hashCode() in java.  I thought I knew but then I ran a few tests.  Check the code below.  The odd thing I noticed is that when I wrote the first sys out the results were different.  Note that it&#39;s almost like it&#39;s reporting a memory address and modifying the class moved the address or something.  Just thought I would share.

    int[] foo = new int[100000];
    java.util.Random rand = new java.util.Random();

    for(int a = 0; a &lt; foo.length; a++) foo[a] = rand.nextInt();

    int[] bar = new int[100000];
    int[] baz = new int[100000];
    int[] bax = new int[100000];
    for(int a = 0; a &lt; foo.length; a++) bar[a] = baz[a] = bax[a] = foo[a];

    System.out.println(foo.hashCode() + &quot; ----- &quot; + bar.hashCode() + &quot; ----- &quot; + baz.hashCode() +  &quot; ----- &quot; + bax.hashCode());

    // returns 4097744 ----- 328041 ----- 2083945 ----- 2438296
    // Consistently unless you modify the class.  Very weird
    // Before adding the comments below it returned this:
    // 4177328 ----- 4097744 ----- 328041 ----- 2083945


    System.out.println(&quot;Equal ?? &quot; +
      (java.util.Arrays.equals(foo, bar) &amp;&amp; java.util.Arrays.equals(bar, baz) &amp;&amp;
      java.util.Arrays.equals(baz, bax) &amp;&amp; java.util.Arrays.equals(foo, bax)));



Java Array HashCode implementation

How do [`Object.hashCode()`][1] and [`System.identityHashCode()`][2] work at the back end? Does `identityHashCode()` return the reference of the object? Does `hashCode()` depend on the content or address of the object? 

What is the difference between `hashCode()` and `identityHashCode()`? 


  [1]: http://download.oracle.com/javase/6/docs/api/java/lang/Object.html#hashCode()
  [2]: http://download.oracle.com/javase/6/docs/api/java/lang/System.html#identityHashCode(java.lang.Object)

How do hashCode() and identityHashCode() work at the back end?

I often see code like

    int hashCode(){
      return a^b;
    }
Why XOR?




Why are XOR often used in java hashCode() but another bitwise operators are used rarely?

When a class in Java doesn&#39;t override **hashCode()**, 
printing an instance of this class gives a nice unique number.

The Javadoc of Object says about **hashCode()**:
&gt; *As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects.*

But when the class overrides **hashCode()**, how can I get
its unique number?

How to get the unique ID of an object which overrides hashCode()?

Is there any method to generate MD5 hash of a string in Java?

How can I generate an MD5 hash in Java?

As per my understanding I think:

1. It is perfectly legal for two objects to have the same hashcode.
2. If two objects are equal (using the equals() method) then they have the same hashcode.
3. If two objects are not equal then they cannot have the same hashcode

Am I correct?

Now if am correct, I have the following question:
The `HashMap` internally uses the hashcode of the object. So if two objects can have the same hashcode, then how can the `HashMap` track which key it uses?

Can someone explain how the `HashMap` internally uses the hashcode of the object?

How does a Java HashMap handle different objects with the same hash code?

What&#39;s a correct and good way to implement `__hash__()`?

I am talking about the function that returns a hashcode that is then used to insert objects into hashtables aka dictionaries.

As `__hash__()` returns an integer and is used for &quot;binning&quot; objects into hashtables I assume that the values of the returned integer should be uniformly distributed for common data (to minimize collisions).
What&#39;s a good practice to get such values? Are collisions a problem?
In my case I have a small class which acts as a container class holding some ints, some floats and a string.

What&#39;s a correct and good way to implement __hash__()?

A strict equality operator will tell you if two object **types** are equal. However, is there a way to tell if two objects are equal, **much like the hash code** value in Java?

Stack Overflow question *[Is there any kind of hashCode function in JavaScript?][1]* is similar to this question, but requires a more academic answer. The scenario above demonstrates why it would be necessary to have one, and I&#39;m wondering if there is any **equivalent solution**.

  [1]: https://stackoverflow.com/questions/194846


How to determine equality for two JavaScript objects?

I was just wondering why is that primes are used in a class&#39;s `hashCode()` method? For example, when using Eclipse to generate my `hashCode()` method there is always the prime number `31` used:

    public int hashCode() {
         final int prime = 31;
         //...
    }

**References:**

Here is a good primer on Hashcode and article on how hashing works that I found (C# but the concepts are transferrable):
[Eric Lippert&#39;s Guidelines and rules for GetHashCode()][1]


  [1]: http://ericlippert.com/2011/02/28/guidelines-and-rules-for-gethashcode/

Why use a prime number in hashCode?

I&#39;m trying to think up a good hash function for strings.  And I was thinking it might be a good idea to sum up the unicode values for the first five characters in the string (assuming it has five, otherwise stop where it ends).  Would that be a good idea, or is it a bad one?

I am doing this in Java, but I wouldn&#39;t imagine that would make much of a difference.

Good Hash Function for Strings

In Java, `obj.hashCode()` returns some value. What is the use of this hash code in programming?

What is the use of hashCode in Java?

Basically, I&#39;m trying to create an object of unique objects, a set. I had the brilliant idea of just using a JavaScript object with objects for the property names. Such as,

    set[obj] = true;

This works, up to a point. It works great with string and numbers, but with other objects, they all seem to &quot;hash&quot; to the same value and access the same property. Is there some kind of way I can generate a unique hash value for an object? How do strings and numbers do it, can I override the same behavior?


Is there hash code function accepting any object type?

I&#39;m curious to know, what people here think about using 
`org.apache.commons.lang.builder` `EqualsBuilder`/`HashCodeBuilder`
for implementing the `equals`/`hashCode`? Would it be a better practice than writing your own? Does it play well with Hibernate? What&#39;s your opinion?

Apache Commons equals/hashCode builder

Please take a look at the picture below.
When we create an object in java with the `new` keyword, we are getting a memory address from the OS.

When we write `out.println(objName)` we can see a &quot;special&quot; string as output. My questions are:

1. What is this output?
2. If it is memory address which given by OS to us:

 a) How can I convert this string to binary?

 b) How can I get one integer variables address?

![alt text][1]


  [1]: https://content.screencast.com/users/uzay95/folders/Jing/media/f3caf9f8-b109-41d4-a477-0ad7c10504ce/2009-12-25_1456.png

Memory address of variables in Java

The hashCode value of a Java String is computed as (&lt;a href=&quot;http://java.sun.com/javase/6/docs/api/java/lang/String.html#hashCode()&quot;&gt;String.hashCode()&lt;/a&gt;):

    s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

Are there any circumstances (say JVM version, vendor, etc.) under which the following expression will evaluate to false?

    boolean expression = &quot;This is a Java string&quot;.hashCode() == 586653468

&lt;b&gt;Update #1:&lt;/b&gt; If you claim that the answer is &quot;yes, there are such circumstances&quot; - then please give a concrete example of when &quot;This is a Java string&quot;.hashCode() != 586653468. Try to be as specific/concrete as possible.

&lt;b&gt;Update #2:&lt;/b&gt; We all know that relying on the implementation details of hashCode() is bad in general. However, I&#39;m talking specifically about String.hashCode() - so please keep the answer focused to String.hashCode(). Object.hashCode() is totally irrelevant in the context of this question.


Consistency of hashCode() on a Java string

I read in the Essential C# 3.0 and .NET 3.5 book that:

&gt;GetHashCode()’s returns over the life of a particular object should be
constant (the same value), even if the object’s data changes. In many
cases, you should cache the method return to enforce this.

Is this a valid guideline?

I have tried a couple built-in types in .NET and they didn&#39;t behave like this.



GetHashCode Guidelines in C#

I notice there is a `getHashCode()` method in every controls, items, in WP7, which return a sequence of number. Can I use this hashcode to identify an item? For example I want to identify a picture or a song in the device, and check it whereabout. This could be done if the hashcode given for specific items is unique.

Can you help explain to me what is hashCode and `getHashCode()` use for?

What is hashCode used for? Is it unique?

What issues / pitfalls must be considered when overriding `equals` and `hashCode`?

What issues should be considered when overriding equals and hashCode in Java?

I have a 2D array of Integers. I want them to be put into a HashMap. But I want to access the elements from the HashMap based on Array Index. Something like:

For A[2][5], `map.get(2,5)` which returns a value associated with that key. But how do I create a hashMap with a pair of keys? Or in general, multiple keys: `Map&lt;((key1, key2,..,keyN), Value)` in a way that I can access the element with using get(key1,key2,...keyN).
 

**EDIT :  3 years after posting the question, I want to add a bit more to it**

I came across another way for `NxN matrix`. 

Array indices, `i` and `j` can be represented as a single `key` the following way:

    int key = i * N + j;
    //map.put(key, a[i][j]); // queue.add(key); 

And the indices can be retrevied from the `key` in this way:

    int i = key / N;
    int j = key % N;





How to create a HashMap with two keys (Key-Pair, Value)?

Is there a way of getting a unique identifier of an instance?

`GetHashCode()` is the same for the two references pointing to the same instance. However, two different instances can (quite easily) get the same hash code:

    Hashtable hashCodesSeen = new Hashtable();
    LinkedList&lt;object&gt; l = new LinkedList&lt;object&gt;();
    int n = 0;
    while (true)
    {
        object o = new object();
        // Remember objects so that they don&#39;t get collected.
        // This does not make any difference though :(
        l.AddFirst(o);
        int hashCode = o.GetHashCode();
        n++;
        if (hashCodesSeen.ContainsKey(hashCode))
        {
            // Same hashCode seen twice for DIFFERENT objects (n is as low as 5322).
            Console.WriteLine(&quot;Hashcode seen twice: &quot; + n + &quot; (&quot; + hashCode + &quot;)&quot;);
            break;
        }
        hashCodesSeen.Add(hashCode, null);
    }

I&#39;m writing a debugging addin, and I need to get some kind of ID for a reference which is unique during the run of the program.

I already managed to get internal ADDRESS of the instance, which is unique until the garbage collector (GC) compacts the heap (= moves the objects = changes the addresses).

Stack&amp;nbsp;Overflow question *[Default implementation for Object.GetHashCode()][5]* might be related.

The objects are not under my control as I am accessing objects in a program being debugged using the debugger API. If I was in control of the objects, adding my own unique identifiers would be trivial.

I wanted the unique ID for building a hashtable ID -&gt; object, to be able to lookup already seen objects. For now I solved it like this:

    Build a hashtable: &#39;hashCode&#39; -&gt; (list of objects with hash code == &#39;hashCode&#39;)
    Find if object seen(o) {
        candidates = hashtable[o.GetHashCode()] // Objects with the same hashCode.
        If no candidates, the object is new
        If some candidates, compare their addresses to o.Address
            If no address is equal (the hash code was just a coincidence) -&gt; o is new
            If some address equal, o already seen
    }

   [5]: https://stackoverflow.com/questions/720177/default-implementation-for-object-gethashcode


.NET unique object identifier

The `hashCode()` method of class Boolean is implemented like this:

    public int hashCode() {
        return value ? 1231 : 1237;
    }

Why does it use 1231 and 1237? Why not something else?


Boolean.hashCode()

I would like to print the &quot;object reference&quot; of an object in Java for debugging purposes.
I.e. to make sure that the object is the same (or different) depending on the situation.


The problem is that the class in question inherits from another class, which has overriden both toString() and hashCode() which would usually give me the id.

Example situation:
Running a multi-threaded application, where I (during development) want to check if all the threads use the same instance of a resource object or not.

How do you get the &quot;object reference&quot; of an object in java when toString() and hashCode() have been overridden?

Say I have my own class

    public class MyObj { /* ... */ }

It has some attributes and methods. It DOES NOT implement equals, DOES NOT implement hashCode.

Once we call equals and hashCode, what are the default implementations? From Object class? And what are they? How the default equals will work? How the default hashCode will work and what will return? == will just check if they reference to the same object, so it&#39;s easy, but what about equals() and hashCode() methods?


How default .equals and .hashCode will work for my classes?

How should model class&#39;s equals and hashcode be implemented in Hibernate? What are the common pitfalls? Is the default implementation good enough for most cases? Is there any sense to use business keys?

It seems to me that it&#39;s pretty hard to get it right to work in every situation, when lazy fetching, id generation, proxy, etc are taken into account.

How should equals and hashcode be implemented when using JPA and Hibernate

I want to hash given `byte[]` array with using `SHA1` Algorithm with the use of `SHA1Managed`.&lt;br/&gt;
The `byte[]` hash will come from unit test. &lt;br/&gt;
Expected hash is `0d71ee4472658cd5874c5578410a9d8611fc9aef` (case sensitive).

How can I achieve this?

    public string Hash(byte [] temp)
    {
        using (SHA1Managed sha1 = new SHA1Managed())
        {
                    
        }
    }


Hashing with SHA1 Algorithm in C#

Recently I read through this
&lt;a href=&quot;http://www.ibm.com/developerworks/java/library/j-jtp05273.html&quot;&gt; Developer Works Document&lt;/a&gt;. 

The document is all about defining `hashCode()` and `equals()` effectively and correctly, however I am not able to figure out why we need to override these two methods. 

How can I take the decision to implement these methods efficiently?




Why do I need to override the equals and hashCode methods in Java?

Can people recommend quick and simple ways to combine the hash codes of two objects.  I am not too worried about collisions since I have a Hash Table which will handle that efficiently I just want something that generates a code quickly as possible.

Reading around SO and the web there seem to be a few main candidates:

 1. XORing
 1. XORing with Prime Multiplication
 1. Simple numeric operations like multiplication/division (with overflow checking or wrapping around)
 1. Building a String and then using the String classes Hash Code method

What would people recommend and why?

Quick and Simple Hash Code Combinations

I find myself wanting to override hashcode and == for an object, and I&#39;m wondering if there are best practices for how to implement a hashcode that depends on multiple attributes, and it seems like there are some Dart-specific considerations.

The simplest answer would be to XOR the hashes of all the attributes together, and it&#39;s probably not too bad. There&#39;s also an example in Dart Up and Running at https://www.dartlang.org/docs/dart-up-and-running/contents/ch03.html

&lt;!-- language: lang-dart --&gt;

      // Override hashCode using strategy from Effective Java, Chapter 11.
     int get hashCode {
       int result = 17;
       result = 37 * result + firstName.hashCode;
       result = 37 * result + lastName.hashCode;
       return result;
     }

but that seems like it expects truncating integer semantics and in Dart overflowing the range of JS integers seems bad for hashing.

We could also do that and just truncate to 32 bits after each operation.

For my application the expected size of the set is very small and almost anything would do, but I&#39;m surprised not to see a standard recipe for the general case. Does anyone have any experience or strong experience with this?

What&#39;s a good recipe for overriding hashcode in Dart?

If the hashCode() method is not overridden, what will be the result of invoking hashCode() on any object in Java?

What is an object&#39;s hash code if hashCode() is not overridden?

I noticed in the Java 6 source code for String that hashCode only caches values other than 0. The difference in performance is exhibited by the following snippet:

    public class Main{
       static void test(String s) {
          long start = System.currentTimeMillis();
          for (int i = 0; i &lt; 10000000; i++) {
             s.hashCode();
          }
          System.out.format(&quot;Took %d ms.%n&quot;, System.currentTimeMillis() - start);
       }
       public static void main(String[] args) {
          String z = &quot;Allocator redistricts; strict allocator redistricts strictly.&quot;;
          test(z);
          test(z.toUpperCase());
       }
    }

&lt;a href=&quot;https://web.archive.org/web/20000000000000/http://www.ideone.com/Ho9lfOKy&quot;&gt;Running this in ideone.com&lt;/a&gt; gives the following output:

    Took 1470 ms.
    Took 58 ms.

So my questions are:

 * Why doesn&#39;t String&#39;s hashCode() cache 0?
 * What is the probability that a Java string hashes to 0?
 * What&#39;s the best way to avoid the performance penalty of recomputing the hash value every time for strings that hash to 0?
 * Is this the best-practice way of caching values? (i.e. cache all except one?)

----

For your amusement, each line here is a string that hash to 0:

    pollinating sandboxes
    amusement &amp; hemophilias
    schoolworks = perversive
    electrolysissweeteners.net
    constitutionalunstableness.net
    grinnerslaphappier.org
    BLEACHINGFEMININELY.NET
    WWW.BUMRACEGOERS.ORG
    WWW.RACCOONPRUDENTIALS.NET
    Microcomputers: the unredeemed lollipop...
    Incentively, my dear, I don&#39;t tessellate a derangement.
    A person who never yodelled an apology, never preened vocalizing transsexuals.

Why doesn&#39;t String&#39;s hashCode() cache 0?

How do you pass in null values into a HashMap?  
The following code snippet works with options filled in:  

    HashMap&lt;String, String&gt; options = new HashMap&lt;String, String&gt;();  
    options.put(&quot;name&quot;, &quot;value&quot;);
    Person person = sample.searchPerson(options);  
    System.out.println(Person.getResult().get(o).get(Id));    

So the issue is what has to be entered into the options and or method to pass in a null value?  
I tried the following code without any success:    

    options.put(null, null);  
    Person person = sample.searchPerson(null);    

    options.put(&quot; &quot;, &quot; &quot;);  
    Person person = sample.searchPerson(null);    

    options.put(&quot;name&quot;, &quot; &quot;);  
    Person person = sample.searchPerson(null);  

    options.put();  
    Person person = sample.searchPerson();    

HashMaps and Null values?

Typically the default implementation of **`Object.hashCode()`** is some function of the allocated address of the object in memory (though this is not mandated by the *JLS*). Given that the VM shunts objects about in memory, why does the value returned by **`System.identityHashCode()`** never change during the object&#39;s lifetime?

If it is a &quot;one-shot&quot; calculation (the object&#39;s `hashCode` is calculated once and stashed in the object header or something), then does that mean it is possible for two objects to have the same `identityHashCode` (if they happen to be first allocated at the same address in memory)?


How does the JVM ensure that System.identityHashCode() will never change?

Since Java 7, we have

    o.hashCode();
	Objects.hashCode(o);
    Objects.hash(o);

The first two are roughly the same with the null check, but what is last one?

&gt; When a single object reference is supplied, the returned value does
&gt; not equal the hash code of that object reference.

Why is that? I mean, we don&#39;t need three methods that do the same thing, I understand that, but why do we need `Objects.hash()` at all? When would you chose to use one over another?

Objects.hash() vs Objects.hashCode(), clarification needed

Is it bad practice to use mutable objects as Hashmap keys?  What happens when you try to retrieve a value from a Hashmap using a key that has been modified enough to change its hashcode?

For example, given

    class Key
    {
        int a; //mutable field
        int b; //mutable field
    
        public int hashcode()
            return foo(a, b);
        // setters setA and setB omitted for brevity
    }

with code

    HashMap&lt;Key, Value&gt; map = new HashMap&lt;Key, Value&gt;();

    Key key1 = new Key(0, 0);
    map.put(key1, value1); // value1 is an instance of Value

    key1.setA(5);
    key1.setB(10);

What happens if we now call `map.get(key1)`?  Is this safe or advisable?  Or is the behavior dependent on the language?

Are mutable hashmap keys a dangerous practice?

I understand that the String class&#39; [hashCode()][1] method is *not* guarantied to generate unique hash codes for distinct String-s.  I see a lot of usage of putting String keys into HashMap-s (using the default String hashCode() method).  A lot of this usage could result in significant application issues if a map `put` displaced a HashMap entry that was previously put onto the map with a truely distinct String key.  

What are the odds that you will run into the scenario where String.hashCode() returns the same value for distinct String-s?  How do developers work around this issue when the key is a String?


  [1]: http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html#hashCode()

Bad idea to use String key in HashMap?

Is there a specific rule on how Overriding `equals()` &amp; `hashCode()` in **sub classes** considering **super fields** ?? knowing that there is many parameters : super fields are private/public , with/without getter ...

For instance, Netbeans generated equals() &amp; hashCode() will not consider the super fields ... and

        new HomoSapiens(&quot;M&quot;, &quot;80&quot;, &quot;1.80&quot;, &quot;Cammeron&quot;, &quot;VeryHot&quot;).equals(
        new HomoSapiens(&quot;F&quot;, &quot;50&quot;, &quot;1.50&quot;, &quot;Cammeron&quot;, &quot;VeryHot&quot;))

will return true :(

    public class Hominidae {
        
        public String  gender;
        public String  weight;
        public String  height;
    
        public Hominidae(String gender, String weight, String height) {
            this.gender = gender;
            this.weight = weight;
            this.height = height;
        }
        ... 
    }
    
    public class HomoSapiens extends Hominidae {
        public String name;
        public String faceBookNickname;
    
        public HomoSapiens(String gender, String weight, String height, 
                           String name, String facebookId) {
            super(gender, weight, height);
            this.name = name;
            this.faceBookNickname = facebookId;
        }
        ...  
    }

If you want to see the Netbeans generated equals() &amp; hashCode() :

    public class Hominidae {
        
        ...
        
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Hominidae other = (Hominidae) obj;
            if ((this.gender == null) ? (other.gender != null) : !this.gender.equals(other.gender)) {
                return false;
            }
            if ((this.weight == null) ? (other.weight != null) : !this.weight.equals(other.weight)) {
                return false;
            }
            if ((this.height == null) ? (other.height != null) : !this.height.equals(other.height)) {
                return false;
            }
            return true;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 37 * hash + (this.gender != null ? this.gender.hashCode() : 0);
            hash = 37 * hash + (this.weight != null ? this.weight.hashCode() : 0);
            hash = 37 * hash + (this.height != null ? this.height.hashCode() : 0);
            return hash;
        }

    }


    public class HomoSapiens extends Hominidae {
        
        ...
        
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final HomoSapiens other = (HomoSapiens) obj;
            if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
                return false;
            }
            if ((this.faceBookNickname == null) ? (other.faceBookNickname != null) : !this.faceBookNickname.equals(other.faceBookNickname)) {
                return false;
            }
            return true;
        }

        @Override
        public int hashCode() {
            int hash = 7;
            hash = 89 * hash + (this.name != null ? this.name.hashCode() : 0);
            hash = 89 * hash + (this.faceBookNickname != null ? this.faceBookNickname.hashCode() : 0);
            return hash;
        }
    }

Overriding equals() &amp; hashCode() in sub classes ... considering super fields

In .NET, the [`GetHashCode` method](https://docs.microsoft.com/en-us/dotnet/api/system.object.gethashcode) is used in a lot of places throughout the .NET base class libraries. Implementing it properly is especially important to find items quickly in a collection or when determining equality.

Is there a standard algorithm or best practice on how to implement `GetHashCode` for my custom classes so I don&#39;t degrade performance?

What is the best algorithm for overriding GetHashCode?

Given the following class

    public class Foo
    {
        public int FooId { get; set; }
        public string FooName { get; set; }
    
        public override bool Equals(object obj)
        {
            Foo fooItem = obj as Foo;

            if (fooItem == null) 
            {
               return false;
            }
    
            return fooItem.FooId == this.FooId;
        }
    
        public override int GetHashCode()
        {
            // Which is preferred?
    
            return base.GetHashCode();
    
            //return this.FooId.GetHashCode();
        }
    }

I have overridden the `Equals` method because `Foo` represent a row for the `Foo`s table.  Which is the preferred method for overriding the `GetHashCode`?

Why is it important to override `GetHashCode`?


Why is it important to override GetHashCode when Equals method is overridden?

Eclipse 3.5 has a very nice feature to generate Java hashCode() functions. It would generate for example (slightly shortened:)

    class HashTest {
        int i;
        int j;        
        public int hashCode() {
            final int prime = 31;
            int result = prime + i;
            result = prime * result + j;
            return result;
        }
    }

(If you have more attributes in the class, `result = prime * result + attribute.hashCode();` is repeated for each additional attribute. For ints .hashCode() can be omitted.)

This seems fine but for the choice 31 for the prime. It is probably taken from the [hashCode implementation of Java String][1], which was used for performance reasons that are long gone after the introduction of hardware multipliers. Here you have many hashcode collisions for small values of i and j: for example (0,0) and (-1,31) have the same value. I think that is a Bad Thing(TM), since small values occur often. For String.hashCode you&#39;ll also find many short strings with the same hashcode, for instance &quot;Ca&quot; and &quot;DB&quot;. If you take a large prime, this problem disappears if you choose the prime right.

So my question: what is a good prime to choose? What criteria do you apply to find it? 

This is meant as a general question - so I do not want to give a range for i and j. But I suppose in most applications relatively small values occur more often than large values. (If you have large values the choice of the prime is probably unimportant.) It might not make much of a difference, but a better choice is an easy and obvious way to improve this - so why not do it? Commons lang [HashCodeBuilder][2] also suggests curiously small values.

(**Clarification**: this is *not* a duplicate of [Why does Java&#39;s hashCode() in String use 31 as a multiplier?][1] since my question is not concerned with the history of the 31 in the JDK, but on what would be a better value in new code using the same basic template. None of the answers there try to answer that.)

  [1]: https://stackoverflow.com/questions/299304/why-does-javas-hashcode-in-string-use-31-as-a-multiplier
  [2]: http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/builder/HashCodeBuilder.html

What is a sensible prime for hashcode calculation?

I want to check if entity is in a Collection member (`@OneToMany` or `@ManyToMany`) of another entity:

    if (entity2.getEntities1().contains(entity1)) { }



Should I write equals() and hashCode() methods in JPA entities?

If one does not override the `hashCode` method, what is the default implementation of `hashCode` ?

What is the default implementation of `hashCode`?

What value does the `hashCode()` method return in java?

I read that it is a memory reference of an object... The hash value for `new Integer(1)` is 1; the hash value for `String(&quot;a&quot;)` is 97. 

I am confused: is it ASCII or what type of value is?

How is hashCode() calculated in Java

I have a class that contains the following two properties:

    public int Id      { get; private set; }
    public T[] Values  { get; private set; }

I have made it `IEquatable&lt;T&gt;` and overriden the `object.Equals` like this:

    public override bool Equals(object obj)
    {
        return Equals(obj as SimpleTableRow&lt;T&gt;);
    }
    
    public bool Equals(SimpleTableRow&lt;T&gt; other)
    {
        // Check for null
        if(ReferenceEquals(other, null))
            return false;

        // Check for same reference
        if(ReferenceEquals(this, other))
            return true;

        // Check for same Id and same Values
        return Id == other.Id &amp;&amp; Values.SequenceEqual(other.Values);
    }

When having override `object.Equals` I must also override `GetHashCode` of course. But what code should I implement? How do I create a hashcode out of a generic array? And how do I combine it with the `Id` integer?

    public override int GetHashCode()
    {
        return // What?
    }

GetHashCode override of object containing generic array

I have an array of objects and I want to concatenate it with another array of objects, except that objects that have same id&#39;s. That objects are used in many places in the system and don&#39;t have hash code or equals implemented. So I don&#39;t want to implement `hashCode()` and `equals()`, cause I&#39;m afraid to break something somewhere in the system where that objects are used and I don&#39;t know about that. 

I want to put all that objects in a set, but somehow make the objects use custom `hashCode()` and `equals()`. Something like custom `Comparator`, but for equals.

Is it possible in java make something like Comparator but for implementing custom equals() and hashCode()

So, I have an interface with a bunch of methods that need to be implemented, the method names are irrelevant.

The objects that implement this interface are often put into collections, and also have a special toString() format that I want them to use.

So, I thought it would be convenient to put hashCode(), equals(), and toString() into the interface, to make sure that I remember to override the default method for these. But when I added these methods to the interface, the IDE/Compiler doesn&#39;t complain if I don&#39;t have those three methods implemented, even though I explicitly put them in the interface.

Why won&#39;t this get enforced for me? It complains if I don&#39;t implement any of the other methods, but it doesn&#39;t enforce those three. What gives? Any clues?

toString(), equals(), and hashCode() in an interface

I was wondering how Java orders items in the `Map` (`HashMap` or `Hashtable`) when they are added. Are the keys ordered by the hashcode, memory reference or by allocation precedence...?

It&#39;s because I&#39;ve noticed same pairs in the `Map` are not always in the same order

How does Java order items in a HashMap or a HashTable?

I&#39;ve read that Scala&#39;a `case class` construct automatically generates a fitting `equals` and `hashCode` implementation. What does exactly the generated code look like?

All Hashcode Solutions on Gang of Coders

Total of 50 Hashcode Solutions