精华内容
下载资源
问答
  • HashMap底层实现

    2020-09-02 16:20:26
    HashMap底层实现 在JDK1.8之前,HashMap的底层是数组加链表组成,也就是散列链表。HashMap通过key的HashCode经过扰动函数处理后得到hash值,这个扰动函数就是HashMap中的hash()函数,然后通过(n-1)&hash判断当前...

    HashMap底层实现

    在JDK1.8之前,HashMap的底层是数组加链表组成,也就是散列链表。HashMap通过key的HashCode经过扰动函数处理后得到hash值,这个扰动函数就是HashMap中的hash()函数,然后通过(n-1)&hash判断当前元素存放的位置(这个n指的是数组长度),如果当前元素的key和hash值与已经存放的元素的key以及hash值相同,则直接覆盖原来的元素,否则通过拉链法解决。
    所谓的“拉链法”,就是链表与数组的结合,也就是说创建一个数组链表,若遇到哈希冲突,则放入链表中。
    在这里插入图片描述
    在JDK1.8之后,在解决哈希冲突时有了比较大的变化,当链表长度大于某个阈值时(默认为8),将链表转换为红黑树,来缩短搜索时间。
    TreeMap、TreeSet以及JDK1.8之后的HashMap底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷,因为二叉查找树在某些情况下会退化成一个线性结构。

    展开全文
  • HashMap底层实现和原理(源码解析)

    万次阅读 多人点赞 2019-06-15 10:14:34
    Note:文章的内容基于JDK1.7进行分析,1.8做的改动文章末尾进行...HashMap基于Map接口实现,元素以键值对的方式存储,并且允许使用null 建和null 值, 因为key不允许重复,因此只能有一个键为null,另外HashMap不...

    Note:文章的内容基于JDK1.7进行分析,1.8做的改动文章末尾进行讲解。

    大家可以看一下:https://www.imooc.com/article/267756

    一、先来熟悉一下我们常用的HashMap

    1、概述

    HashMap基于Map接口实现,元素以键值对的方式存储,并且允许使用null 建和null 值, 因为key不允许重复,因此只能有一个键为null,另外HashMap不能保证放入元素的顺序,它是无序的,和放入的顺序并不能相同。HashMap是线程不安全的。

    2、继承关系

    public class HashMap<K,V>extends AbstractMap<K,V>
        implements Map<K,V>, Cloneable, Serializable
     

    3、基本属性

    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默认初始化大小 16 
    static final float DEFAULT_LOAD_FACTOR = 0.75f;     //负载因子0.75
    static final Entry<?,?>[] EMPTY_TABLE = {};         //初始化的默认数组
    transient int size;     //HashMap中元素的数量
    int threshold;          //判断是否需要调整HashMap的容量  

    Note:HashMap的扩容操作是一项很耗时的任务,所以如果能估算Map的容量,最好给它一个默认初始值,避免进行多次扩容。HashMap的线程是不安全的,多线程环境中推荐是ConcurrentHashMap。

    二、常被问到的HashMap和Hashtable的区别

    1、线程安全

    两者最主要的区别在于Hashtable是线程安全,而HashMap则非线程安全。

    Hashtable的实现方法里面都添加了synchronized关键字来确保线程同步,因此相对而言HashMap性能会高一些,我们平时使用时若无特殊需求建议使用HashMap,在多线程环境下若使用HashMap需要使用Collections.synchronizedMap()方法来获取一个线程安全的集合。

    Note:

    Collections.synchronizedMap()实现原理是Collections定义了一个SynchronizedMap的内部类,这个类实现了Map接口,在调用方法时使用synchronized来保证线程同步,当然了实际上操作的还是我们传入的HashMap实例,简单的说就是Collections.synchronizedMap()方法帮我们在操作HashMap时自动添加了synchronized来实现线程同步,类似的其它Collections.synchronizedXX方法也是类似原理。

    2、针对null的不同

    HashMap可以使用null作为key,而Hashtable则不允许null作为key
    虽说HashMap支持null值作为key,不过建议还是尽量避免这样使用,因为一旦不小心使用了,若因此引发一些问题,排查起来很是费事。
    Note:HashMap以null作为key时,总是存储在table数组的第一个节点上。

    3、继承结构

    HashMap是对Map接口的实现,HashTable实现了Map接口和Dictionary抽象类。

    4、初始容量与扩容

    HashMap的初始容量为16,Hashtable初始容量为11,两者的填充因子默认都是0.75。

    HashMap扩容时是当前容量翻倍即:capacity*2,Hashtable扩容时是容量翻倍+1即:capacity*2+1。

    5、两者计算hash的方法不同

    Hashtable计算hash是直接使用key的hashcode对table数组的长度直接进行取模

    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;

    HashMap计算hash对key的hashcode进行了二次hash,以获得更好的散列值,然后对table数组长度取摸。

    int hash = hash(key.hashCode());
    int i = indexFor(hash, table.length);
    
    static int hash(int h) {
            // This function ensures that hashCodes that differ only by
            // constant multiples at each bit position have a bounded
            // number of collisions (approximately 8 at default load factor).
            h ^= (h >>> 20) ^ (h >>> 12);
            return h ^ (h >>> 7) ^ (h >>> 4);
        }
     
     static int indexFor(int h, int length) {
            return h & (length-1);

    三、HashMap的数据存储结构

    1、HashMap由数组和链表来实现对数据的存储

    HashMap采用Entry数组来存储key-value对,每一个键值对组成了一个Entry实体,Entry类实际上是一个单向的链表结构,它具有Next指针,可以连接下一个Entry实体,以此来解决Hash冲突的问题。

    数组存储区间是连续的,占用内存严重,故空间复杂的很大。但数组的二分查找时间复杂度小,为O(1);数组的特点是:寻址容易,插入和删除困难;

    链表存储区间离散,占用内存比较宽松,故空间复杂度很小,但时间复杂度很大,达O(N)。链表的特点是:寻址困难,插入和删除容易。

     

     

     

    从上图我们可以发现数据结构由数组+链表组成,一个长度为16的数组中,每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key.hashCode())%len获得,也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中,12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。

    HashMap里面实现一个静态内部类Entry,其重要的属性有 hash,key,value,next。

    HashMap里面用到链式数据结构的一个概念。上面我们提到过Entry类里面有一个next属性,作用是指向下一个Entry。打个比方, 第一个键值对A进来,通过计算其key的hash得到的index=0,记做:Entry[0] = A。一会后又进来一个键值对B,通过计算其index也等于0,现在怎么办?HashMap会这样做:B.next = A,Entry[0] = B,如果又进来C,index也等于0,那么C.next = B,Entry[0] = C;这样我们发现index=0的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起。所以疑问不用担心。也就是说数组中存储的是最后插入的元素。到这里为止,HashMap的大致实现,我们应该已经清楚了。

     public V put(K key, V value) {
            if (key == null)
                return putForNullKey(value); //null总是放在数组的第一个链表中
            int hash = hash(key.hashCode());
            int i = indexFor(hash, table.length);
            //遍历链表
            for (Entry<K,V> e = table[i]; e != null; e = e.next) {
                Object k;
                //如果key在链表中已存在,则替换为新value
                if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                    V oldValue = e.value;
                    e.value = value;
                    e.recordAccess(this);
                    return oldValue;
                }
            }
     
            modCount++;
            addEntry(hash, key, value, i);
            return null;
        }
    
     
    
    void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e); //参数e, 是Entry.next
        //如果size超过threshold,则扩充table大小。再散列
        if (size++ >= threshold)
                resize(2 * table.length);
    }

    四、重要方法深度解析

    1、构造方法

    HashMap()    //无参构造方法
    HashMap(int initialCapacity)  //指定初始容量的构造方法 
    HashMap(int initialCapacity, float loadFactor) //指定初始容量和负载因子
    HashMap(Map<? extends K,? extends V> m)  //指定集合,转化为HashMap

    HashMap提供了四个构造方法,构造方法中 ,依靠第三个方法来执行的,但是前三个方法都没有进行数组的初始化操作,即使调用了构造方法此时存放HaspMap中数组元素的table表长度依旧为0 。在第四个构造方法中调用了inflateTable()方法完成了table的初始化操作,并将m中的元素添加到HashMap中。

    2、添加方法

    public V put(K key, V value) {
            if (table == EMPTY_TABLE) { //是否初始化
                inflateTable(threshold);
            }
            if (key == null) //放置在0号位置
                return putForNullKey(value);
            int hash = hash(key); //计算hash值
            int i = indexFor(hash, table.length);  //计算在Entry[]中的存储位置
            for (Entry<K,V> e = table[i]; e != null; e = e.next) {
                Object k;
                if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                    V oldValue = e.value;
                    e.value = value;
                    e.recordAccess(this);
                    return oldValue;
                }
            }
    
            modCount++;
            addEntry(hash, key, value, i); //添加到Map中
            return null;
    }

    在该方法中,添加键值对时,首先进行table是否初始化的判断,如果没有进行初始化(分配空间,Entry[]数组的长度)。然后进行key是否为null的判断,如果key==null ,放置在Entry[]的0号位置。计算在Entry[]数组的存储位置,判断该位置上是否已有元素,如果已经有元素存在,则遍历该Entry[]数组位置上的单链表。判断key是否存在,如果key已经存在,则用新的value值,替换点旧的value值,并将旧的value值返回。如果key不存在于HashMap中,程序继续向下执行。将key-vlaue, 生成Entry实体,添加到HashMap中的Entry[]数组中。

    3、addEntry()

    /*
     * hash hash值
     * key 键值
     * value value值
     * bucketIndex Entry[]数组中的存储索引
     * / 
    void addEntry(int hash, K key, V value, int bucketIndex) {
         if ((size >= threshold) && (null != table[bucketIndex])) {
             resize(2 * table.length); //扩容操作,将数据元素重新计算位置后放入newTable中,链表的顺序与之前的顺序相反
             hash = (null != key) ? hash(key) : 0;
             bucketIndex = indexFor(hash, table.length);
         }
    
        createEntry(hash, key, value, bucketIndex);
    }
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

    添加到方法的具体操作,在添加之前先进行容量的判断,如果当前容量达到了阈值,并且需要存储到Entry[]数组中,先进性扩容操作,空充的容量为table长度的2倍。重新计算hash值,和数组存储的位置,扩容后的链表顺序与扩容前的链表顺序相反。然后将新添加的Entry实体存放到当前Entry[]位置链表的头部。在1.8之前,新插入的元素都是放在了链表的头部位置,但是这种操作在高并发的环境下容易导致死锁,所以1.8之后,新插入的元素都放在了链表的尾部。

    4、获取方法:get

    public V get(Object key) {
         if (key == null)
             //返回table[0] 的value值
             return getForNullKey();
         Entry<K,V> entry = getEntry(key);
    
         return null == entry ? null : entry.getValue();
    }
    final Entry<K,V> getEntry(Object key) {
         if (size == 0) {
             return null;
         }
    
         int hash = (key == null) ? 0 : hash(key);
         for (Entry<K,V> 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;
    }

    在get方法中,首先计算hash值,然后调用indexFor()方法得到该key在table中的存储位置,得到该位置的单链表,遍历列表找到key和指定key内容相等的Entry,返回entry.value值。

    5、删除方法

    public V remove(Object key) {
         Entry<K,V> e = removeEntryForKey(key);
         return (e == null ? null : e.value);
    }
    final Entry<K,V> removeEntryForKey(Object key) {
         if (size == 0) {
             return null;
         }
         int hash = (key == null) ? 0 : hash(key);
         int i = indexFor(hash, table.length);
         Entry<K,V> prev = table[i];
         Entry<K,V> e = prev;
    
         while (e != null) {
             Entry<K,V> next = e.next;
             Object k;
             if (e.hash == hash &&
                 ((k = e.key) == key || (key != null && key.equals(k)))) {
                 modCount++;
                 size--;
                 if (prev == e)
                     table[i] = next;
                 else
                     prev.next = next;
                 e.recordRemoval(this);
                 return e;
             }
             prev = e;
             e = next;
        }
    
        return e;
    }

    删除操作,先计算指定key的hash值,然后计算出table中的存储位置,判断当前位置是否Entry实体存在,如果没有直接返回,若当前位置有Entry实体存在,则开始遍历列表。定义了三个Entry引用,分别为pre, e ,next。 在循环遍历的过程中,首先判断pre 和 e 是否相等,若相等表明,table的当前位置只有一个元素,直接将table[i] = next = null 。若形成了pre -> e -> next 的连接关系,判断e的key是否和指定的key 相等,若相等则让pre -> next ,e 失去引用。

    6、containsKey

    public boolean containsKey(Object key) {
            return getEntry(key) != null;
        }
    final Entry<K,V> getEntry(Object key) {
            int hash = (key == null) ? 0 : hash(key.hashCode());
            for (Entry<K,V> 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;
        }

    containsKey方法是先计算hash然后使用hash和table.length取摸得到index值,遍历table[index]元素查找是否包含key相同的值。

    7、containsValue

    public boolean containsValue(Object value) {
        if (value == null)
                return containsNullValue();
    
        Entry[] tab = table;
            for (int i = 0; i < tab.length ; i++)
                for (Entry e = tab[i] ; e != null ; e = e.next)
                    if (value.equals(e.value))
                        return true;
        return false;
        }

    containsValue方法就比较粗暴了,就是直接遍历所有元素直到找到value,由此可见HashMap的containsValue方法本质上和普通数组和list的contains方法没什么区别,你别指望它会像containsKey那么高效。

    五、JDK 1.8的 改变

    1、HashMap采用数组+链表+红黑树实现。

    在Jdk1.8中HashMap的实现方式做了一些改变,但是基本思想还是没有变得,只是在一些地方做了优化,下面来看一下这些改变的地方,数据结构的存储由数组+链表的方式,变化为数组+链表+红黑树的存储方式,当链表长度超过阈值(8)时,将链表转换为红黑树。在性能上进一步得到提升。

    2、put方法简单解析:

    public V put(K key, V value) {
        //调用putVal()方法完成
        return putVal(hash(key), key, value, false, true);
    }
    
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //判断table是否初始化,否则初始化操作
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //计算存储的索引位置,如果没有元素,直接赋值
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //节点若已经存在,执行赋值操作
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //判断链表是否是红黑树
            else if (p instanceof TreeNode)
                //红黑树对象操作
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //为链表,
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //链表长度8,将链表转化为红黑树存储
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //key存在,直接覆盖
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //记录修改次数
        ++modCount;
        //判断是否需要扩容
        if (++size > threshold)
            resize();
        //空操作
        afterNodeInsertion(evict);
        return null;
    }

    如果存在key节点,返回旧值,如果不存在则返回Null。

    展开全文
  • HashMap底层实现原理解析

    万次阅读 多人点赞 2020-12-18 10:37:27
    一:HashMap底层实现原理解析 我们常见的有数据结构有三种结构:1、数组结构 2、链表结构 3、哈希表结构 下面我们来看看各自的数据结构的特点: 1、数组结构: 存储区间连续、内存占用严重、空间复杂度大 优点:...

    一:HashMap底层实现原理解析

    我们常见的有数据结构有三种结构:1、数组结构 2、链表结构 3、哈希表结构 下面我们来看看各自的数据结构的特点:
    1、数组结构: 存储区间连续、内存占用严重、空间复杂度大

    • 优点:随机读取和修改效率高,原因是数组是连续的(随机访问性强,查找速度快)
    • 缺点:插入和删除数据效率低,因插入数据,这个位置后面的数据在内存中都要往后移动,且大小固定不易动态扩展。

    2、链表结构:存储区间离散、占用内存宽松、空间复杂度小

    • 优点:插入删除速度快,内存利用率高,没有固定大小,扩展灵活
    • 缺点:不能随机查找,每次都是从第一个开始遍历(查询效率低)

    3、哈希表结构:结合数组结构和链表结构的优点,从而实现了查询和修改效率高,插入和删除效率也高的一种数据结构
    常见的HashMap就是这样的一种数据结构
    在这里插入图片描述

    HashMap中的put()和get()的实现原理

    • 1、map.put(k,v)实现原理
      (1)首先将k,v封装到Node对象当中(节点)。
      (2)然后它的底层会调用K的hashCode()方法得出hash值。
      (3)通过哈希表函数/哈希算法,将hash值转换成数组的下标,下标位置上如果没有任何元素,就把Node添加到这个位置上。如果说下标对应的位置上有链表。此时,就会拿着k和链表上每个节点的k进行equal。如果所有的equals方法返回都是false,那么这个新的节点将被添加到链表的末尾。如其中有一个equals返回了true,那么这个节点的value将会被覆盖。
    • 2、map.get(k)实现原理
      (1)先调用k的hashCode()方法得出哈希值,并通过哈希算法转换成数组的下标。
      (2)通过上一步哈希算法转换成数组的下标之后,在通过数组下标快速定位到某个位置上。如果这个位置上什么都没有,则返回null。如果这个位置上有单向链表,那么它就会拿着K和单向链表上的每一个节点的K进行equals,如果所有equals方法都返回false,则get方法返回null。如果其中一个节点的K和参数K进行equals返回true,那么此时该节点的value就是我们要找的value了,get方法最终返回这个要找的value。

    为何随机增删、查询效率都很高的原因是?
    原因: 增删是在链表上完成的,而查询只需扫描部分,则效率高。

    HashMap集合的key,会先后调用两个方法,hashCode and equals方法,这这两个方法都需要重写。

    为什么放在hashMap集合key部分的元素需要重写equals方法?
    因为equals方法默认比较的是两个对象的内存地址

    二:HashMap红黑树原理分析

    相比 jdk1.7 的 HashMap 而言,jdk1.8最重要的就是引入了红黑树的设计,当hash表的单一链表长度超过 8 个的时候,链表结构就会转为红黑树结构。
    为什么要这样设计呢?好处就是避免在最极端的情况下链表变得很长很长,在查询的时候,效率会非常慢。
    在这里插入图片描述

    • 红黑树查询:其访问性能近似于折半查找,时间复杂度 O(logn);
    • 链表查询:这种情况下,需要遍历全部元素才行,时间复杂度 O(n);

    简单的说,红黑树是一种近似平衡的二叉查找树,其主要的优点就是“平衡“,即左右子树高度几乎一致,以此来防止树退化为链表,通过这种方式来保障查找的时间复杂度为 log(n)。
    在这里插入图片描述
    关于红黑树的内容,网上给出的内容非常多,主要有以下几个特性:

    • 1、每个节点要么是红色,要么是黑色,但根节点永远是黑色的;

    • 2、每个红色节点的两个子节点一定都是黑色;

    • 3、红色节点不能连续(也即是,红色节点的孩子和父亲都不能是红色);

    • 4、从任一节点到其子树中每个叶子节点的路径都包含相同数量的黑色节点;

    • 5、所有的叶节点都是是黑色的(注意这里说叶子节点其实是上图中的 NIL 节点);

    在树的结构发生改变时(插入或者删除操作),往往会破坏上述条件 3 或条件 4,需要通过调整使得查找树重新满足红黑树的条件。

    展开全文
  • hashMap底层实现

    2020-03-04 15:03:01
    1 hashmap的数据结构是什么样子的? jdk 1.8 新加的内容 当链表长度大于8之后(在数组长度大于64的前提下),链表就会转换为红黑树了。 2 put方法怎么实现的? 3 扩容机制是什么?【jdk 1.7的代码,1.8的...

    1 hashmap的数据结构是什么样子的?

    jdk 1.8 新加的内容

    • 当链表长度大于8之后(在数组长度大于64的前提下),链表就会转换为红黑树了。

    2 put方法怎么实现的?

    3 扩容机制是什么?【jdk 1.7的代码,1.8的加入了红黑树,代码比较难看】

    4 为什么扩容大小为2的幂次方?

    查找快:将Key值进行Hash后得到Hash值,Hash值得范围大概40亿,很明显,内存存不下,进行转换,对数组的长度(即hashmap的长度)进行取模运算,得到的余数才用来做要存放的位置(即对应的数组下标)。[这也解释了HashMap的长度为什么是2的幂次方,为了提高取模运算的效率]。

    分散均匀:

    HashMap 采用这种非常规设计,主要是为了在取模和扩容时做优化,同时为了减少hash碰撞,HashMap 定位哈希桶索引位置时,也加入了高位参与运算的过程。
    
    长度16或者其他2的幂,Length-1的值是所有二进制位全为1,这种情况下,index的结果等同于HashCode后几位的值。只要输入的HashCode本身分布均匀,Hash算法的结果就是均匀的。
    
    如果不为16或者2的幂,那么,经过hash算法之后,有些index结果出现的概率会更大,而有些index则永远步会出现。即不符合hash算法的j均匀分布的原则。

    5 什么是负载因子,为什么默认值是0.75?

    负载因子表示的是一个散列表的空间使用程度。

    源码里对负载因子有一段解释,大概意思就是:在理想情况下,使用随机哈希吗,节点出现的频率在hash桶中遵循泊松分布,同时给出了桶中元素的个数和概率的对照表。
    
    从上表可以看出当桶中元素到达8个的时候,概率已经变得非常小,也就是说用0.75作为负载因子,每个碰撞位置的链表长度超过8个是几乎不可能的。
    hash容器指定初始容量尽量为2的幂次方。
    HashMap负载因子为0.75是空间和时间成本的一种折中。

    6 如何解决 hash 冲突的?

    拉链法

    7 是不是线程安全的?

    • HashMap不是线程安全的,在多线程并发的环境下,可能会产生死锁等问题。
    • 补充一点 Hashtable 是线程安全的。还有并发的 HashMap :ConcurrentHashMap(java5引入的)。

    8 hashmap 与 hashtable 的与别是什么?

    1. HashMap线程不安全,是非synchronized的,Hashtable是线程安全的。
    
    2. HashMap可以接受null(HashMap可以接受为null的键值(key)和值(value)),而Hashtable则不行。
    
    3. 是HashMap的迭代器(Iterator)是fail-fast迭代器,而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构(增加或者移除元素),将会抛出ConcurrentModificationException,但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为,要看JVM。这条同样也是Enumeration和Iterator的区别。
    
    4. 由于Hashtable是线程安全的也是synchronized,所以在单线程环境下它比HashMap要慢。如果你不需要同步,只需要单一线程,那么使用HashMap性能要好过Hashtable。
    
    5. HashMap不能保证随着时间的推移Map中的元素次序是不变的。
    
    6. 继承的父类不同、作者不同,产生时间不同。HashMap是继承自AbstractMap类,而HashTable是继承自Dictionary类。不过它们都实现了同时实现了Map、Cloneable(可复制)、Serializable(可序列化)这三个接口
    
    7. 初始容量大小和每次扩充容量大小的不同。Hashtable默认的初始大小为11,之后每次扩充,容量变为原来的2n+1。HashMap默认的初始化大小为16。之后每次扩充,容量变为原来的2倍。
    
    8. 计算hash值的方法不同。为了得到元素的位置,首先需要根据元素的Key计算出一个hash值,然后再用这个hash值来计算得到最终的位置。Hashtable直接使用对象的hashCode。然后再使用取余来获得最终的位置,比较耗时。HashMap是通过位运算来进行操作的,效率高。
        下面是 Hashtable 的确定索引方法:
            int hash = key.hashCode();
            int index = (hash & 0x7FFFFFFF) % tab.length;

    9 为什么不一下子把链表转化成红黑树?

    1. 构造红黑树要比构造链表复杂,在链表的节点不多的时候,从整体的性能看来, 数组+链表+红黑树的结构可能不一定比数组+链表的结构性能高。
    
    2. HashMap 频繁的扩容,会造成底部红黑树不断的进行拆分和重组,这是非常耗时的。因此,也就是链表长度比较长的时候转变成红黑树才会显著提高效率。

    展开全文
  • HashMap底层实现原理及面试问题

    万次阅读 多人点赞 2018-08-29 11:00:56
    HashMap的工作原理 HashMap基于hashing原理,我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时,它调用键对象的hashCode()方法来计算hashcode,让后找到bucket位置来储存值对象。当获取...
  • hashmap底层实现

    2017-04-26 13:26:09
    1. HashMap概述: HashMap是基于哈希表的Map接口的非同步实现(Hashtable跟HashMap很像,唯一的区别是Hashtalbe中的方法是线程安全的,也就是同步的)。此实现提供所有可选的映射操作,并允许使用null值和null键。...
  • HashMap底层实现原理详解

    万次阅读 多人点赞 2021-02-13 22:41:16
    文章目录前言一、快速入门二、使用步骤1.引入库2.读入数据总结学习内容:学习时间:学习产出:前言一、pandas是什么?二、使用步骤1.引入库2....随着JDK版本的跟新,JDK1.8对HashMap底层实现进行
  • HashMap底层实现原理

    万次阅读 多人点赞 2019-04-24 13:57:56
    HashMap底层实现原理 HashMap是Java语言中用的最频繁的一种数据结构。 1.hashmap的数据结构 要了解hashmap首先要弄清楚他的结构。在java编程语言中最基本的数据结构有两种,数组和链表。 数组:查询速度快,可以根据...
  • HashMap底层实现详解

    2019-08-20 09:14:34
    HashMap底层实现详解前言Java中的hashCode和equals关于hashCode关于equalsHashMap的实现原理Hashmap基本结构讲解存储数据过程put(key,value)HashMap的resize取数据过程get(key)扩容问题 前言 HashMap底层实现采用了...
  • HashSet与HashMap底层实现1.HashSet底层是基于HashMap实现的2.HashMap的底层实现原理2.1HashMap的介绍2.2HashMap的底层是什么 1.HashSet底层是基于HashMap实现的 public class HashSet<E> extends ...
  • hashmap 底层实现原理

    2021-03-04 11:06:45
    Java HashMap底层实现原理 HashMap底层是哈希表(散列表),哈希就是一个数组,数组的每个元素是一个单向链表。 ● 在第一次执行put方法时,给哈希表的数组(哈希桶)默认初始化,容量: 16 ● hashMap加载因子是0.75 ● ...
  • 【JAVA】HashMap底层实现原理浅谈

    万次阅读 多人点赞 2018-10-07 17:28:35
    HashMap底层实现原理浅谈 不论是实习还是正式工作,HashMap的底层实现原理一直是问地频率最高的一个内容,今天记录一下自己对HashMap的理解,如有不当之处,还请各位大佬指正。 一、前置名词解释 (1)哈希表 ...
  • hashmap底层实现原理

    2021-04-11 16:02:29
    hashmap底层实现原理 k=key; v=value; hashcode和equals方法在Object类中默认是内存地址需要重写 哈希表在链表中完成增删,查询只需扫描部分,效率高 一.put(k,v)实现原理 将(k,v)封装到Node对象当中。 它的底层...
  • Java HashMap底层实现

    2018-10-26 21:26:43
    Java HashMap底层实现 HashMap的底层物理结构: Entry 数组 JDK1.7 数组+链表 JDK1.8 数组+链表/红黑树 Hash table–散列表的原理 在数组中根据下标查找某个元素,一次定位就可以达到,哈希表利用了这种...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,162
精华内容 3,264
关键字:

hashmap底层实现