Logica dietro un algoritmo di hashing di hash della tabella hash

Sto provando a scrivere una tabella hash in Java sulla base di qualche articolo su Princeton .

The most commonly used method for hashing integers is called modular hashing: we choose the array size M to be prime, and, for any positive integer key k, compute the remainder when dividing k by M. This function is very easy to compute (k % M, in Java), and is effective in dispersing the keys evenly between 0 and M-1

Questa parte ha senso: qualunque sia il numero, il modulo della dimensione della tabella hash fornirà un indice di array all'interno di tale intervallo.

Strings. Modular hashing works for long keys such as strings, too: we simply treat them as huge integers. For example, the code below computes a modular hash function for a String s, where R is a small prime integer (Java uses 31).

Quindi viene fornito un esempio di codice, che non ottengo.

int hash = 0;
for (int i = 0; i < s.length(); i++)
    hash = (R * hash + s.charAt(i)) % M;

L'ho refactored come:

int someSmallPrimeInteger = 31;
int hash = 0;
for (int i = 0; i < key.length(); i++) {
    int unicodeCharAsInt = Character.getNumericValue(key.charAt(i));
    hash = (someSmallPrimeInteger * hash + unicodeCharAsInt) % hashTableCapacity;*

Non capisco molto su questo:

1. Perché il ciclo? Perché non basta convertire ogni char nel suo valore unicode e aggiungerlo?
2. Come è stato scelto questo "piccolo numero primo", perché?
3. Perché ha bisogno di essere primo?
4. (someSmallPrimeInteger * hash + unicodeCharAsInt) Perché questo? Qual è il significato di questa funzione?

Lo capisco così male, non riesco nemmeno a esprimere le domande in modo intelligente, anche se è un codice così piccolo.