码迷,mamicode.com
首页 > 编程语言 > 详细

Java之HashMap源码解析1

时间:2014-12-26 20:20:18      阅读:218      评论:0      收藏:0      [点我收藏+]

标签:java   java开发   集合   hashmap   源码   

讲解HashMap<K,V>时,我们先看看在API文档中是怎么介绍的:

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作,并允许使用 null 值和null 键。(除了非同步和允许使用 null 之外,HashMap 类与 Hashtable 大致相同。)此类不保证映射的顺序,特别是它不保证该顺序恒久不变。

此实现假定哈希函数将元素适当地分布在各桶之间,可为基本操作(get 和 put)提供稳定的性能。迭代collection 视图所需的时间与 HashMap 实例的“容量”(桶的数量)及其大小(键-值映射关系数)成比例。所以,如果迭代性能很重要,则不要将初始容量设置得太高(或将加载因子设置得太低)。

HashMap 的实例有两个参数影响其性能:初始容量 和加载因子。容量 是哈希表中桶的数量,初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时,则要对该哈希表进行 rehash 操作(即重建内部数据结构),从而哈希表将具有大约两倍的桶数。

通常,默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销,但同时也增加了查询成本(在大多数 HashMap 类的操作中,包括 get 和 put 操作,都反映了这一点)。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子,以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子,则不会发生rehash 操作。

如果很多映射关系要存储在 HashMap 实例中,则相对于按需执行自动的 rehash 操作以增大表的容量来说,使用足够大的初始容量创建它将使得映射关系能更有效地存储。

注意,此实现不是同步的。如果多个线程同时访问一个哈希映射,而其中至少一个线程从结构上修改了该映射,则它必须 保持外部同步。(结构上的修改是指添加或删除一个或多个映射关系的任何操作;仅改变与实例已经包含的键关联的值不是结构上的修改。)这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象,则应该使用Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作,以防止对映射进行意外的非同步访问,如下所示:

   Map m =Collections.synchronizedMap(new HashMap(...));

由所有此类的“collection 视图方法”所返回的迭代器都是快速失败的:在迭代器创建之后,如果从结构上对映射进行修改,除非通过迭代器本身的 remove 方法,其他任何时间任何方式的修改,迭代器都将抛出ConcurrentModificationException。因此,面对并发的修改,迭代器很快就会完全失败,而不冒在将来不确定的时间发生任意不确定行为的风险。

注意,迭代器的快速失败行为不能得到保证,一般来说,存在非同步的并发修改时,不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出ConcurrentModificationException。因此,编写依赖于此异常的程序的做法是错误的,正确做法是:迭代器的快速失败行为应该仅用于检测程序错误。


通过源码我们来看下HashMap的构造器:

<strong>public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
}
</strong>

分析:

this.loadFactor = DEFAULT_LOAD_FACTOR;

在这里指定了加载因子为DEFAULT_LOAD_FACTORDEFAULT_LOAD_FACTOR在源码中被定义成:

static final float DEFAULT_LOAD_FACTOR = 0.75f;

为什么加载因子被设置成0.75,API文档中标明了默认加载因子(.75) 在时间和空间成本上寻求一种折衷。至于为什么这样说,我也不是非常理解。网上一些解释是当加载因子过大时,造成冲突的机会会增加,过小时,会造成空间的浪费,在Hash表中,当我们put时如果产生冲突,也就是两个不同的对象,但它们的hashCode相同,出现了占用表中的同一个位置,在同一个位置空间中冲突的元素会通过一个链表保存起来,所以当我们get时,如果起冲突,就要访问链表,而频繁的访问链表会造成成本过高。


threshole=(int)(DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR);

我们设置临界值为DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR

DEFAULT_INITIAL_CAPACITY的值:

static final int DEFAULT_INITIAL_CAPACITY=16

也就是临界值为12,当实际大小超过这个值时,会进行扩容。


table = new Entry[DEFAULT_INITIAL_CAPACITY];

存储元素的实体数组,也就是HashMap就是一个Entry数组,Entry对象中包含了键和值,我们来看下Entry:

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
	    V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

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

        public final String toString() {
            return getKey() + "=" + getValue();
        }

        /**
         * This method is invoked whenever the value in an entry is
         * overwritten by an invocation of put(k,v) for a key k that's already
         * in the HashMap.
         */
        void recordAccess(HashMap<K,V> m) {
        }

        /**
         * This method is invoked whenever the entry is
         * removed from the table.
         */
        void recordRemoval(HashMap<K,V> m) {
        }
    }


看下Entry的构造函数:


Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
 }

其中h代表哈希值,k代表键,v代表值,n代表下一个节点。从上面我们还看到它实现了getKey(),getValue(),setValue(V value),equals(Object o),hashCode()这些函数,

看equals方法的实现:


public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }


首先判断是否是Map.Entry的一个实例,不是false,接着取出它们两的key和value进行判断,相同返回true,否则返回false.

 




转载请注明出处:http://blog.csdn.net/hai_qing_xu_kong/article/details/42176275 情绪控_




Java之HashMap源码解析1

标签:java   java开发   集合   hashmap   源码   

原文地址:http://blog.csdn.net/hai_qing_xu_kong/article/details/42176275

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!