HashCode

Hi all,
I studied some docs reagarding hashCode() and have some questions.
From: java.lang.Object: hashCode():
1) "Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals 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." Why?
2) From: Java Glossory: http://www.mindprod.com/jgloss/hashcode.html
Object.hashCode Implementation: The default hashCode() method uses the 32-bit internal JVM address of the Object as its hashCode. However, if the Object is moved in memory during garbage collection, the hashCode stays constant. This default hashCode is not very useful, since to look up an Object in a HashMap, you need the exact same key Object by which the key/value pair was originally filed. Normally, when you go to look up, you don't have the original key Object itself (Why?)
just some data for a key. So, unless your key is a String, nearly always you will need to implement a hashCode and equals method on your key class.
3) From the same text:
"As a rule of thumb, any time you use an Object as a key in a Map or Set (e.g. Hashtable, HashMap, HashSet, TreeMap etc.) you must redefine both equals and hashCode in such a way both incorporate all the fields of the logical key. Fields in the key Object irrelevant to lookup should not be included in either method."
Why do I need to implement the hashCode() method anyway? Why the 32-bit internal JVM address of the Object which is returned from hashCode() method wouldn't be enough to give me the key I need?
4) From Java theory and practice: Hashing it out: http://www-128.ibm.com/developerworks/java/library/j-jtp05273.html
"Why override equals() and hashCode()?
What would happen if Integer did not override equals() and hashCode()? Nothing, if we never used an Integer as a key in a HashMap or other hash-based collection. However, if we were to use such an Integer object for a key in a HashMap, we would not be able to reliably retrieve the associated value, unless we used the exact same Integer instance in the get() call as we did in the put() call. This would require ensuring that we only use a single instance of the Integer object corresponding to a particular integer value throughout our program. Needless to say, this approach would be inconvenient and error prone."
Why its error prone? Why can't we say that we are using the same instance of the Integer object?
5) Why do I need to override hashCode() for HashSet? We don't have the concept of key in HashSet?
6) Its also said that no matter what algorithm is used for calculating hashCode, its possible that two non-equal objects have the same hashCode, so if we are using those objects as keys in HashTable, how can we avoid having the same hashCode or the same key for two different values? On the other word, how can we avoid collisions, (if there is anyway) ?
I stopped going through more documents at this point, since it seems more questions will arise! If I know the answer to the above questions it will help to understand the rest of document. Any help is greatly appreciated.

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." Why? Because there's no reason to do so. HashCode isn't intended as a persistent identifier for an object. It's simply intended as a fingerprint of the object's current state.
key/value pair was originally filed. Normally,
when you go to look up, you don't have the original
key Object itself (Why?) I do map.put(joe.name, joe) later, when somebody asks for the object named "joe"--using the String "joe"--I use that to do person = map.get(requestedName); . When the string "joe" comes in, that lookup is how I find the associated object.
hy do I need to implement the hashCode() method
anyway? Why the 32-bit internal JVM address of the
Object which is returned from hashCode() method
wouldn't be enough to give me the key I need? Hashcode cannot use any data that equals does not use. The default hashCode uses (in general, and roughly) the object's address.
The way a hashMap works is you use the object's hashCode to get to the right bucket--the small subset of all the entries that might potentially match--and then do a linear search on the bucket using equals.
If I say map.get("joe"), the get method first computes the hashCode of the "joe" String object. Every time I provide "joe", I have to get the same hashCode, in order to get the right bucket--the right subset--to search. If String didn't override hashCode, then two different "joe"String objects would have two different hashCodes, and I'd never be able to zoom in on the bucket containing the "joe" entry.
Likewise, any object that you want to use as a key in a HashMap, or store in a HashSet, must override hashCode so that the hashCode can be used to find the correct subset that might contain an entry for which equals() is true.
http://en.wikipedia.org/wiki/Hashing
Why its error prone? Why can't we say that we are
using the same instance of the Integer object? I don't have the time to explain this any more. Read the wiki link above, or an introductory text on data structures.

Similar Messages

Hashcode switch problem

Hello. Can anyone tell me why this isn't working? I'm trying to use a switch off of a String, so I take the hashcode of it and compare it to the possible input strings. It looks like it should work, it's just comparing intergers, but my compiler always gives me an error "constant expression required". Why is this happenning?
Here is my code:
final int string1 = "hello".hashCode() ;
final int string2 = "goodbye".hashCode() ;
String input ;
switch( input.hashCode() )
case string1 :
// stuff
case string2 :
// stuff
}The compiler always hits the error on the 'case string1:' line. How can it say "i need a constant value" when the value it's using is a final? Isn't that constant enough?

final int string1 = "hello".hashCode() ;
final int string2 = "goodbye".hashCode() ;is resolved at run-time.
switch( input.hashCode() )
case string1 :
case string2 :is resolved at compile-time.
so you have to use if..else..endif; however I don't see why you would need hashCode() to compare strings.
Maybe for performance ??? Then you should make sure that using hashCode() is really faster. otherwise you end up with VERY strange code.

Two objects created at the same time with the same hashcode

We have this object with the following constructor:
2010-06-24 00:10:31,260 [LoadBalancerClientSubscriber(3)(pid:24312)] INFO com.intel.swiss.sws.netstar.application.caching.framework.data
set.synchronizer.DatasetSynchronizer - Initializing dataset synchronizer for: [/nfs/iil/iec/sws/work/damar/ds_cama/tmp/ds_126631277304794
/d81], i am com.intel.swiss.sws.netstar.application.caching.framework.dataset.synchronizer.DatasetSynchronizer@2ed3cae0
2010-06-24 00:10:31,260 [LoadBalancerClientSubscriber(5)(pid:24315)] INFO com.intel.swiss.sws.netstar.application.caching.framework.data
set.synchronizer.DatasetSynchronizer - Initializing dataset synchronizer for: [/nfs/iil/iec/sws/work/damar/ds_cama/tmp/ds_126631277304794
/d31], i am com.intel.swiss.sws.netstar.application.caching.framework.dataset.synchronizer.DatasetSynchronizer@2ed3cae0Note that two objects are created by different threads with exactly the same hash code. Any idea if/how this is possible?

isocdev_mb wrote:
The last part definitely suggests already that relying on uniqueness is incorrect. Hash codes are very often equal on distinct objects, viz. new String("java").hashCode == new String("java").hashCode(). Use a class level counter as suggested earlier.For that case we would of course expect the hashCodes to be equal, since the objects are equal. But even in the case of non-equal objects that don't override hashCode, you can still get the same value. Or, for that matter, non-equal objects that do override it. There are 2^32 possible hashCode values. There are 2^64 possible Long values. That means that there are 2^32 Longs that have a hashCode of 1, 2^32 Longs that have a hashCode of 2, etc.
And for non-equal objects...
package scratch;
import java.util.Set;
import java.util.Map;
import java.util.HashMap;
public class HashCodeIsNotUnique {
public static void main(String[] args) throws Exception {
    Map<Integer, Integer> hashCodeCounts = new HashMap<Integer, Integer>();
    int numObjects = 10000;
    for (int i = 0; i < numObjects; i++) {
      Object obj = new Object();
      int hashCode = obj.hashCode();
      if (!hashCodeCounts.containsKey(hashCode)) {
        hashCodeCounts.put(hashCode, 0);
      hashCodeCounts.put(hashCode, hashCodeCounts.get(hashCode) + 1);
    for (Map.Entry<Integer, Integer> entry : hashCodeCounts.entrySet()) {
      int key = entry.getKey();
      int value = entry.getValue();
      if (value > 1) {
        System.out.println(key + " occurred " + value + " times");
9578500 occurred 2 times
14850080 occurred 2 times

Getting Hashcode of a file in an Adapter Module

Hi all
Does anybody know to dynamically get the hashcode of a file in an Adapter Module.

Hi Michal
contentToString()
          String serialization for logging purposes.
getPrincipalData()
          Retrieves the current principle data, usually the message
getSupplementalData(String name)
          Gets one supplement data value.
getSupplementalDataNames()
          Returns the names of all currently existing supplement data.
setPrincipalData(Object principalData)
          Sets the principle data that represents usually the message to be processed.
setSupplementalData(String name, Object supplementalData)
          Sets a supplement data for the rest of the module chain
this all methods I can see. Can u please elaborate a bit

Get value from the array based on the HashCode

public static void runJoin(int[][] t1,int[][] t2)
     PrintWriter out=null;
     int rows = 1000;
     int cols = 7;
     int [][] myTable3 = new int[rows][cols];
     int x = 0;
     System.out.print("Running HashJoin:Method loads the "+
     "smaller table in the memory and applies a hashing function "+
     "to common column and stores it in another table. "+
     "The larger table is then read from the file. "+
     "The same hashing function is applied to Col n of the table and a       matching record in the first table is looked up. A match will create a row in Table 3. ");
//Apply hashing function to smaller table and store it in the memory.
          Integer[] It2 = new Integer[t2.length];
          int [] hashCodest2 = new int[t2.length];
          Hashtable ht = new Hashtable();
          for(int i =0; i <t2.length;i++){
               It2[i] = new Integer(t2[0]);
               hashCodest2[i] = It2[i].hashCode();
               ht.put(new Integer(hashCodest2[i]),It2[i]);
          //Larger table get hashcodes
          Integer It1[] = new Integer[t2.length];
          int [] hashCodest1 = new int[t2.length];
          for(int j =0; j <t1.length;j++){
               It1[j] = new Integer(t1[j][4]);
               hashCodest1[j] = It1[j].hashCode();               }
          //Based on the hashcode get the value from the Table2;
          try{
out = new PrintWriter( new FileOutputStream( "c:\\HashJoinTable.txt" ) );
          Enumeration e = ht.keys();
               while(e.hasMoreElements())
//How do I get the value from the array based on the HashCode? Do I need to do a loop here???
hashCodes1.get(e.nextElement());
          }catch(Exception e){}

ok I got it......
          //Apply hashing function to smaller table and store it in the memory.
          Integer[] It2 = new Integer[t2.length];
          int [] hashCodest2 = new int[t2.length];
          Hashtable ht = new Hashtable();
          for(int i =0; i <t2.length;i++){
               It2[i] = new Integer(t2[0]);
               hashCodest2[i] = It2[i].hashCode();
               ht.put(new Integer(hashCodest2[i]),It2[i]);
          //Larger table get hashcodes and compare
          Integer It1[] = new Integer[t2.length];
          int [] hashCodest1 = new int[t2.length];
          Hashtable ht2 = new Hashtable();
          for(int j =0; j <t1.length;j++){
               It1[j] = new Integer(t1[j][4]);
               hashCodest1[j] = It1[j].hashCode();
               ht2.put(new Integer(hashCodest1[j]),It1[j]);
          //Based on the hashcode get the value from the Table2;
          try{
out = new PrintWriter( new FileOutputStream( "c:\\HashJoinTable.txt" ) );
          Enumeration e = ht.keys();
          Integer t3[] = new Integer[t2.length];
               while(e.hasMoreElements())
                    t3[x] = (Integer) ht2.get(e.nextElement());
                    x++;
          }catch(Exception e){}

Trying to understand hashCode( )

Hello again, I'm trying to understand the hashCode( ) method. I have a textbook which describes it this way:
"A hashcode is a value that uniquely identifies an individual object. For example, you could use the memory address of an object as it's hashcode if you wanted. It's used as a key in the standard java.util.Hashtable[i] class."
Please forgive me if this emplies that I may be a bit slow with this, but this explanation is too vague for me to grasph what's going on here. Can someone thoroughly explain (in a non scientific way), how and why this method is used?
Thanks in advance.

I thought the examples I provided might give you an idea why the hashCode method is useful. I'll try one more brief one, and if that doesn't connect that spare wire to the light bulb over your head, then I'll have to agree with schapel and suggest that you study up on your CS theory.
This will be a really crocked up example, and you could skirt some of the issues with better design, but it's a valid example nonetheless.
You run a greenhouse or an arboretum or something. You've got 25,000 Tree objects (forget their subclasses for now). Trees have properties like species, name (I don't know why you'd name a tree--just bear with me), location, age, medical history. You're going to put your Trees into a java.util.Set, so you've got a collection with one reference to each tree. However, you're getting overlapping subsets of your trees from various sources--that is getAllElms() returns some trees that are also in getAllOlderThan(10). You need to combine all those results into a 1-each collection of Trees.
When you go to add an Object to the Set, the Set has to first check if that Object is already present. The Set implementation could iterate over all its elements and call equals() to see if that Object is already there. Or, it could first get the hashCode (let's say you've implemented hashCode to return the xor of the species and the age). So, maybe 100 out of your 25,000 trees are 50 yeard old Elms. Internally, if the Set implementation keeps a mapping from hashCode to an array of Trees with that hashcode, then it only has to copmare to those 100 trees that match, rather than all 25,000.
As I said, this is a cheezy example. One problem is that if trees are mutable, this Set implementation won't work, since the Set won't know that a Tree's internal values (and hence, possibly, its hashCode) have changed.
Is is making any sense yet?
Okay so please help me understand this rudimentary,
logical reason for wanting to use a hashCode( )? Say
I create a top level class called "Plant.java". Now
from that class I create a subclass called Tree.java
from which several other subclasses and objects are
created. Help me gain a basic understanding of why
and how the hashCode( ) method might be beneficial.
(lol... I feel sort of like I've opened up a cool new
electronic toy, I'm standing here with a "spare wire
in my hand wondering what the heck this part is
for?")
Thanks again for your help. I really apprecitate it.

Can I call hashCode() into equals()

Hi,
I implemented a class MyObject that overrides the method hashCode() that respect the general contract and the resulting hashcode value is stored in a data member of my class MyObject.
I also overrided the equals() that looks like this:
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj == this) return true;
if (other instanceof MyObject == false) {
return false;
.... complex tests to check the equality that take a long time....
To optimize the equals() I would like to do:
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj == this) return true;
if (other instanceof MyObject == false) {
return false;
// use the hashCode, if different, no need to make the complex checks
if (hasCodeValue_ != obj.hashCode()) {
return false;
.... complex tests to check the equality
I think it should work because the hashCode is different when the objects are different, but I can't find any example of equals() implementation that uses the hascode(), is there any reason for that ? Thanks for your help, BR,
Sebastien.

Would you clarify for me please?
Do you mean that the hashCode method will naturally be
faster because something like String.hashCode() will
return faster than String.equals(otherString) ?Equals methods usually require a few checks before they really start comparing things. They check to see if the objects are the same, they check to see of the object passed in was null, they check the type of the argument and then they cast it. Then they start comparing members and if any of their members are Objects there's more of that.
Hashcode methods just go right at the values. And like you said, they can be cached in a lot of cases like String.
Or do you mean that one should take care to write
hashCode methods that are very fast?
If the latter, I'd like to hear about how you make
sure of that.Well, you could eliminate fields from the calculation but that might produce bad results. Generally, you just don't do a lot of complicated operations.

Please help me in understanding hashcode()

I have some doubt with hashcode(), please help me in understanding.
As it is always advised that whenever you override equals() method, override even hashcode(). As equals() returns the equality of two objects i.e it returns whether two objects are equal or not. The hashcode(), returns int value, i.e if two objects are equal than both hashcode will be same.
Now my question is:
1. When equals() method is comparing 2 objects and returning whethere both are equal or not. Then why we need this hashcode().
2. When this hashcode(), is going to be call?
Please tell me Whatever I understood is right or not....

rajalakshmi wrote:
2. When this hashcode(), is going to be call?
equals() method will implicitly call hashCode() method to compare objects.No it won't. Where did you get that?
Here is the actual code to Strings equals method
    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;
    }Now, where is hashCode called there?

Quick hashCode question

Hi,
ive read a few previous posts about this and am still not 100% on this. From what i understand, hashCode is worked out using the memory address unless an equals() method is implemented in which case it uses this.
Is this right or wrong?
Thanks
Chris

Read the API documentation of java.lang.Object.hashCode(). It states three conditions:
1. the same object must return the same value for hashCode() if it is called multiple times (during the execution of the Java application)
2. if two objects are equal according to the equals() method, a call to hashCode() of both objects must return the same value
3. it is not required that if two objects are unequal, they have different values for hashCode().
Furthermore:
"As much as is reasonably practical, the hashCode method defined by class Object 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 JavaTM programming language.)"
Jesper

Function Modul for generate hashcode

Hi all
i search a function modul for generate a hashcode. Does it existing a function modul for that?
Regards

Hi
Try FKK_BR_BUILD_HASH_CODE.
Pushpraj

Use of hashCode and equals method in java(Object class)

What is the use of hashCode and in which scenario it can be used?similarly use of equals method in a class when it overides form Object class. i.e i have seen many scenario the above said method is overridden into the class.so why and in which scenario it has to override?Please help me.

You could find that out easily with google, that is a standard junior developer interview question.

Float Arrays and hashcodes

Hi,
I have some problems with generating unique hash codes for float arrays.
The following code will result in "true" on my JVM (JRE 1.6):
System.out.println(Arrays.hashCode(new float[]{0,1,2,3,6,9}) == Arrays.hashCode(new float[]{0,1,3,6,8,9}));Does anyone have an idea how to generate a truly unique hashcode for float arrays?
Thanks for your help,
Dieter

JoachimSauer wrote:
dkleinrath wrote:
JoachimSauer wrote:
But again: you don't usually need a perfect hash. Why do you think you need one?I use static HashMaps to store meta information about specific arrays. I also use a HashSet to search for unique arrays in a big collection of arrays.That's ok. Both HashMap and HashSet can work perfectly with in-perfect hash code (obviously, since perfect hash codes are not possible in many situations).
What they can not handle is .equals() being "wrong" (i.e. inconsistent with hashCode()).
This means that you can't directly use float[] as keys.
You could build a simple wrapper around float[] to be used as keys, 'though.I just tried that and it works like a charm.
Thank you very much for your help.

About hashCode()

hello, i just want to ask, if a certain string converted
into a hash code can be retrieve/turn back to it's
original form?
ex. String n = "alice"; ---> int value = n.hashCode();
can "value" return to "n" as (alice)?
can they provide example code in order to help me solve
my problem? thanks in advance..

No.
A tiny bit of logic will tell you this is impossible. There are 2^32 possible hashcode values. There are far more possible strings. Hashcode is not intended to be unique or reversible.

Problem in not overriding equals and Hashcode

I have a very small question. We know that if we do not override the equals and hascode of Object class, we can not use the object in the Hashed collection. Can anybody provide me a concrete example which indicates the problem if we do not override the equals and hascode.

back to the original question from DebadattaMishra
I have a very small question. We know that if we do
not override the equals and hascode of Object class,
we can not use the object in the Hashed collection.
Can anybody provide me a concrete example which
indicates the problem if we do not override the
equals and hascode.lets extend the example from jverd. Suppose we have a Person and want to store some Score in a HashMapclass Person {
    String name;
    Person(String name) {
        this.name = name;
class Score {
    int value;
    Score(int value) {
        this.value = value;
public class PersonTest {
    Map<Person, Score> map = new HashMap<Person, Score>();
    void test() {
        map.put(new Person("John"), new Score(1));
        map.put(new Person("Maria"), new Score(2));
        Score score = searchScore("John");
        System.out.println("Found: " + score); // Found: null
    Score searchScore(String name) {
        return map.get(new Person(name));
}if you run test() you will get "Found: null" since the John instance in the HashMap is not the same as used in searchScore. HashMap uses the equals method from Object since we have not overridden it.
If we add an equals methodclass Person {
    String name;
    Person(String name) {
        this.name = name;
    public boolean equals(Object obj) {
        if(obj instanceof Person) {
            Person p = (Person) obj;
            return name.equals(p.name);
        } else {
            return false;
    // hashcode not overridden
}we probably will get "Found: null" most if the time. The HashMap uses the hashcode() to create an index for saving the keys, so it mostly will not find the Person.((there is still a very small probability that the correct Person is found))
It will work fine if we add a hashcode like    public int hashCode() {
        return name.hashCode();
    }I hope this example helped.

About hashCode() function..

What is the use of hashCode() function.
It is in both String and Hashtable classes...
What is the necessity having same function in both classes..
What actually it returns...
Can we use it with any type objects?

I hope everybody know that java have special
treatment for Strings.
int hash1 = "ABCDEa123abc".hashCode();
int hash2 = "ABCDFB123abc".hashCode();Both the time the string used "ABCDEa123abc" will
have the same reference. You are trying to make a valid point, but you missed the fact that those two strings are not equal, but produce the same hashCode(). This happens, because you are mapping a large value space (Strings) to a much smaller space (int).
It's used to demonstrate that you must not depend on the hashCode beeing unique.
>
Thats why u always get the same hashcode.

Adding Objects To a HashSet, overriding equals and hashCode

Hi everyone,
I'm trying to add objects to a HashSet, using a string identifier (an attribute of these objects) to determine if two objects are equal.
I have a class 'IntExpEvent' class that overrides the equals and hashCode methods.
public class IntExpEvent implements ExperimentalEvent{
public int correctAnswer;
public String identifier;
public IntExpEvent(String id, int correctAnswer){
     this.identifier = id;
     this.correctAnswer=correctAnswer;
public String getID(){
     return(this.identifier);
public boolean equals(ExperimentalEvent e){
     return (this.identifier.equals(e.getID()));
public int hashCode(){
     System.out.println((this.getID()).hashCode());
     return (this.getID()).hashCode();
private int hashCode=-1;
public int hashCode() {
     if(hashCode==-1) {
     char[] ca=getID().toCharArray();
     for(int x=0;x<ca.length;x++) {
          hashCode+=ca[x];
     return(hashCode);
     IntExpEvent e1 = new IntExpEvent("test_IntExpEvent",4);
     IntExpEvent e2 = new IntExpEvent("test_IntExpEvent",6);
     HashSet hs = new HashSet();
     System.out.println(hs.add(e1));
     System.out.println(hs.add(e2));
I can still add both e1 and e2 to the HashSet, which is what I'm trying to stop from happening. i.e. objects with the same identifier should be treated as the same object, allowing only one to be added to the HashSet. Does anyone know how I can do this? Help would be greatly appreciated

In fact you don't override the equals method. The signature defined in the Object class is
boolean equals(Object o)In your case it is
boolean equals(ExperimentalEvent e)So instead of overriding the method you're overloading it.
Regards

HashCode

Similar Messages

Maybe you are looking for