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));
     }
 }