Re-hashing a hash map inside put method

I'm trying to implement a separate-chaining hash map in Java. Inside the put()-method I want to re-hash the map if the load factor( nr-of-elements/size-of-array) gets to large. For this I have written another method rehash() that rehashes the list by doubling the size of the array/capacity and then adding all the entries again (atleast this is what I want it to do). The problem is that when I test it I get an "java.lang.OutOfMemoryError: Java heap space" and I'm guessing this is since I'm calling the put() method inside the rehash() method as well. The problem is that I don't really know how to fix this. I wonder if someone can check my code and give me feedback or give me a hint on how to proceed.
The Entry<K,V> in the code below is a nested private class in the hash map class.

Thanks in advance!

The put()-method:

public V put(K key,V value) {
int idx = key.hashCode()%capacity;  //Calculate index based on hash code.
if(idx<0) {    
idx+=this.capacity;  //if index is less than 0 add the length of the array table
}
if(table[idx]==null) {   //If list at idx is empty just add the Entry-node
table[idx] = new Entry<K,V>(key,value);
nr_of_keys +=1;
if(this.load()>=this.load_factor) {  //Check if load-factor is greater than maximum load. If this is the case rehash.
rehash();
}
return null;
} else {
Entry<K,V> p = table[idx];  //dummy pointer
while(p.next!=null) { //while next node isn't null move the pointer forward
if(p.getKey().equals(key)) {    //if key matches:
if(!p.getValue().equals(value)) { //if value don't match replace the old value.
V oldVal = p.getValue();
p.setValue(value);
return oldVal; 
}
} else {
p=p.next;
}
}
if(p.getKey().equals(key)) {   //if the key of the last node matches the given key:
if(!p.getValue().equals(value)) {
V oldVal = p.getValue();
p.setValue(value);
return oldVal;
} else {
return null;
}
}
p.next = new Entry<K,V>(key,value); //key doesn't exist so add (key,value) at the end of the list.
nr_of_keys +=1;
if(this.load()>=this.load_factor) { //if load is to large rehash()
rehash();
}
return null;
}
}

Rehash()-method:

public void rehash() {
Entry<K,V>[] tmp = table;  //create temporary table
int old_capacity = this.capacity;  //store old capacity/length of array.
this.capacity = 2*capacity; //New capacity is twice as large
this.nr_of_keys=0; //reset nr. of keys to zero.
table = (Entry<K, V>[]) new Entry[capacity];  //make this.table twice as large
for(int i=0; i<old_capacity;i++) { //go through the array
Entry<K,V> p = tmp[i]; //points to first element of list at position i.
while(p!=null) {
put(p.getKey(), p.getValue());
p=p.next;
}
}
}

The load()-method:

public double load() {
return((double) this.size())/((double)this.capacity);
}

where size() returns the number of (key,value) pairs in the map and capacity is the size of the array table (where the linked lists are stored).

Once you rehash your map nothing will be the same. The buckets the entry sets, etc.
So.

• create your temporary table.
• get the values normally using your current get methods.
• then create new buckets based on rehashing to the new bucket size, with the new capacity and add to the table. (DO NOT USE PUT).
• Then replace the existing table with the just created one. Make certain that all values pertinent to the new table size are also changed such as bucket selection methods based on threhholds, capcity, etc.

Finally use print statements to track the new buckets and the movement of items between buckets.

You have added the rehash(), but there is still the load() implemetation missing (or inside load, the size()).

The pattern looks clear though, and allows a guess, waiting for this additional info.

You tell us that when the load factor reaches a certain point inside a put, you rehash. That rehash doubles the internal array and calls put again. And in the end you have no memory.

Where, my bet would be there is some subtle or not-so-subtle recursion taking place where you put, it rehashes by doubling the memory usage, then re-puts, which somehow creates a rehashing...

A first possiblity would be that there is some internal variables tracking the array's state that are not properly reset (e.g. number of occupied entries, ...). Confusing the "old" array data with that of the new being built would a likely culprit.

Another possiblity is with your put implementation, but it would require a step by step debug - which I'd advise you to perform.