Java – Using HashTable Without Overriding hashCode()

collectionshashingjava

Today I was asked this question during an interview:

What will happen if we do not override the hashcode method for our
class, then add it to HashTable and then try to get objects?

What could go wrong?

Best Answer

The idea with a HashTable when you try retrieving an object is that the data structure computes the hash code of the object using the GetHashCode() method and then goes through a list using the Equals() method.

With default GetHashCode() implementation, two perfectly similar objects might end up yielding different hash codes which means that if you do not use the exact same instance, you will never find the your object in the HashTable.

In general, you want to make sure of two things when implementing hash codes:

If A.Equals(B) then A.GetHashCode()==B.GetHashCode()
Try to get a distribution of hash codes properly spread to get the maximum efficiency from the hash table (if too few hash codes are possible, you'll end up searching a list).

Related Solutions

Java – Efficient way to shuffle objects

Your team suffers from a common problem: object denial.

Instead of a class that holds a single question with all the information associated with it, you try to create a class called question that holds all the questions in a single instance.

That's the wrong way to go about it, and it complicates what you try to do a lot! Sorting (and shuffling) parallel arrays (or Lists) is nasty business and there's no common API for it, simply because you usually want to avoid it at all.

I suggest you restructure your code like this:

class Question
{
    private Integer index;
    private String question;        
    private String answer;      
    private String opt1;        
    private String opt2;    
}

// somewhere else
List<Question> questionList = new ArrayList<Question>();

This way, shuffling your question becomes trivial (using Collections.shuffle()):

Collections.shuffle(questionList);

Java – How to make a method synchronized across all instances of a class

Synchronize on the Person.class or create a static LOCK object on which you synchronize:

synchronized(Person.class){
    //...
}

private static final Object LOCK = new Object();

//...
synchronized(LOCK){
    //...
}

Either way, we're using a single (static) lock object instance which is common to all callers. Synchronizing on the class mirrors the default behavior of synchronized static methods. But it somewhat exposes the lock, which can be dangerous because for instance, some evil code could synchronize on Person.class and never release the lock, and make your code jam up. Keeping a separate private lock is therefore more secure.

Best Answer

Related Solutions

Java – Efficient way to shuffle objects

Java – How to make a method synchronized across all instances of a class

Related Topic