手写HashMap

编写顶层接口

 

public interface Map<K,V> {

    public V put(K k,V v);

    public V get(K k);

    public int size();

    public interface  Entry<K,V>{
        public K getKey();
        public V getValue();
    }

}

 

 

实现类

import java.util.ArrayList;
import java.util.List;

public class HashMap<K, V> implements Map<K, V> {
    //扩容以后是不是需要把以前老表里面的元素再hash？？？？  需要，index取模的位置发生变化
    //再hash耗时   所以此时map.put特别慢


    //初始容量    扩容机制  当前容量乘2      2^n
    private static int defaultLength = 16;
    //加载因子
    private static double defaultLoader = 0.75;

    private Entry<K, V>[] table = null;
    //初始大小
    private int size = 0;

    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<String, String>();

        for (int i = 0; i < 10000; i++) {

            map.put("huyue" + i, "huyue" + i);
        }

        for (int i = 0; i < 10000; i++) {

            String s = map.get("huyue" + i);
            System.out.println(i + "===" + s);
        }

    }


    public HashMap() {
        this(defaultLength, defaultLoader);
    }

    public HashMap(int length, double loader) {
        defaultLength = length;
        defaultLoader = loader;
        table = new Entry[defaultLength];
    }

    public HashMap(Entry[] table, int size) {
        super();
        this.table = table;
        this.size = size;
    }


    @Override
    public int hashCode() {
        return super.hashCode();
    }


    //递归获取链表中相等的值
    public V findValueByEqualKey(K k, Entry<K, V> entry) {

        if (k == entry.getKey() || k.equals(entry.getKey())) {

            return entry.getValue();
        } else {
            if (entry.next != null) {
                return findValueByEqualKey(k, entry.next);
            }

        }
        return null;
    }


    //获得存储位置
    public int getIndex(K k) {
        int m = defaultLength;
        //的到的可能是一个负数   jdk  决定的hashcode可能是一个负数   取反
        int index = k.hashCode() % m;
        return index >= 0 ? index : -index;
    }

    //存值
    private Entry<K, V> newEntry(K k, V v, Entry<K, V> next) {

        return new Entry(k, v, next);
    }

    //扩容
    public void up2Size() {
        Entry<K, V>[] newTable = new Entry[2 * defaultLength];
        //再hash
        reHash(newTable);
    }

    //再hash
    public void reHash(Entry<K, V>[] newTable) {
        List<Entry<K, V>> list = new ArrayList<Entry<K, V>>();
        //这里是把旧的表里面的数据找到，里面涉及到一个递归
        for (int i = 0; i < table.length; i++) {
            //当前数值位置没存值 跳过
            if (table[i] == null) {
                continue;
            }
            findEntryByNext(table[i], list);
        }
        if (list.size() > 0) {
            //再初始化
            size = 0;
            defaultLength = defaultLength * 2;
            table = newTable;
            //再hash
            for (Entry<K, V> entry : list) {
                if (entry.next != null) {
                    //重新hash，就是所有重新生成
                    entry.next = null;
                }
                //这里就是再hash
                put(entry.getKey(), entry.getValue());
            }
        }

    }


    //查询所有entry
    public void findEntryByNext(Entry<K, V> entry, List<Entry<K, V>> list) {
        //递归操作链表
        if (entry != null && entry.next != null) {
            list.add(entry);
            //递归下一个
            findEntryByNext(entry.next, list);
        } else {

            list.add(entry);
        }
    }


    //**************************************
    @Override
    public V put(K k, V v) {
        //根据k拿到存储位置
        int index = getIndex(k);
        //拿到当前值
        Entry<K, V> entry = table[index];
        //当前位置未被占用
        if (entry == null) {
            //next 第一个无指向
            table[index] = newEntry(k, v, entry);
            size++;
        } else {
            table[index] = newEntry(k, v, entry);
        }
        return table[index].getValue();
    }


    //**************************************
    @Override
    public V get(K k) {
        int index = getIndex(k);
        if (table[index] == null) {
            return null;
        }

        return findValueByEqualKey(k, table[index]);
    }

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


    //内部类
    class Entry<K, V> implements Map.Entry<K, V> {
        K k;
        V v;
        Entry<K, V> next;

        //构造函数
        public Entry(K k, V v, Entry<K, V> next) {
            this.k = k;
            this.v = v;
            this.next = next;
        }

        public K getK() {
            return k;
        }

        public void setK(K k) {
            this.k = k;
        }

        public V getV() {
            return v;
        }

        public void setV(V v) {
            this.v = v;
        }

        public Entry<K, V> getNext() {
            return next;
        }

        public void setNext(Entry<K, V> next) {
            this.next = next;
        }

        @Override
        public K getKey() {
            return k;
        }

        @Override
        public V getValue() {
            return v;
        }
    }


}