Why does this implementation of Quadratic Probing fail when not overriding values on collision?

My current implementation of Quadratic Probing overrides the item being stored at the current index with the new item when a collision occurs. I insert three Person objects which are stored by using their lastname as key. To test the collision resolution of the implementation they all have the same last name which is "Windmill".

I need the implementation to keep all person objects but just move them to a different index instead of overriding them.

The list size has been set as 7, stored in variable "M" used for modulo in the insert function.

Insert function

@Override
public void put(String key, Person value) {
   int tmp = hash(key);
   int i, h = 0;

    for (i = tmp; keys[i] != null; i = (i + h * h++) % M) {
        collisionCount++;

        if (keys[i].equals(key))  { 
            values[i] = value;
            return; 
        } 
    }

    keys[i] = key;
    values[i] = value;
    N++;
}

Hash function

private int hash(String key) {
    return (key.hashCode() & 0x7fffffff) % M;
}

get function

@Override
public List<Person> get(String key) {
    List<Person> results = new ArrayList<>();

    int tmp = hash(key);
    int i = hash(key), h = 0;

    while (keys[i] != null)
    {
        if (keys[i].equals(key))
            results.add(values[i]);

        i = (i + h * h++) % M;
    }   

    return results;
}

When i remove the piece of code that overrides previous values, the index int overflows and turns into a negative number, causing the program to crash.

You get overflow because you do % M after some operations with ints that cause overflow. You need to replace i = (i + h * h++) % M with some additional operations based on modulo operation properties (https://en.wikipedia.org/wiki/Modulo_operation):

• (a + b) mod n = [(a mod n) + (b mod n)] mod n.
• ab mod n = [(a mod n)(b mod n)] mod n.