why is hashCode() for String object different from hashCode() of a custom class' object?

Why is the hashcode of stringObject is the string I provided? ex. String s = new String("hello"); // here the hascode is hello.

That is Not true

hashCode() is an int number

You seems confusing hashcode() with toString()

if you want to check the hashcode()

String str = "hello";
System.out.println(str.hashcode());//will print some int number
System.out.println(str);//will invoke toString() which will return `hello`

I think you're confusing hashCode() with toString().

The default toString() implementation of every object is indeed <classname>@<some number> and the number happens to be the hash code of the object in hex, but that can (and should) be overridden by classes that can provide a more meaningful string representation. And for a string, the obvious string representation is itself.

String s = new String("hello"); hash code of this will never be Hello, because hashCode() methods return type is int not a string

String is a class provided in the Java library. Thus, the hashCode() method has been overridden by creator of this class to reflect it. Please not that the hashcode is an int value.

When you create a class, you want to override both hashCode() and equals() method, in order to be able to compare your objects, and do other cool stuff (putting them in a HashMap, for example).

You need to be careful on how you would implement hashCode() as you want to respect the general contract, that states that if 2 objects are equal according to equals() method, they have the same hashCode(), while the opposite doesn't have to be necessarily true (but it's recommended).

You can find a more deep explaination here - http://www.javaworld.com/community/node/1006

The method hashCode() always returns an integer which is the hash value of an object. An nativ implementation is available in class Object. If you want to create your own hash of a type, you have to overwrite hashCode().

toString() will return the string representation of an object and hashCode() (as descripted above) the hash value of an object.

The class String overwrites hashCode(). This is how it's done by String:

public int hashCode() {
    int h = hash;
    int len = count;
    if (h == 0 && len > 0) {
        int off = offset;
        char val[] = value;

        for (int i = 0; i < len; i++) {
            h = 31*h + val[off++];
        }
        hash = h;
    }
    return h;
}

There are some issues here:

1. as other has already said - hashCode() returns an integer, and you might be confusing with toString()
2. Which is more important IMO: Object has both hashCode() and toString() methods. However, any subclass of Object can override this method. When the method will be called - the dynamic type's method will be invoked, so for String, String.hashCode() will be invoked and not Object.hashCode() [same idea for toString()]. This is called dynamic dispatch.

for example:

public static class A { 
    public void foo() {
        System.out.println("A");
    }
}
public static class B extends A{ 
    @Override
    public void foo() {
        System.out.println("B");
    }
}
public static void main(String[] args) throws Exception  {
    A a = new B();
    a.foo();
}

In the above code snap, B.foo() will be invoked, and B will be printed, since B overrides foo(), and the dynamic type of a is B, so B.foo() is invoked.

In your case: Since String overrides hashCode(), then String.hashCode() is invoked, while for testClass - it doesn't override hashCode(), so the original Object.hashCode() is invoked.

I think you are getting confused due to hashcode of empty string which is 0. Hashcode is always an integer which is computed by hashcode function available for that class. Now, hashcode of any custom class is provided by the Object class(default parent) hashcode method which returns the memory address of that object in int form.(if not overridden by custom class)

Now you can think of String as a custom class but created by some other user who override this hashcode function for strings in String class which now computes it like: S[0]*31^(n-1)+S[1]*31^(n-2)+...+s[n] , 0 for empty string. All the calculations included for evaluating above expression are integer calculation of java. You can refer to https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#hashCode()

The String class of java overrides hascode function so that when you call hashcode on two different String objects with same string in them will result into same hashcode; which is usually important while useing hashing techniques in hashed data-structures like hashmaps. So this overridden function provides same hashcode for both String s1=new String("hello") and String s2=new String("hello") ; whereas in memory they have been stored as different Strings. Now if you want your custom class to have same hashcode on basis of some property of that class you can override the hashcode in your class as String does on tha basis of actual string stored in it.

So in your case 1; you get 0 and in cade 2 you get some memory location in int form as explained above.