HashMap小解

第一次实习面试的时候,小房间里面试官拿着一本本子,上来就告诉我自己是做Java的,然后问了我很多Java基础,当从HashMap如何使用到怎么实现的时候,我就两眼懵逼了,当问到安卓的Context是干什么的时候,我的内心直接被击中了。虽然写了好几个月的程序,却只停留在会用的基础上,而没去知其所以然,太脸红了。这次面试打开了我对程序语言执着研究的大门,还是菜鸟的我感觉到能问出这种问题,还如此谦虚的人真是厉害,怀抱着大神带我飞的心情,几乎热泪盈眶的我欣然带着这份offer,准备跟着大神大干一场。结果当我入职的事后才知道,大神在我来的前几天就去支付宝了...言归正传,我就整理八经研究一下这个HashMap。

HashMap

HashMap是程序编写过程中,再平常不过的一个集合类,通常通过他的put(key,value)和get(key)方法来存取数据,数据存取的类型非常多样,而且允许key和value为null。直接上源码：
HashMap

public class HashMap extends AbstractMap implements Map, 
Cloneable, Serializable { ... }

AbstractMap

public abstract class AbstractMap implements Map { ... }

HashMap继承于AbstractMap,Map定义了键值对的映射规则。AbstractMap内部也也实现了Map接口,
这是为什么嘞？难道是为了强调吗,或者是反射getInterfaces的时候能够直接获取到Map,这里不是和明白,后续再补吧。

构造方法

HashMap的构造方法四个
Ps: 全局变量中已经指定默认的加载因子0.75,初始容量16

public HashMap(int initialCapacity, float loadFactor)

public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}


public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

public HashMap(Map m){
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
        DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
}

殊途同归,最终都指向了第一个构造方法。嗯,我们来看一下。

public HashMap(int initialCapacity, float loadFactor)

这里有初始容量,加载因子两个参数,影响HashMap性能。

初始容量 是哈希表在创建时的容量。

加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时,通过调用rehash 方法将容量翻倍。

以下内容来自百度对于他们的理解：
比如说向水桶中装水,此时HashMap就是一个桶, 这个桶的容量就是加载容量,而加载因子就是你要控制向这个桶中倒的水不超过水桶容量的比例,比如加载因子是0.75 ,那么在装水的时候这个桶最多能装到3/4 处,超过这个比例时,桶会自动扩容。因此,这个桶
最多能装水 = 桶的容量 x 加载因子。
如果桶的容量是40,加载因子是0.75
那么你的桶最多能装40 x 0.75 = 30的水,如果你装了30的水还想继续装水,那么就该用大一点的桶,调用rehash就是负责增加桶的容量的方法。

数据结构

Java中最常用的两种结构是数组和模拟指针(引用),几乎所有的数据结构都可以利用这两种来组合实现,HashMap也是如此。实际上HashMap是一个“链表散列”,网上扒取了一张结构图：

hashmap结构图示例

HashMap底层还是数组,只是数组的每一项都是一条链,initialCapacity 代表数组长度。

来吧,看看构造函数的内容:

public HashMap(int initialCapacity, float loadFactor) {

   if (initialCapacity < 0)
       throw new IllegalArgumentException("Illegal initial capacity: " +
               initialCapacity);
   
   if (initialCapacity > MAXIMUM_CAPACITY) {
       initialCapacity = MAXIMUM_CAPACITY;
   } else if (initialCapacity < DEFAULT_INITIAL_CAPACITY) {
       initialCapacity = DEFAULT_INITIAL_CAPACITY;
   }
        
   if (loadFactor <= 0 || Float.isNaN(loadFactor))
       throw new IllegalArgumentException("Illegal load factor: " +
               loadFactor);
   threshold = initialCapacity;
   
   init();    
}

存储数据

数据存储用的是put(k,v)的方式

public V put(K key, V value) {
        // 如果表是空的 就新建一个HashTable
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }

        // key可以是null,调用putForNullKey方法,保存null与table第一个位置中
        if (key == null)
            return putForNullKey(value);
        // 获取key的哈希
        int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);

        // 计算key hash 值在 table 数组中的位置
        int i = indexFor(hash, table.length);

        // 迭代找出key的位置,为了得到 value
        for (HashMapEntry e = table[i]; e != null; e = e.next) {
            Object k;
            // 如果key重复了 返回老的value （所以put的结果是个object）
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        // 添加一次修改
        modCount++;
        // 将key、value添加至i位置处 替换
        addEntry(hash, key, value, i);
        return null;
    }

计算哈希值的方法

static int hash(int h) {
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

我们知道对于HashMap的table而言,数据分布需要均匀（最好每项都只有一个元素,这样就可以直接找到）,不能太紧也不能太松,太紧会导致查询速度慢,太松则浪费空间。计算hash值后,怎么才能保证table元素分布均与呢？我们会想到取模,但是由于取模的消耗较大,HashMap是这样处理的：调用indexFor方法。

static int indexFor(int h, int length) {

        return h & (length - 1);
 }

HashMap的底层数组长度总是2的n次方,在构造函数中存在：capacity <<= 1;这样做总是能够保证HashMap的底层数组长度为2的n次方。当length为2的n次方时,h&(length - 1)就相当于对length取模,而且速度比直接取模快得多,这是HashMap在速度上的一个优化。

取数据

数据获取用的是get(key)的形式。

public V get(Object key) {
    
    if (key == null)
        return getForNullKey();
    Entry entry = getEntry(key);
    return null == entry ? null : entry.getValue();
}

private V getForNullKey() {
  if (size == 0) {
   return null;
 }
 for (HashMapEntry e = table[0]; e != null; e = e.next) {
   if (e.key == null)
    return e.value;
}
return null;
}

还有个比较重要的方法

final Entry getEntry (Object key) {
  if (size == 0) {
    return null;
  }
  int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
  for (HashMapEntry e = table[indexFor(hash, table.length)]; e != null;
    e = e.next) {
    Object k;
  if (e.hash == hash && ((k = e.key) == key || (key != null &&key.equals(k)))) 
    return e;
}
return null;
}

Entry是Map接口内的一个接口,他的作用就是包装一个map的节点,这个节封装了key,value,以及别的值（比如hashmap中的哈希码和next指针）,方便对Map的操作。

总结

由此看出,数据结构基础不好,看这个真费劲。明白是明白,但是真叫你一点点写出来,是想扑街的。

HashMap基于hashing原理，我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，然后找到bucket位置来储存值对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会储存在链表的下一个节点中。 HashMap在每个链表节点中储存键值对对象。
当两个不同的键对象的hashcode相同时会发生什么？ 它们会储存在同一个bucket位置的链表中。键对象的equals()方法用来找到键值对。
因为HashMap的好处非常多，我曾经在电子商务的应用中使用HashMap作为缓存。因为金融领域非常多的运用Java，也出于性能的考虑，我们会经常用到HashMap和ConcurrentHashMap。

尊重原创,借鉴：http://www.cnblogs.com/chenssy/p/3521565.html