HashMap详解

1.HashMap的使用:

(1) 插入键值对数据

public V put(K key, V value)

(2)根据键值获取键值对值数据

public V get(Object key)

(3)获取Map中键值对的个数

public int size()

(4)判断Map集合中是否包含键为key的键值对

public boolean containsKey(Object key)

(5)判断Map集合中是否包含值为value的键值对

boolean containsValue(Object value)

(6)判断Map集合中是否没有任何键值对

public boolean isEmpty()

(7)清空Map集合中所有的键值对

public void clear()

(8)根据键值删除Map中键值对

public V remove(Object key)

public static void main(String[] args) {
        // 声明HashMap对象
        Map<String,Integer> map= new HashMap<>();

        //添加数据
        map.put("ZhangYi",98);
        map.put("WangEr",99);
        map.put("ZhangShan",89);
        map.put("Lisi",92);

        //根据键值对键值获取数据‘’
        int value=map.get("Lisi");
        System.out.println("kay:Lisi And value:"+value);

        //获取Map中键值对的个数
        int size=map.size();
        System.out.println("map 中的键值对个数为:"+size);

        //判断Map集合中是否包含键为key的键值对
        boolean b1=map.containsKey("LiSI");
        boolean b2=map.containsKey("Lisi");
        System.out.println("是否包含键值为LiSI的键值对数据:"+b1);
        System.out.println("是否包含键值为Lisi的键值对数据:"+b2);

        //判断Map集合中是否包含值为value的键值对
        boolean b3=map.containsValue(99);
        boolean b4=map.containsValue(100);
        System.out.println("是否包含值为99的键值对数据:"+b3);
        System.out.println("是否包含值为100的键值对数据:"+b4);

        //判断Map集合中是否没有任何键值对

        boolean b5=map.isEmpty();
        System.out.println("map中键值对数据是否为空:"+b5);

        //根据键值删除Map中键值对
        int value2=map.remove("Lisi");
        System.out.println("删除了键为Lisi的键值对数据,其值为:"+value2);

        boolean b6=map.containsKey("Lisi");
        System.out.println("是否包含键值为Lisi的键值对数据:"+b6);

        //清空Map集合中所有的键值对
        map.clear();
        boolean b7=map.isEmpty();
        System.out.println("map中键值对数据是否为空:"+b7);

    }
}

运行结果:

kay:Lisi And value:92
map 中的键值对个数为:4
是否包含键值为LiSI的键值对数据:false
是否包含键值为Lisi的键值对数据:true
是否包含值为99的键值对数据:true
是否包含值为100的键值对数据:false
map中键值对数据是否为空:false
删除了键为Lisi的键值对数据,其值为:92
是否包含键值为Lisi的键值对数据:false
map中键值对数据是否为空:true

2.HashMap迭代器的使用:

HashMap遍历方式:

1)Key的遍历:

HashMap<Integer,String> map= new HashMap<>();

        //添加数据
        map.put(12,"ZhangYi");
        map.put(23,"WangEr");
        map.put(14,"ZhangShan");
        map.put(45,"Lisi");

for(Integer key:map.keySet()){
    System.out.print("key:"+ key);
    System.out.print("value:" +map.get(key));
}

2)value的遍历:

HashMap<Integer,String> map= new HashMap<>();

        //添加数据
        map.put(12,"ZhangYi");
        map.put(23,"WangEr");
        map.put(14,"ZhangShan");
        map.put(45,"Lisi");

for(String str: map.values()){
    //map中的key不可以重复,但是value可以重复
    System.out.print("value: " +str);
}

3)Entry的遍历:

HashMap<Integer,String> map= new HashMap<>();

        //添加数据
        map.put(12,"ZhangYi");
        map.put(23,"WangEr");
        map.put(14,"ZhangShan");
        map.put(45,"Lisi");

    //entrySet得到当前HashMap中节点的集合
for(Map.Entry<Integer,String> entry: map.entrySet()){
    System.out.println("key: " +entry.getKey()+"value: "+entry.getValue());
}

4)Interator遍历:

HashMap<Integer,String> map= new HashMap<>();

        //添加数据
        map.put(12,"ZhangYi");
        map.put(23,"WangEr");
        map.put(14,"ZhangShan");
        map.put(45,"Lisi");

Iterator<Map.Entry<Integer,String>> itr = map.entrySet().iterator();
while(itr.hasNext()){
    Map.Entry<Integer,String> entry = itr.next();
    System.out.println("key: "+entry.getKey()+"value: "+entry.getValue());
}

3.HashMap的底层源码实现:

3.1.HashMap中put()方法:

 public V put(K key, V value) {
        /**四个参数,第一个hash值,第四个参数表示如果该key存在值,如果为null的话,则插入新的value,最后一个参数,在hashMap中没有用,可以不用管,使用默认的即可**/
        return putVal(hash(key), key, value, false, true);
    }
 
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //tab 哈希数组,p 该哈希桶的首节点,n hashMap的长度,i 计算出的数组下标
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //获取长度并进行扩容,使用的是懒加载,table一开始是没有加载的,等put后才开始加载
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**如果计算出的该哈希桶的位置没有值,则把新插入的key-value放到此处,此处就算没有插入成功,也就是发生哈希冲突时也会把哈希桶的首节点赋予p**/
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //发生哈希冲突的几种情况
        else {
            // e 临时节点的作用, k 存放该当前节点的key 
            Node<K,V> e; K k;
            //第一种,插入的key-value的hash值,key都与当前节点的相等,e = p,则表示为首节点
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //第二种,hash值不等于首节点,判断该p是否属于红黑树的节点
            else if (p instanceof TreeNode)
                /**为红黑树的节点,则在红黑树中进行添加,如果该节点已经存在,则返回该节点(不为null),该值很重要,用来判断put操作是否成功,如果添加成功返回null**/
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //第三种,hash值不等于首节点,不为红黑树的节点,则为链表的节点
            else {
                //遍历该链表
                for (int binCount = 0; ; ++binCount) {
                    //如果找到尾部,则表明添加的key-value没有重复,在尾部进行添加
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //判断是否要转换为红黑树结构
                        if (binCount >= TREEIFY_THRESHOLD - 1) 
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果链表中有重复的key,e则为当前重复的节点,结束循环
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //有重复的key,则用待插入值进行覆盖,返回旧值。
            if (e != null) { 
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //到了此步骤,则表明待插入的key-value是没有key的重复,因为插入成功e节点的值为null
        //修改次数+1
        ++modCount;
        //实际长度+1,判断是否大于临界值,大于则扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        //添加成功
        return null;
    }

3.2.HashMap之resize()方法

当插入数据时哈希表过于拥挤,即size>threshold 或者table == null时,会触发一次resize扩容操作。扩容时,我们的内部数组扩容了2倍,所以对于每一个插槽内的元素在 rehash时存在两种可能:
1.依然映射到当前下标插槽处
2.映射到高位下标处(当前下标 + 扩容前内部数组长度大小)

final Node<K,V>[] resize() {
//oldTab指向hash桶数组
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
//如果oldCap不为空,即hash桶数组不为空
    if (oldCap > 0) {
//判断oldCap是否大于最大容量,如果大于最大容量了,就赋值为整数的最大值
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
//直接返回
            return oldTab;
        }
//如果当前hash桶数组的长度在扩容后仍然小于最大容量,这里扩容指的是以2倍的方式扩容,并且oldCap大于默认值16
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
//双倍扩容阀值
            newThr = oldThr << 1; // double threshold
    }
//反之,oldCap小于等于0,但是oldThr大于0
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
//oldCap小于等于0,oldThr小于等于0
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})

//新建hash数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//使得旧数组的引用指向新数组
    table = newTab;
//进行扩容操作,即复制节点对象到新的hash桶数组中
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
//如果旧数组在j位置不为空,将该节点赋值给e
            if ((e = oldTab[j]) != null) {
//将旧数组中j位置设置为空,方便gc
                oldTab[j] = null;
//如果e后面没有节点
                if (e.next == null)
//直接对e的hash值按位与新数组的长度得到index位置,将e节点放置该位置
                    newTab[e.hash & (newCap - 1)] = e;
//如果e为红黑树的节点类型,那么添加到红黑树中
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//反之e为链表的节点类型,并且e.next != null
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
//将当前节点的next赋值给next引用
                        next = e.next;
//如果节点e的hash值与原hash桶数组的长度按位与为0
//若与原容量按位与,结果为0,表示将这个节点放入新数组中,位置不变
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
//如果节点e的hash值与原hash桶数组的长度按位与不为0
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
//如果loTail不为空
                    if (loTail != null) {
//将loTail.next设置为空
                        loTail.next = null;
//将loHead赋值给新的hash桶数组j位置
                        newTab[j] = loHead;
                    }
//如果hiTail不为空
                    if (hiTail != null) {
//将hiTail.next设置为空
                        hiTail.next = null;
//将hiHead赋值给新的hash桶数组[j+旧hash桶数组的长度]
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

3.3.HashMap之get(Object key)方法

public V get(Object key) {
    Node<K,V> e;
//getNode得到该key所对应的节点e,节点为null则返回null,反之返回e.value
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//判断当前table(桶)不能为空,即桶中存在节点,并且当前key-》index不为空,即该位置存在节点
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
//判断该位置的第一个节点(first),如果first.hash等于该key所对应的散列码,first.key等于该key,则直接返回first
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
//判断当前first.next后是否存在其他节点,如果存在即first.next != null
        if ((e = first.next) != null) {
//判断该first节点是否是红黑树节点,如果是,则调用红黑树中getTreeNode方法
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//do-while循环特点是先执行循环体,再判断条件是否满足
//e为当前节点,如果e.hash等于key所对应的散列码,e.key等于该key,则直接返回e
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

3.4.HashMap之remove(Object key)方法

public V remove(Object key) {
    Node<K,V> e;
//remove删除该key所对应的节点e,节点为null则返回null,反之返回e.value
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
//判断当前table(桶)不能为空,即桶中存在节点,并且当前key-》index不为空,即该位置存在节点
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
//p为该位置的第一个节点,如果p.hash等于该key所对应的散列码,p.key等于该key,则p为目标节点,赋值给node引用
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
//判断当前p.next后是否存在其他节点,如果存在即p.next != null
        else if ((e = p.next) != null) {
//判断该p节点是否是红黑树节点,如果是,则调用红黑树中getTreeNode方法得到该节点,赋值给node引用
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
//反之为链表节点,在该链表中查找到该节点,赋值给node引用
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
//判断该node节点是否是红黑树节点,如果是则调用红黑树中的removeTreeNode方法
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果node == p, 说明目标删除节点为第一个节点
            else if (node == p)
                tab[index] = node.next;
//反之,p为目标删除节点的前一个节点,node为目标删除节点,p.next = node.next
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}


4.HashMap迭代器实现:

abstract class HashIterator {
//要返回的下一个节点
    Node<K,V> next;        // next entry to return
//当前节点
    Node<K,V> current;     // current entry
//期望的结构性修改次数
    int expectedModCount;  // for fast-fail
//索引位置
    int index;             // current slot

//HashIterator构造器
    HashIterator() {
//期望的结构性修改次数赋值
        expectedModCount = modCount;
//当前HashMap中table赋值给t
        Node<K,V>[] t = table;
        current = next = null;
        index = 0;
//查找当前哈希表中第一个非空的数据节点赋值给next
        if (t != null && size > 0) { // advance to first entry
            do {} while (index < t.length && (next = t[index++]) == null);
        }
    }

//判断当前迭代器是否含有下一个可迭代的元素
    public final boolean hasNext() {
        return next != null;
    }

//返回当前可迭代器的下一个元素
    final Node<K,V> nextNode() {
        Node<K,V>[] t;
//next保存当前可迭代的下一个元素,将next赋值给e
        Node<K,V> e = next;
//不相等,说明在迭代器迭代的过程中HashMap结构发生变化,则抛出异常
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
//当前下一个可迭代元素不为空并且table也不为空
        if ((next = (current = e).next) == null && (t = table) != null) {
//查找当前哈希表中下一个非空的数据节点赋值给next

            do {} while (index < t.length && (next = t[index++]) == null);
        }
//返回结果
        return e;
    }

    public final void remove() {
//current节点为上一次next返回的节点
        Node<K,V> p = current;
        if (p == null)
            throw new IllegalStateException();
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        current = null;
        K key = p.key;
//调用HashMap中removeNode(hash, key, value, mathchValue, movable)删除当前key所在节点;
        removeNode(hash(key), key, null, false, false);
//更新expectedModCount为最新值
        expectedModCount = modCount;
    }
}

5.HashMap与HashTable之间的区别与联系:

HashMap与HashTable之间的区别

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值