What is hashcode in java?

Answer 1

hashcode is an integer number which is provide to each object by jvm note that this is not address of object but for convencing internally they use

Java uses the hash function given below:- s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] where s[i] is the ith character of the string, n is the length of the string, and ^ indicates exponentiation.

Answer 2

HashMap

The HashMap gives you an unsorted, unordered Map. When you need a Map and you don't care about the order (when you iterate through it), then HashMap is the way to go; the other maps add a little more overhead. Where the keys land in the Map is based on the key's hashcode, so, like HashSet, the more efficient your hashCode() implementation, the better access performance you'll get. HashMap allows one null key and multiple null values in a collection.

Answer 3

Hashcode indentifies the location of a object in a hashtable, equals is a method that allows to compare two objects instead of comparing just the adress at memory, with the == operator. You also can customize both.

Answer 4

Hashcodes are typically used to increase the performance of large collections of data. The hashCode value of an object is used by some collection classes (Don't worry about Collections, its gonna be the very next chapter). Although you can think of it as kind of an object ID number, it isn't necessarily unique. Collections such as HashMap and HashSet use the hashCode value of an object to determine how the object should be stored in the collection, and the hashCode is used again to help locate the object in the collection. For the exam you do not need to understand the deep details of how the collection classes that use hashing are implemented, but you do need to know which collections use them. You must also be able to recognize an appropriate or correct implementation of hashCode(). This does not mean legal and does not even mean efficient. It's perfectly legal to have a terribly inefficient hashCode method in your class, as long as it doesn't violate the contract specified in the Object class documentation. So for the exam, if you're asked to pick out an appropriate or correct use of hashCode, don't mistake appropriate for legal or efficient.

Understanding Hashcodes

In order to understand what's appropriate and correct, we have to look at how some of the collections use hashcodes.

Imagine a set of buckets lined up on the floor. Someone hands you a piece of paper with a name on it. You take the name and calculate an integer code from it by using A is 1, B is 2, and so on, and adding the numeric values of all the letters in the name together. A given name will always result in the same code.

Let's look at an example:

KeyHash Code AlgorithmHash CodeRockyR(18) + o(15) + c(3) + k(11) + y(25)72AnandA(1) + n(14) + a(1) + n(14) + d(4)34

The above is a simple algorithm that just sums up the numeric position of the alphabets in the name and arrives at a number that being 72 for Rocky and 34 for Anand. So in the hashCode bucket, the value 34 will be saved as the key for Anand and similarly 72 will be the value for Rocky.

Now imagine that someone comes up and shows you a name and says, "Please retrieve the piece of paper that matches this name." So you look at the name they show you, and run the same hashCode-generating algorithm. The hashCode tells you in which bucket you should look to find the name.

You might have noticed a little flaw in our system, though. Two different names might result in the same value. For example, the names Amy and May have the same letters, so the hashCode will be identical for both names. That's acceptable, but it does mean that when someone asks you (the bucket-clerk) for the Amy piece of paper, you'll still have to search through the target bucket reading each name until we find Amy rather than May. The hashCode tells you only which bucket to go into, but not how to locate the name once we're in that bucket.

So for efficiency, your goal is to have the papers distributed as evenly as possible across all buckets. Ideally, you might have just one name per bucket so that when someone asked for a paper you could simply calculate the hashCode and just grab the one paper from the correct bucket (without having to go flipping through different papers in that bucket until you locate the exact one you're looking for). The least efficient (but still functional) hashCode generator would return the same hashCode (say, 42) regardless of the name, so that all the papers landed in the same bucket while the others stood empty. The bucket-clerk would have to keep going to that one bucket and flipping painfully through each one of the names in the bucket until the right one was found. And if that's how it works, they might as well not use the hashcodes at all but just go to the one big bucket and start from one end and look through each paper until they find the one they want.

This distributed-across-the-buckets example is similar to the way hashcodes are used in collections. When you put an object in a collection that uses hashcodes, the collection uses the hashCode of the object to decide in which bucket the object should land. Then when you want to fetch that object, you have to give the collection a reference to an object that the collection compares to the objects it holds in the collection. As long as the object you're trying to search for has the same hashCode as the object you're using for the search (the name you show to the person working the buckets), then the object will be found. But...and this is a Big But, imagine what would happen if, going back to our name example, you showed the bucket-worker a name and they calculated the code based on only half the letters in the name instead of all of them. They'd never find the name in the bucket because they wouldn't be looking in the correct bucket!

Answer 5

The hashCode() and equals() are Java methods found in Object so all objects inherit these methods. A rule of thumb states that when one of these 2 methods is overridden the other should also be overridden. The default hashCode() method returns an int representation of the object's location in memory. The default equals() method compares memory locations (this == obj).

Both methods come into play when working with hash-related containers (e.g., HashSet, HashMap). These objects use a collection of buckets into which key/value entries are stored. When storing the key/value entry the hash code of the key is used to determine into which bucket the entry will be stored. When retrieving an entry the key's hash code is used to find the correct bucket.

It is possible that hash code of different keys calculate to the same value. When this happens we call it a "collision". A bucket is a collection so more than one entry can be added to a given bucket. When you try to add a key/value entry and there is a collision the entry is appended to the bucket. When retrieving an entry, the key is used to find the bucket but then it searches all entries in the bucket by comparing the keys of each entry using equals().

Note that both the key and value are stored in the bucket as an Map.Entry object so that the keys can be compared in the event of a collision.