手动实现HashMap和HashTable

散列的具体实现：

1.HashSet

2.HashMap

为什么使用散列：

散列可以提供平均时间复杂度为O（1）的实现方法。

散列表的定义：

散列表（哈希表），是指可以通过关键字key直接访问到内容value的一种数据结构。可以一个value对应多个key,但是一个key只能对应一个value，其中是通过key映射到一个位置上，来直接访问value。

手动实现散列表【hashtable，hashmap】：

哈希表的数据结构图：

【网上偷懒盗了一张图，侵删。。】

HashTable/HashMap 的实现就是一个数组和链表的结合。

1.通过元素的简单键key实现hash索引，找到元素在HashTable中的位置

2.使用链表来解决哈希碰撞冲突

核心接口：

1.status put(int key,int value)

2.status get(int key,int *val)

3.status delete(int key)

status表示操作的成功或者失败，0表示成功，1表示失败
简化实现，因此使用key的类型为int，value的类型为int

---

HashMap:

HashEntry的数据结构是链表形式的。

class HashEntry {
    private final Object key;
    private Object value;
    private HashEntry next;

    public HashEntry(Object key, Object value, HashEntry next) {
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public Object getKey() {
        return key;
    }

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public HashEntry getNext() {
        return next;
    }

    public void setNext(HashEntry next) {
        this.next = next;
    }
}

HashMap的具体实现：

    public class MyHashMap {

    //默认初始化大小 16
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    //默认负载因子 0.75
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //临界值
    private int threshold;

    //元素个数
    private int size;

    //扩容次数
    private int resize;

    private HashEntry[] table;

    public MyHashMap() {
         table = new HashEntry[DEFAULT_INITIAL_CAPACITY];
        threshold = (int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        size = 0;
    }

    private int index(Object key) {
        //根据key的hashcode和table长度取模计算key在table中的位置
        return key.hashCode() % table.length;
    }


    /*
     * HashMap会对null值得key进行特殊处理，总是放到table[0]位置
     * put()就是先计算hash，然后hash与table.length取模计算index值。
     * 然后将key放到table[index]位置，当table[index]
     * 已经存在其他元素时，会在table[index]位置形成一个链表，将
     * 新添加的元素放在table[index]，原来的元素通过
     * Entry的next进行链接欸，这样以链表形式解决hash冲突问题。
     * 当元素数量达到临界值[capacity*factor]时，
     * 则进行扩容，是table数组长度变为table.length*2
     */

    public void put(Object key, Object value) {
        //key为null时需要特殊处理，为简化实现忽略null值
        if (key == null) return;
        int index = index(key);

        //遍历index位置的entry，若找到重复key则更新对应entry的值，然后返回
        HashEntry entry = table[index];
        while (entry != null) {
            if (entry.getKey().hashCode() == key.hashCode() && (entry.getKey() == key || entry.getKey().equals(key))) {
                entry.setValue(value);
                return;
            }
            entry = entry.getNext();
        }
        //若index位置没有entry或者未找到重复的key，则将新key添加到table的index位置
        add(index, key, value);
    }

    private void add(int index, Object key, Object value) {
        //将新的entry放到table的index位置第一个，若原来有值则以链表形式存放
        HashEntry entry = new HashEntry(key, value, table[index]);
        table[index] = entry;
        //判断size是否达到临界值，若已达到则进行扩容，将table的capacicy翻倍
        if (size++ >= threshold) {
            resize(table.length * 2);
        }
    }

    /*
     * resize()实现hashmap扩容，具体过程为：
     * 先创建一个容量大小为table.length*2的新的table，
     * 修改临界值，然后把table里面的元素计算hash值
     * 并使用table.length*2重新计算index放入到新的table里面
     * 
     * 注意：
     * 每个元素的hash全部重新计算index，而不是简单的把原来
     * 的index位置元素简单地移动到新table对应位置
     */
    private void resize(int capacity) {
        if (capacity <= table.length) return;

        HashEntry[] newTable = new HashEntry[capacity];
        //遍历原table，将每个entry都重新计算hash放入newTable中
        for (int i = 0; i < table.length; i++) {
            HashEntry old = table[i];
            while (old != null) {
                HashEntry next = old.getNext();
                int index = index(old.getKey());
                old.setNext(newTable[index]);
                newTable[index] = old;
                old = next;
            }
        }
        //用newTable替table
        table = newTable;
        //修改临界值
        threshold = (int) (table.length * DEFAULT_LOAD_FACTOR);
        resize++;
    }

    /*
     * 当key为null时会进行特殊处理，在table[0]的链表上查找
     * key为null的元素
     * 源码之中：get()的过程就是先计算hash，然后再通过hash
     * 与table.length取模计算index值，然后遍历table[index]上
     * 的链表，直到找到key，然后返回
     * 此处简单处理
     */
    public Object get(Object key) {
        //这里简化处理，忽略null值
        if (key == null) return null;
        HashEntry entry = getEntry(key);
        return entry == null ? null : entry.getValue();
    }

    public HashEntry getEntry(Object key) {
        HashEntry entry = table[index(key)];
        while (entry != null) {
            if (entry.getKey().hashCode() == key.hashCode() && (entry.getKey() == key || entry.getKey().equals(key))) {
                return entry;
            }
            entry = entry.getNext();
        }
        return null;
    }


    /*
     * remove()和put(),get()类似，计算hash,计算index，然后遍历查找,
     * 将找到的元素从table[index]链表之中移除，修改size
     */
    public void remove(Object key) {
        if (key == null) return;
        int index = index(key);
        HashEntry pre = null;
        HashEntry entry = table[index];
        while (entry != null) {
            if (entry.getKey().hashCode() == key.hashCode() && (entry.getKey() == key || entry.getKey().equals(key))) {
                if (pre == null) table[index] = entry.getNext();
                else pre.setNext(entry.getNext());
                //如果成功找到并删除，修改size
                size--;
                return;
            }
            pre = entry;
            entry = entry.getNext();
        }
    }

    public boolean containsKey(Object key) {
        if (key == null) return false;
        return getEntry(key) != null;
    }

    public int size() {
        return this.size;
    }

    /*
     * clear()就是遍历table然后把每个位置置为
     * null,同时修改元素个数为0，需要
     * 注意的是clear()只会清除里面的元素，并不会重置capacity
     */
    public void clear() {
        for (int i = 0; i < table.length; i++) {
            table[i] = null;
        }
        this.size = 0;
    }


    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("size:%s capacity:%s resize:%s\n\n", size, table.length, resize));
        for (HashEntry entry : table) {
            while (entry != null) {
                sb.append(entry.getKey() + ":" + entry.getValue() + "\n");
                entry = entry.getNext();
            }
        }
        return sb.toString();
    }



    public static void main(String[] args){
        MyHashMap hashmap = new MyHashMap();
        hashmap.put(0,1);
        hashmap.put(1,1);
        hashmap.put(2,4);

        System.out.println(hashmap.get(0));
        System.out.println(hashmap.get(1));
        System.out.println(hashmap.get(2));


     }
}

从我简单的实现中，不难发现:

HashMap的底层存储，使用的是数组存储
数组中的每个元素是链表的地址
通过链表的地址找到所有Hash值相同元素

---

HashTable的实现：

 class Entry{
    int key;//关键字
    int value;
    Entry next;//链表

    public Entry(int key,int value ,Entry entry)//构造函数
    {
        super();
        this.key = key;
        this.value = value;
        this.next = entry;
    }
}


public class MyHashTable {

      private static final int DEFAULT_INITAL_CAPACITY = 5;//定义的是默认长度

        private static final float LOAD_FACTOR = 0.75f;//扩容因子

        private Entry[] table = new Entry[DEFAULT_INITAL_CAPACITY];//初始化
        private int size =0;//哈系表大小
        private int use =0;//使用的地址数量


        public void put(int key,int value){//压入内容
            int index =hash(key);//通过hash方法转换，采用的是直接法

            if (table[index]==null)//说明位置未被使用
            {
             table[index] = new Entry(-1,-1,null);
            }

            Entry tmp = table[index];
            if (tmp.next == null)//说明位置未被使用
            {
                table[index].next = new Entry(key,value,null);
                size++;
                use++;
                if (use >= table.length*LOAD_FACTOR)//判断是否需要扩容
                {
                    resize();//扩容方法
                }
            }else{//已被使用，则直接扩展链表
                for (tmp = tmp.next;tmp!=null;tmp = tmp.next)
                {
                    int k =tmp.key;
                    if(k==key)
                    {
                        tmp.value = value;
                        return;
                    }
                }

                Entry temp = table[index].next;
                Entry newEntry = new Entry(key,value,temp);
                table[index].next = newEntry;
                size++;
            }

        }
        public void remove(int key) //删除，链表的中间值删除方法
        {
            int index =hash(key);
            Entry e = table[index];
            Entry pre = table[index];
            if (e!=null&& e.next!=null)
            {
                for (e=e.next;e!=null;pre =e,e =e.next)
                {
                    int k =e.key;
                    if(k==key)
                    {
                        pre.next = e.next;
                        size--;
                        return;
                    }
                }
            }
        }

        public int get(int key)//通过key提取value
        {
            int index = hash(key);
            Entry e =table[index];
            if (e!=null&&e.next!=null)
            {
                for (e=e.next;e!=null;e=e.next)
                {
                    int k = e.key;
                    if (k ==key)
                    {
                        return e.value;
                    }
                }
            }
            return -1;
        }

        public int size(){//返回元素个数
            return size;

        }

        public int getLength(){//哈系表大小
            return table.length;
        }


        /*
         * 装填因子达到阈值后，重新resize桶，桶的大小分配
         * 策略一般为原桶大小的2倍。原桶之中的所有数据rehash
         * 并拷贝到新桶之中。
         */
        private void resize() {
            int newLength = table.length*2;
            Entry[] oldTable = table;
            table = new Entry[newLength];
            use = 0;
            for(int i =0 ;i<oldTable.length;i++)
            {
                if (oldTable[i]!=null&&oldTable[i].next !=null)
                {
                    Entry e = oldTable[i];
                    while(null!=e.next)
                    {
                        Entry next = e.next;
                        int index =hash(next.key);
                        if (table[index]==null)
                        {
                            use++;
                            table[index] = new Entry(-1,-1,null);
                        }
                        Entry temp = table[index].next;
                        Entry newEntry =new Entry(next.key,next.value,temp);
                        table[index].next = newEntry;

                        e = next;
                    }
                }
            }

        }

        private int hash(int key) {//哈希方法
            return key%table.length;
        }



        public static void main(String[] args){

            MyHashTable hashtable = new MyHashTable();
            hashtable.put(0,1);
            hashtable.put(1,1);
            hashtable.put(2,4);

            System.out.println(hashtable.get(0));
            System.out.println(hashtable.get(1));
            System.out.println(hashtable.get(2));

        }


}

在简单实现HashMap和HashTable的过程中，参考了JDK源码的具体实现。同时，加深了我对HashMap和HashTable的更深入的了解。

HashMap:

// 此处计算key的hash值时，会判断是否为null，如果是，则返回0，即key为null的键值对
// 的hash为0。因此一个hashmap对象只会存储一个key为null的键值对，因为它们的hash值都相同。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// 将键值对放入table中时，不会校验value是否为null。因此一个hashmap对象可以存储
// 多个value为null的键值对
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
   boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}

HashTable:

 public synchronized V put(K key, V value) {
// 确保value不为空。这句代码过滤掉了所有value为null的键值对。因此Hashtable不能
// 存储value为null的键值对
if (value == null) {
throw new NullPointerException();
}

// 确保key在table数组中尚未存在。
Entry<?,?> tab[] = table;
int hash = key.hashCode(); //在此处计算key的hash值，如果此处key为null，则直接抛出空指针异常。
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}

addEntry(hash, key, value, index);
return null;
}

对比源代码，我们不难发现：

1、 HashMap计算key的hash值时调用单独的方法，在该方法中会判断key是否为null，如果是则返回0；而Hashtable中则直接调用key的hashCode()方法，因此如果key为null，则抛出空指针异常。

2、 HashMap将键值对添加进数组时，不会主动判断value是否为null；而Hashtable则首先判断value是否为null。

3、以上原因主要是由于Hashtable继承自Dictionary，而HashMap继承自AbstractMap。