HashMap Casero

package hashmapsimple;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MyMap<K, V> implements Map<K,V>{
    private int capacity;
    private int size;
    private static final int DEFAULT_SIZE = 8;
    private Entry<K,V>[] table;
    public MyMap() {
        this(DEFAULT_SIZE);
    }
    public MyMap(int xcapacity) {
        if(xcapacity <= 0){
            throw new IllegalArgumentException("Capacidad no permitida: " + capacity);
        } else {
            this.capacity = xcapacity;
        }
        this.clear();
    }
    public MyMap(Map<? extends K, ? extends V> m) {
        this.putAll(m);
    }
    @Override
    public V put(K key, V value) {
        if(key == null){
            return null;
        } else {
            int index = getIndex(key);
            System.out.println("indice -> "+ index);
            Entry<K, V> pair = table[index];
            if (pair != null && pair.getKey().equals(key)) {
                V oldValue = pair.getValue();
                pair.setValue(value);
                return oldValue;
            }
            setEntry(key, value, index);
            return value;
        }
    }
    @Override
    public V get(Object key) {
        return (this.getEntry(key) == null) ? null : this.getEntry(key).getValue();
    }
    @Override
    public boolean containsKey(Object key) {
        return this.getEntry(key) != null;
    }
    private Entry<K, V> getEntry(Object key) {
        for (int index = getIndex(key); index < capacity; index++) {
            Entry<K, V> pair = table[index];
            if (pair != null && pair.getKey().equals(key)){
                return pair;
            }
        }
        return null;
    }
    @Override
    public boolean containsValue(Object value){
        if(value != null){
            for (Entry tab : table) {
                if (tab != null && value.equals(tab.getValue())){
                    return true;
                }
            }
        }
        return false;
    }
    @Override
    public int size() {
        return size;
    }
    @Override
    public boolean isEmpty(){
        return size == 0;
    }
    @Override
    public void clear() {
        table = new Entry[capacity];
        size = 0;
    }

    @Override
    public V remove(Object key){
        int index = getIndex(key);
        Entry<K,V> e = table[index];
        if(e != null){
            for(;index < size; index++){
                table[index] = table[index + 1];
            }
            size--;
            return e.getValue();
        } else {
            return null;
        }
    }
    private int getIndex(Object key) {
       return (key.hashCode() & 0x7FFFFFFF) % table.length -1;
    }

    private void setEntry(K key, V value, int index) {
        Entry<K, V> e = table[index];
        while (e != null) {
            index++;
            if (index >= capacity) {
                table = Arrays.copyOf(table, table.length +1);
                put(key,value);
                return;
            }
            e = table[index];
        }
        table[index] = new Entry(key, value);
        size++;
    }

    /*-----------------------------------------------------------*/
    //@Override
    @Override
    public Set<K> keySet() {
        return new KeySet();
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        if(m.size() > 0){
            m.entrySet().forEach((e) -> {
                this.put(e.getKey(), e.getValue());
            });
        }
    }
    /*-----------------------------------------------------------*/
    private class KeySet extends AbstractSet<K>{
        @Override
        public Iterator<K> iterator() {
            return new KeyIterator();
        }
        @Override
        public int size() {
            return size;
        }
    }
    private final class KeyIterator extends HashIterator<K> {
        @Override
        public K next() {
            return nextEntry().getKey();
        }
    }
    /*-----------------------------------------------------------*/
    @Override
    public Collection<V> values() {
        return new Values();
    }
    private class Values extends AbstractCollection<V>{
        @Override
        public Iterator<V> iterator() {
            return new ValueIterator();
        }
        @Override
        public int size() {
            return size;
        }
    }
    private final class ValueIterator extends HashIterator<V>{
        @Override
        public V next() {
            return nextEntry().getValue();
        }
    }
    /*-----------------------------------------------------------*/
    @Override
    public Set<Map.Entry<K, V>> entrySet() {
        return new EntrySet();
    }
    private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        @Override
        public Iterator<Map.Entry<K, V>> iterator() {
            return new EntryIterator();
        }
        @Override
        public int size() {
            return size;
        }
    }
    private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
        @Override
        public Entry<K, V> next() {
            return nextEntry();
        }
    }
    /*-----------------------------------------------------------*/
    private abstract class HashIterator<E> implements Iterator<E> {
        private int index;
        private Entry<K,V> currEntry;
        private Entry<K,V> nextEntry;
        @SuppressWarnings("empty-statement")
        HashIterator() {
            index = 0;
            currEntry = null;
            nextEntry = null;
            if (table[index] != null){
                nextEntry = table[index];
            }
        }
        @Override
        public boolean hasNext() {
            return nextEntry != null;
        }
        @SuppressWarnings("empty-statement")
        public Entry<K,V> nextEntry() {
            currEntry = nextEntry;
            index++;
            Entry<K,V> t = table[index];
            if (t != null) {
                nextEntry = t;
            } else {
                nextEntry = null;
                for (;index < table.length; index++){
                    if (table[index] != null){
                        nextEntry = table[index];
                    }
                }
            }
            return currEntry;
        }
    }
    /*-----------------------------------------------------------*/
    class Entry<K,V> implements Map.Entry<K,V>{
        final K key;
        V value;
        Entry(K k, V v) {
            value = v;
            key = k;
        }
        @Override
        public final K getKey() {
            return key;
        }
        @Override
        public final V getValue() {
            return value;
        }
        @Override
        public V setValue(V v) {
            V val = value;
            value = v;
            return val;
        }
        @Override
        public String toString() {
            return getKey() + "=" + getValue();
        }
    }
}

/*----------------------- Prueba en Consola --------------------------------*/
package hashmapsimple;
public class Cuerpo
{
    public static void main(String[] args) {
        MyMap<Integer,String>col= new MyMap();
        col.put(1, "Deborah");
        col.put(2, "Tommy");
        col.put(3, "Franco");
        col.put(4, "Manuela");
        col.put(null,"pepe");
        java.util.HashMap<Integer, String> m = new java.util.HashMap();
        m.put(5, "Miguel");
        m.put(6, "Denisse");
        col.putAll(m);
        System.out.println(" ");
        System.out.println("con containsKey: " + col.containsKey(1));
        System.out.println("con containsKey: " + col.containsKey(7));
        System.out.println(" ");
        System.out.println("con get: " + col.get(1));
        System.out.println("con get: " + col.get(7));
        System.out.println(" ");
        System.out.println("con containsValue: " + col.containsValue("Franco"));
        System.out.println("con containsValue: " + col.containsValue("Rodrigo"));
        System.out.println("con containsValue: " + col.containsValue(null));
        //col.remove(2);
        //col.remove(7);
        //col.clear();
        System.out.println(" ");
        System.out.println("tamaño -> " + col.size());
        System.out.println(" ");
        System.out.println(" --valores-- ");
        col.values().stream().forEach((s) -> {
            System.out.println(s);
        });
        System.out.println(" ");
        System.out.println(" --claves-- ");
        col.keySet().stream().forEach((s) -> {
            System.out.println(s);
        });
        System.out.println(" ");
        System.out.println(" --entradas-- ");
        col.entrySet().stream().forEach((e)->{
            System.out.println("clave -> "+ e.getKey() +" valor -> "+e.getValue());
        });
    }
}