HashMap的简单实现

 基本概念

Map 别名映射表，也叫关联数组，基本思想是它维护的键-值(对)关联，因此可以用键查找值，也有放入键值的操作，下面根据定义自己来实现一个Map,首先应该想到的是数组，因为大多数Java集合类底层都是基于数组和链表的，这里我给它命名叫做 MapVersion01

public class MapVersion01<K,V> {
    //存储每一个键值对的数组
    private Object[][] pairs;
    //数组的容量
    private int index;

    public MapVersion01(int capacity) {
        this.pairs = new Object[capacity][2];
    }

    /**
     * 插入的方法
     * @param key
     * @param value
     */
    public void  put(K key, V value) {
        if(index >= pairs.length)
            throw new IndexOutOfBoundsException();
        pairs[index++] = new Object[]{key, value};
    }

    /**
     * 查找方法
     * @param key
     * @return
     */
    public V get(K key) {
        for(int i = 0 ; i < index ; i++) {
            if(key.equals(pairs[i][0]))
                return (V)pairs[i][1];
        }
        return null;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for(int i = 0 ; i < index ; i ++) {
            sb.append(pairs[i][0]).toString();
            sb.append(" : ");
            sb.append(pairs[i][1].toString());
            if(i < index - 1) {
                sb.append("\n");
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        MapVersion01<Integer,String> map = new MapVersion01<Integer,String>(10);
        map.put(1,"111");
        map.put(2,"222");
        map.put(3,"333");
        map.put(4,"444");
        map.put(5,"555");
        map.put(6,"666");
        System.err.println(map);
    }
单元测试结果:

这里为了方便查看，重写了toString方法，打印出每一个键值对儿，乍一看，实现起来貌似很简单，再看一下Map接口，好像少了点什么。对了，少了2样东西:

1. 遍历hash表取键值对的方法；
2. 分别得到所有键的集合、值的集合；

这2个问题应该很好实现,下面是我实现的:

public Set<K> keySet() {
    Set<K> keySet = new HashSet<K>();
    if (pairs.length > 0) {
        for (int i = 0; i < index; i++) {
            K key = (K) pairs[i][0];
            keySet.add(key);
        }
    }
    return keySet;
}

public Set<V> values() {
    Set<V> values = new HashSet<V>();
    if (pairs.length > 0) {
        for (int i = 0; i < index; i++) {
            V value = (V) pairs[i][1];
            values.add(value);
        }
    }
    return values;
}

public Set<Entry<K, V>> entrySet() {
    Set<Entry<K, V>> set = new HashSet<Entry<K, V>>();
    if (pairs.length > 0) {
        for (int i = 0; i < index; i++) {
            K key = (K) pairs[i][0];
            V value = (V) pairs[i][1];
            Entry<K, V> entry = new Entry<K, V>(key, value);
            set.add(entry);
        }
    }
    return set;
}

//键值对存放在一起的映射对象
private static class Entry<K, V> {
    private K key;
    private V value;

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

    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getValue() {
        return value;
    }

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

    @Override
    public int hashCode() {
        return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode());
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Entry))
            return false;
        Entry<K, V> me = (Entry<K, V>) obj;
        return (me.getKey() == null ? key == null : me.getKey().equals(key)) &&
                (me.getValue() == null ? value == null : me.getValue().equals(value));
    }
}