Problems with my implementation of a Java Hashmap

Question

After doing research and looking up old posts for a while I realize that when you use a Hashmap or Hashtable in Java where Strings are the keys, the first "round" of hashing is applied to each String objects hashCode (apparently there is a second hash function that is applied to the result of int hashCode()), where by default int hashCode()has some relationship with it's callers location in memory (from what I read). With that being said, if I had a map with a developer defined class for keys, I read that I can override int hashCode() and use some distinct field(s) of my object to return the most unique int possible for each object. However, consider the code fragment below that contains arrays of primitive types.

import java.util.HashMap;

public class test
{ 

    public static void main(String[] args) { 

        HashMap<char[], int[] > map = new HashMap<char[], int[]>();

        String s = "Hello, World";

        int x[] = { 1, 2, 3, 4, 5 };

        map.put( s.toCharArray(), x );

        x = map.get( s );

        for ( int i : x )
            System.out.print( i );
    } 
}

The program crashes from a NullPointerException of course because map.get( s ); returns null. I suspect that has happened because there are two different references between map.put() and map.get(). What I want the program to output is 1 2 3 4 5.

My question: How can I get the above code fragment to look up the keys by the value of the key vs the reference of the key? That is, how can I get the program to output 1 2 3 4 5?

Edit: I am using the hashmap as a look up table. I am reading strings from a file and need a fast way to determine if the string I just read in is in the table or not.

Answer 1

Just use the String as the key for the map.

HashMap<String, int[] > map = new HashMap<String, int[]>();
String key = "array1";
int x[] = { 1, 2, 3, 4, 5 };
map.put( key, x );

String is immutable so it is good choice as the key for a map.

Adding another array:

String key2 = "array2";
int x2[] = { 6, 7, 8, 9, 10 };
map.put( key2, x2 );

Outputting values:

x = map.get( key );
for ( int i : x )
    System.out.print( i + " " );
}

gives

1 2 3 4 5

x = map.get( key2 );
for ( int i : x )
    System.out.print( i + " " );
}

gives

6 7 8 9 10

Answer 2

1. "Read somewhere that there are 2 rounds of hashing". No. If you want to see how Strings are hashed - go look at the code.
2. The basic contract of hash map is that it will retrieve items if the keys have the same hash and are equal by their equals function. Why do you think that char[] has an overridden equals that allows it to compare itself with Strings properly? Or even between each other? It does not override equals, and will only return true if it's the same instance.
3. You are using arrays for keys. That is possible but most senior devs will shout at you for that. There is no good way to compare them: Object.equals (that they use by default) means you cannot reproduce an array - you have to use the exact same object. Using Arrays.equals (or similar means to compare contents) will mean you have mutable objects as keys - BAD.

As per your comment I understand that you want to be able to edit the string. That's fine before you put it into the map. But do not change objects when they are keys in a map in a way that might change the hash code or equals. Best way to do this is to use a custom object. Arrays are not suitable for this.

If you really want to change the values on the fly while they're in a map - use a BiMap (or do what it does in forcePut yourself).

Answer 3

There are many ways to do this. One of the smallest changes you can do is to simply save your char[] before calling put(), and use the same one as argument to get():

char[] charArray = s.toCharArray();
map.put(charArray, x);
x = map.get(charArray);

The important thing here is that you need to use the same object to get() as you used to put().

Answer 4

From Oracle Documentation

public V get(Object key)

Returns the value to which the specified key is mapped, or null if this 
map contains no mapping for the key.
More formally, if this map contains a mapping from a key k to a value v 
such that (key==null ? k==null : key.equals(k)), then this method returns v; 
otherwise it returns null.

and obviously s.equals(s.toCharArray()) is false. They are not even the same Class.

However, you could use as key a Class that overrides equals() in a way that returns true for your case. For example:

class MyCharArray {

   private char[] data;

   @Override
   public boolean equals(Object o) {
       if (o instanceOf String) {
           return data.equals(o.toCharArray);
       else {
           return false;
       }
   }

   ...
}