基于Java的HashMap和HashSet实现

一、Map接口类：

import java.util.Iterator;

public interface IMap<K, V> {
    /* 清除所有键值对 */
    void clear();

    /* key是否已经存在 */
    boolean containsKey(K key);

    /* value是否存在 */
    boolean containsValue(V value);

    /* 根据key获得value */
    V get(K key);

    /* map是否为空 */
    boolean isEmpty();

    /* 所有key组成的数组 */
    MyHashSet<K> keySet();

    /* 存入键值对 */
    void put(K key, V value);

    /* 把另外一个map中的所有键值对存入到当前map中 */
    void putAll(IMap<? extends K, ? extends V> map);

    /* 根据key删除一个键值对 */
    V remove(K key);

    /* 键值对的个数 */
    int size();

    /* 所有的value组成的数组 */
    V[] values();

    Iterator<MyHashMap.Node> iterator();
}

二、HashSet接口类：

import java.util.Iterator;

public interface IHashSet<E> {
    void add(E key);

    void remove(E key);

    void clear();

    boolean contains(E key);

    boolean isEmpty();

    int size();

    Iterator<E> iterator();
}

三、HashMap类：

import java.util.Iterator;

public class MyHashMap<K, V> implements IMap<K, V> {
    private int length = 16;

    private Node[] buckets = new Node[length];// 桶
    private int size;

    @Override
    public void clear() {
        for (int i = 0; i < buckets.length; i++) {
            buckets[i] = null;
        }
    }

    @Override
    public boolean containsKey(K key) {
        int index = hash1(key);
        if (buckets[index] == null) {
            return false;
        } else {
            Node<K, V> p = buckets[index];// 相当于在链表中找key
            while (p != null) {
                K k1 = p.key;
                // Java == 比较的是地址
                // 借用java机制，hashcode和equals都来自于Object，用户可以改写这两个方法——制定对象相等的规则
                if (k1 == key || (k1.hashCode() == key.hashCode() && k1.equals(key))) {
                    return true;
                }
                p = p.next;
            }
        }

        return false;
    }

    @Override
    public boolean containsValue(V value) {
        for (int i = 0; i < buckets.length; i++) {
            if (buckets[i] != null) {
                Node<K, V> p = buckets[i];
                while (p != null) {
                    if (p.value.equals(value))
                        return true;
                }
            }
        }
        return false;
    }

    @Override
    public V get(K key) {
        int index = hash1(key);
        if (buckets[index] == null) {
            return null;
        } else {
            Node<K, V> p = buckets[index];
            while (p != null) {
                K k1 = p.key;
                if (k1 == key || (k1.hashCode() == key.hashCode() && k1.equals(key))) {
                    return p.value;
                }
                p = p.next;
            }
        }
        return null;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public MyHashSet<K> keySet() {
        MyHashSet<K> set = new MyHashSet<>();
        for (int i = 0; i < buckets.length; i++) {
            if (buckets[i] != null) {
                Node<K, V> p = buckets[i];
                while (p != null) {
                    set.add(p.key);
                    p = p.next;
                }
            }
        }
        return set;
    }

    @Override
    public void put(K key, V value) {
        Node<K, V> node = new Node<>(key, value);
        int index = hash1(key);// 算出在桶中的位置
        if (buckets[index] == null) {// 桶中没有东西
            buckets[index] = node;
            size++;
        } else {
            Node<K, V> p = buckets[index];// 链表的表头找到
            while (p != null) {
                K k1 = p.key;
                if (key == k1 || key.hashCode() == k1.hashCode() && key.equals(k1)) {
                    p.value = value;// 存在相同的key，则更新value
                    break;
                }
                if (p.next == null) {
                    p.next = node;
                    size++;
                    break;
                }
                p = p.next;
            }

        }
    }

    private int hash1(K key) {
        // return key.hashCode() % length;
        int h = 0;
        int seed = 31;// 素数
        String s = key.toString();
        for (int i = 0; i != s.length(); ++i) {
            h = seed * h + s.charAt(i);
        }
        return h % length;
    }

    @Override
    public void putAll(IMap<? extends K, ? extends V> map) {

    }

    @Override
    public V remove(K key) {
        int index = hash1(key);// 先定桶的位置
        if (buckets[index] == null) {
            return null;
        } else {
            Node<K, V> p = buckets[index];// 找到表头
            Node<K, V> pre = p;

            while (p != null) {
                K k1 = p.key;
                if (k1.hashCode() == key.hashCode() && k1.equals(key)) {
                    // 移除
                    if (p == pre) {
                        buckets[index] = pre.next;
                    } else {
                        pre.next = p.next;
                    }
                    size--;
                    return p.value;
                }
                pre = p;
                p = p.next;
            }
        }
        return null;
    }

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

    @Override
    public V[] values() {
        return null;
    }

    private class MapInterator implements Iterator<Node> {
        int i = 0;
        Node p = buckets[0];

        @Override
        public boolean hasNext() {
            while (this.i < length && p == null) {
                this.i++;
                if (this.i == length)
                    p = null;
                else
                    p = buckets[this.i];
            }
            // i是一个非空的桶，p是链表头
            return p != null;
        }

        @Override
        public Node next() {
            Node res = p;
            p = p.next;
            return res;
        }
    }

    @Override
    public Iterator<Node> iterator() {
        return new MapInterator();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < buckets.length; i++) {
            if (buckets[i] != null) {
                Node<K, V> p = buckets[i];
                while (p != null) {
                    sb.append("(" + p.key + "," + p.value + "),");
                    p = p.next;
                }
            }
        }
        return sb.toString();
    }

    public class Node<K, V> {
        public K key;
        public V value;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }

        private Node next;

        @Override
        public String toString() {
            return "BSTNode{" + "key=" + key + ", value=" + value + '}';
        }
    }
}

四、HashSet类：

import java.util.Iterator;

public class MyHashSet<E> implements IHashSet<E> {
    private MyHashMap<E, E> map = new MyHashMap<>();

    @Override
    public void add(E key) {
        map.put(key, null);
    }

    @Override
    public void remove(E key) {
        map.remove(key);
    }

    @Override
    public void clear() {
        map.clear();
    }

    @Override
    public boolean contains(E key) {
        return map.containsKey(key);
    }

    @Override
    public boolean isEmpty() {
        return map.isEmpty();
    }

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

    @Override
    public Iterator<E> iterator() {
        Iterator<MyHashMap.Node> iter = map.iterator();
        return new Iterator<E>() {
            @Override
            public boolean hasNext() {
                return iter.hasNext();
            }

            @Override
            public E next() {
                return (E) iter.next().key;
            }
        };
    }

    @Override
    public String toString() {
        Iterator<MyHashMap.Node> iterator = map.iterator();
        StringBuilder sb = new StringBuilder();
        while (iterator.hasNext()) {
            sb.append(iterator.next().key + ",");
        }
        return sb.toString();
    }
}

五、HashMap优化：

　　1、扩容：如果当表中的75%已经被占用，即视为需要扩容了。

　　2、如果冲突造成的链表长度超过8的时候，就要转为红黑树存储。

　　3、hash函数优化。h = key.hashCode(); h^(h>>16); h % length。