but still... :D

return (int)value;

Map<Character, Integer> map = new HashMap<>();
IntStream.range('\n', 'z' + 1).forEach(e -> map.put((char) e, e));
map.entrySet().forEach(System.out::println);

public class MyHashMap<K, V> implements MyMap<K, V> {
    private Node<K, V>[] hashTable = new Node[31];
    private static int size;


    // when using generics here, too we can make the inner class static
    private static class Node<K, V> { // -----------------------------------------------
        K key;
        V value;
        Node<K, V> next;

        public Node(K key, V value, Node<K, V> next) {
            this.key = key;
            this.value = value;
            this.next = next;
            size++;
        }
    } // end inner class Node ---------------------------------------------

    @Override
    public void put(K key, V value) {
        // first check if the key already exists (includes key, value check for null)
        if (replace(key, value))
            return;

        int hashKey = Math.abs(key.hashCode()) % hashTable.length; // calculate an index for the hashTable (use % hashTable.length)
        //insert the new Node into the hashTable and let the new Node point to the Node previous in the hashTable
        hashTable[hashKey] = new Node<>(key, value, hashTable[hashKey]);
    }

    @Override
    public V get(K key) {
        if (key == null)
            throw new IllegalArgumentException("key must not be null");

        int hashKey = Math.abs(key.hashCode()) % hashTable.length; // calculate an index for the hashTable (use % hashTable.length)
        Node<K, V> needle = hashTable[hashKey]; // and get the first element for that hashKey, if it is null, no elements exist

        while (needle != null) {
            if (needle.key.equals(key))
                return needle.value;

            // set needle to the next element;
            needle = needle.next;
        }

        return null;
    }

    @Override
    public int size() {
        return size;
    }
}

@Override
public boolean replace(K key, V value) {
    if (key == null || value == null)
        throw new IllegalArgumentException("key or value null");

    int hashKey = Math.abs(key.hashCode()) % hashTable.length; // calculate an index for the hashTable (use % hashTable.length)
    Node<K, V> needle = hashTable[hashKey]; // and get the first element for that hashKey, if it is null, no elements exist
    // otherwise go throw all the linked elements and compare them to key. if yes, replace, if we end up on null
    // we weren't able to find and replace the element -> false
    while (needle != null) {
        if (needle.key.equals(key)) {
            needle.value = value;
            return true;
        }
        // set needle to the next element;
        needle = needle.next;
    }
    return false;
}

@Override
public boolean remove(K key) {
    if (key == null)
        throw new IllegalArgumentException("key must not be null");

    int hashKey = Math.abs(key.hashCode()) % hashTable.length; // calculate an index for the hashTable (use % hashTable.length)
    Node<K, V> needle = hashTable[hashKey]; // and get the first element for that hashKey, if it is null, no elements exist
    Node<K, V> prev = null;
    while (needle != null) {

        if (needle.key.equals(key)) {
            if (prev == null)
                hashTable[hashKey] = null;
            else
                prev = needle.next;

            size--;
            return true;
        }
        // set needle to the next element;
        prev = needle;
        needle = needle.next;
    }

    return false;
}

@Override
public void clear() {
    hashTable = new Node[31];
    size = 0;
}

public interface MyMap<K, V> {
    void put(K key, V value);

    V get(K key);

    boolean replace(K key, V value);

    boolean remove(K key);

    void clear();

    int size();
}

// Map theory:
// a HashMap has a complexity of O(1) in the best case (for put, get, replace, remove). If the map degenerates it's up to O(N)
// (all values have the same hash or just a handful of hashes is used). To avoid this a filling level needs to be defined (number of elements / hashTable.length)
// if the filling level becomes too large, reorganization of the hashTable needs to be done (enlarge it, the complexity
// is O(N)). If filling level = 1.0 -> that's the medium length of the value lists (I don't know the correct english term for
// them, a direct translation would be 'overflow list') as well, we have a complexity of O(log N / log log N)))
// that would be the optimum you can reach. Usually you rehash when a filling level of 1.3 - 1.5 is reached