Java中HashMap的学习

已于 2024-03-07 11:52:31 修改
阅读量337 收藏 7
点赞数 9
分类专栏： Java 文章标签： java 学习
于 2024-03-02 09:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44877172/article/details/136391084
版权

简介

在Java中，Map接口是一个非常重要的接口，它定义了将键映射到值的关系。Map接口位于java.util包中，并提供了一种将键（key）映射到值（value）的方式。键和值可以是任何对象，并且每个键在Map中必须是唯一的。

Map接口的主要实现类包括HashMap、LinkedHashMap、TreeMap等。

Map接口定义了一些重要的方法，包括：

  • put(K key, V value): 将指定的值与此映射中的指定键相关联（可选操作）。
  • get(Object key): 返回映射中与此键关联的值；如果映射不包含此键的映射关系，则返回null。
  • remove(Object key): 如果此映射包含指定键的映射关系，则将其删除。
  • containsKey(Object key): 如果此映射包含指定键的映射关系，则返回true。
  • containsValue(Object value): 如果此映射将一个或多个键映射到指定值，则返回true。
  • putAll(Map<? extends K, ? extends V> m): 将指定映射中的所有映射关系复制到此映射中（可选操作）。
  • clear(): 从此映射中移除所有映射关系（可选操作）。
  • keySet(): 返回此映射中包含的键的Set视图。
  • values(): 返回此映射中包含的值的Collection视图。
  • entrySet(): 返回此映射中包含的映射关系的Set视图。

扩容方式

JDK1.7版本扩容

①：先生成新数组；

②：遍历老数组中的每个位置上的链表上的每个元素；

③：获取每个元素的key，并基于新数组长度，计算出每个元素在新数组中的下标；

④：将元素添加到新数组中去；

⑤：所有元素转移完之后，将新数组赋值给HashMap对象的table属性。

JDK1.8版本扩容

①：先生成新数组；

②：遍历老数组中的每个位置上的链表或红黑树；

③：如果是链表，则直接将链表中的每个元素重新计算下标，并添加到新数组中去；

④：如果是红黑树，则先遍历红黑树，先计算出红黑树中每个元素对应在新数组中的下标位置；

a：统计每个下标位置的元素个数；

b：如果该位置下的元素个数超过了8，则生成一个新的红黑树，并将根节点添加到新数组的对应位置；

c：如果该位置下的元素个数没有超过8，那么则生成一个链表，并将链表的头节点添加到新数组的对应位置；

⑤：所有元素转移完了之后，将新数组赋值给HashMap对象的table属性。

源码

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
   	
   	//默认初始化容量16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
	//最大容量2的30次方
    static final int MAXIMUM_CAPACITY = 1 << 30;
	//扩容因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
	//连表转化为红黑树数组中元素的个数临界值
    static final int TREEIFY_THRESHOLD = 8;

    static final int UNTREEIFY_THRESHOLD = 6;
	//连表转化为红黑树数组某一节点连表元素个数的临界值
    static final int MIN_TREEIFY_CAPACITY = 64;
}

putVal()方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //临时定义的数组 保存table中的数据
        HashMap.Node<K,V>[] tab;
        //临时定义变量，根据hash值，接受数组中这个下标位置上的数据
        HashMap.Node<K,V> p;
        int n, i;
        //jdk1.8 使用默认构造函数时，第一调用put方法时，初始化table数组，使用默认值
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //之后再次添加分为下面两种情况
        //第一种就是在table数组的(n - 1) & hash下标下没有数据，则直接将该value放入到数组下标位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            //第二种情况 在table数组的(n - 1) & hash下标下已经存在数据
            HashMap.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 HashMap.TreeNode)
                //判断要加入的数据类型是TreeNode类型，则走putTreeVal方法
                e = ((HashMap.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);//如果是null 则直接将数据放到该位置
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);//如果此时该位置是一个红黑树的结构，则按照规则进行插入
                        break;
                    }
                    //如果连表或红黑树中已经存在了,则取出
                    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;
}

resize()方法

final HashMap.Node<K, V>[] resize() {
        HashMap.Node<K, V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        //数组已经初始化了
        if (oldCap > 0) {
            //如果数组容量大于等于最大容量 则不进行如何处理，直接返回
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //如果在0到最大范围之间，则扩容两倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //数组初始化
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {
            // 这是使用默认值的情况，使用无参构造函数
            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"})
        HashMap.Node<K, V>[] newTab = (HashMap.Node<K, V>[]) new HashMap.Node[newCap];
        //将扩容后的哈希表赋值给table
        table = newTab;
        //如果旧表不为空，即存在数据
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                HashMap.Node<K, V> e;
                if ((e = oldTab[j]) != null) {
                    //将节点设置为空
                    oldTab[j] = null;
                    if (e.next == null)
                        //如果链表只有一个节点，将旧表节点重新计算放入新表
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof HashMap.TreeNode)
                        //如果该节点是红黑树，执行split方法来处理红黑树节点，包括升级、降级、回退到链表等操作
                        ((HashMap.TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        //此时桶中结构为链表，且大于1个节点，开始遍历链表
                        HashMap.Node<K, V> loHead = null, loTail = null;
                        HashMap.Node<K, V> hiHead = null, hiTail = null;
                        HashMap.Node<K, V> next;
                        do {
                            next = e.next;
                            // 从if-else可以看出，对一条链表进行遍历，将链表中的元素通过
                            // 条件(e.hash & oldCap) == 0来进行分类，满足条件的存放在loHead链上
                            // 不满足条件的存放在hiHead链上，且都是尾部插入方式，这和JDK7的头部插入有区别
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            } else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        //将loHead链放在数组的原位置
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        //将hiHead链放在数组的（j + oldCap）位置
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
}

treeifyBin()方法

final void treeifyBin(Node<K,V>[] tab, int hash) {
        //定义几个变量，n是数组长度，index是索引
        int n, index; Node<K,V> e;
        //这里的tab指的是本HashMap中的数组，n为数字长度，如果数组为null或者数组长度小于64
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            //则调用resize()方法直接扩容，不转红黑树
            resize();
        //否则说明满足转红黑树条件，通过按位与运算取得索引index，并将该索引对应的node节点赋值给e，e不为null时    
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            //定义几个变量，hd代表头节点，tl代表尾节点
            TreeNode<K,V> hd = null, tl = null;
            do {
                //先把e节点转成TreeNode类型，并赋值给p
                TreeNode<K,V> p = replacementTreeNode(e, null);
                //如果尾节点tl为空，则说明还没有根节点，试想下，这时元素数目都超过8个了，还能没有尾节点么，所以没有尾节点只能说明还没设置根节点
                if (tl == null)
                    //设置根节点，把p赋值给根节点hd
                    hd = p;
                else {
                    //把tl设置为p的前驱节点
                    p.prev = tl;
                    //把p设置为tl的后继节点，这两步其实就是我指向你，你指向我的关系，为了形成双向链表 
                    tl.next = p;
                }
                //把首节点设置成p后，把p赋值给尾节点tl，然后会再取链表的下一个节点，转成TreeNode类型后再赋值给p，如此循环
                tl = p;
                //取下一个节点，直到下一个节点为空，也就代表这链表遍历好了
            } while ((e = e.next) != null);
            //用新生成的双向链表替代旧的单向链表，其实就是把这个数组对应的位置重新赋值成新双向链表的首节点
            if ((tab[index] = hd) != null)
                //这个方法里就开始做各种比较，左旋右旋，然后把双向链表搞成一个红黑树
                hd.treeify(tab);
        }
    }

getNode()方法

final HashMap.Node<K, V> getNode(int hash, Object key) {
        //临时变量储存table数组
        HashMap.Node[] tab;
        //临时变量获取第一个元素
        HashMap.Node first;
        //n为table的长度
        int n;
        //如果table已经被初始化切table数组的长度大于0,在已知元素的查找位置上有元素则进入if判断
        //否则返回null,即没有找到元素
        if ((tab = this.table) != null && (n = tab.length) > 0 && (first = tab[n - 1 & hash]) != null) {
            Object k;
            //first元素存在,切first元素即锁需要查找的元素,直接返回first.
            if (first.hash == hash && ((k = first.key) == key || key != null && key.equals(k))) {
                return first;
            }
            //e为临时变量储存在first元素不是所需元素的下一个元素
            HashMap.Node e;
            if ((e = first.next) != null) {
                //当链表被树化后的查询
                if (first instanceof HashMap.TreeNode) {
                    return ((HashMap.TreeNode)first).getTreeNode(hash, key);
                }
                //如果链表没有被树化,则使用链表的方式查询.
                do {
                    //循环判断当前的临时变量e是否与所需元素相同
                    //相同则返回e元素,不相同则返回null
                    if (e.hash == hash && ((k = e.key) == key || key != null && key.equals(k))) {
                        return e;
                    }
                } while((e = e.next) != null);
            }
        }
        return null;
}

removeNode()方法

final HashMap.Node<K, V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) {
        //获取临时变量tab存储table数组
        HashMap.Node[] tab;
        HashMap.Node p;
        int n;
        int index;
        //获取n为table长度,index为hash后的位置
        //如果当前table已经初始化,且index位置上的元素不为空,则进入if判断,准备查找需要删除的元素
        if ((tab = this.table) != null && (n = tab.length) > 0 && (p = tab[index = n - 1 & hash]) != null) {
            HashMap.Node<K, V> node = null;
            Object k;
            //如果当前index位置上第一个元素则是需要被删除的元素,则将node指定为p,开始删除
            //如果不是则进入else循环开始查找
            if (p.hash == hash && ((k = p.key) == key || key != null && key.equals(k))) {
                node = p;
            } else {
                HashMap.Node e;
                //如果当前index位置上下一个元素不为空,则判断类型进行查找
                if ((e = p.next) != null) {
                    //如果index位置为红黑树,则调用树的查找
                    if (p instanceof HashMap.TreeNode) {
                        node = ((HashMap.TreeNode)p).getTreeNode(hash, key);
                    } else {
                        //如果当前index位置为链表,则循环向后查找
                        label88: {
                            while(e.hash != hash || (k = e.key) != key && (key == null || !key.equals(k))) {
                                p = e;
                                if ((e = e.next) == null) {
                                    break label88;
                                }
                            }
                            //将node指定为e,不论e是否为null.
                            node = e;
                        }
                    }
                }
            }
            //如果node不为null,则代表查找到key值对应的元素
            Object v;
            if (node != null && (!matchValue || (v = ((HashMap.Node)node).value) == value || value != null && value.equals(v))) {
                //如果被查找到的node类型为树类型,则调用树的删除方法
                if (node instanceof HashMap.TreeNode) {
                    ((HashMap.TreeNode)node).removeTreeNode(this, tab, movable);
                }
                //如果node==p,则代表是index当前位置的第一个元素被查找到,直接将index位置的元素后移即可.
                else if (node == p) {
                    tab[index] = ((HashMap.Node)node).next;
                }
                //如果不是第一个元素,则将查找到元素的前一个元素的next指针指向被查找到的元素的next元素,即可实现删除
                else {
                    p.next = ((HashMap.Node)node).next;
                }
                //将操作数加一
                ++this.modCount;
                //将map中元素个数减一
                --this.size;
                this.afterNodeRemoval((HashMap.Node)node);
                //返回被删除的元素
                return (HashMap.Node)node;
            }
        }
 
        return null;
}

computeIfAbsent()方法

//指定 key，找到对应的Node节点，执行remappingFunction.apply(key)，返回新的 value 值，会执行以下四种情况：
//Node 不为 null 且 Node.value 不为null，返回 Node.value
//value 为 null，直接返回 null
//value 不为null，Node不为null 且 Node.value为null，设置 Node.value为value，返回 value
//value 不为null，Node为null，新建节点 (key, v)， 返回 value

@Override
public V computeIfAbsent(K key,
                         Function<? super K, ? extends V> mappingFunction) {
    /* null 异常检测 */
    if (mappingFunction == null)
        throw new NullPointerException();
    /* 计算 key 的 hash 值 */    
    int hash = hash(key);
    Node<K,V>[] tab; Node<K,V> first; int n, i;
    int binCount = 0;
    TreeNode<K,V> t = null;
    Node<K,V> old = null;
    /* 元素个数 > 临界值 || tab 为空 || tab 长度为 0 */
    if (size > threshold || (tab = table) == null ||
        (n = tab.length) == 0)
        /* 进行扩容并获得 扩容后的数组长度 */
        n = (tab = resize()).length;
    /* 拿到 key 值对应的桶位下标，并获取首元素的节点 */
    if ((first = tab[i = (n - 1) & hash]) != null) {
    	/* first 若属于树节点，使用树节点的查找Node节点方法getTreeNode() */
        if (first instanceof TreeNode)
            old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
        else {
        	/* 链表查找 node 节点 */
            Node<K,V> e = first; K k;
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k)))) {
                    old = e;
                    break;
                }
                ++binCount;
            } while ((e = e.next) != null);
        }
        /* old 不为 null && old.value 不为 null，返回旧值oldValue */
        V oldValue;
        if (old != null && (oldValue = old.value) != null) {
        	/* 预留函数 */
            afterNodeAccess(old);
            return oldValue;
        }
    }
    /* 执行指定的操作 */
    V v = mappingFunction.apply(key);
    /* v 为 null 直接 return null */
    if (v == null) {
        return null;
    } else if (old != null) { // old 不为null，但old.value 为 null
        /* 设置旧值为 v */
        old.value = v;
        /* 预留函数 */
        afterNodeAccess(old);
        return v;
    }
    /* t != null 即 当前桶位的元素为树节点，添加新值(key, v) */
    else if (t != null)
        t.putTreeVal(this, tab, hash, key, v);
    else {
    	/* 添加链节点(key,v) */
        tab[i] = newNode(hash, key, v, first);
        /* 判断 binCount >= 8 - 1,是否需要转化树节点 */
        if (binCount >= TREEIFY_THRESHOLD - 1)
            treeifyBin(tab, hash);
    }
    /* 更新 modCount，size */
    ++modCount;
    ++size;
    /* 预留函数 */
    afterNodeInsertion(true);
    return v;
}

computeIfPresent()方法

public V computeIfPresent(K key,
      BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    /* null 异常检测 */                      	
    if (remappingFunction == null)
        throw new NullPointerException();
    Node<K,V> e; V oldValue;
    /* 计算 key 的 hash 值 */
    int hash = hash(key);
    /* e 不为空 && e.value 不为空 */
    if ((e = getNode(hash, key)) != null &&
        (oldValue = e.value) != null) {
        /* 执行指定动作 返回v */
        V v = remappingFunction.apply(key, oldValue);
        /* v != null 则替换该 value 值 */
        if (v != null) {
            e.value = v;
            /* 预留函数 */
            afterNodeAccess(e);
            return v;
        }
        else
        	/* v 为null 则删除 key 对应的节点 */
            removeNode(hash, key, null, false, true);
    }
    /* 找不到 key 对应的节点 或者 Node.value 为空，直接返回 null */
    return null;
}

示例

import java.util.HashMap;  
import java.util.Map;  
  
public class MapExample {  
    public static void main(String[] args) {  
        // 创建一个HashMap实例  
        Map<String, Integer> map = new HashMap<>();  
  
        // 向map中添加键值对  
        map.put("one", 1);  
        map.put("two", 2);  
        map.put("three", 3);  
  
        // 获取并打印map中的值  
        System.out.println("Value for 'one': " + map.get("one"));  
  
        // 检查map中是否包含某个键  
        System.out.println("Contains key 'two'? " + map.containsKey("two"));  
  
        // 遍历map的键  
        for (String key : map.keySet()) {  
            System.out.println("Key: " + key + ", Value: " + map.get(key));  
        }  
  
        // 遍历map的键值对  
        for (Map.Entry<String, Integer> entry : map.entrySet()) {  
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());  
        }  
  
        // 移除一个键值对  
        map.remove("two");  
        System.out.println("Map after removal: " + map);  
  
        // 清空map  
        map.clear();  
        System.out.println("Map after clearing: " + map);  
    }  
}

在这个示例中，我们创建了一个HashMap实例，并添加了一些键值对。然后，我们演示了如何获取值、检查键的存在、遍历键和键值对，以及如何移除和清空Map。

Map接口及其实现类在Java中广泛应用于各种场景，如缓存、数据库查询结果的存储、配置管理等。它们提供了一种高效、灵活的方式来处理键值对关系。

weixin_44877172
关注
  • 9
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java7hashmap源码-network_program:学习java网络编程
06-04
java网络编程学习 简介 用于存放学习java网络编程过程遇见的重难点笔记和相关代码 附带代码大部分是《java网络编程 第四版》的课程代码 对运算字符串进行识别的作业 @since2020.11.26 IO流 - 多线程 @since2020.11....
JAVA中哈希表HashMap的深入学习
08-18
在Java中，HashMap的内部结构是一个Entry数组，每个Entry是一个键值对，同时包含了指向下一个Entry的引用，形成了一个单链表。Entry类实现了Map.Entry接口，其中包含了key、value、next引用和一个hash属性，用于存储...
Java中HashMap的用法
eck_燃的博客
03-19 9万+
HashMap 学习java基础的时候对map不熟悉，再加上图算法经常用到这个结构来存储，特此加一篇文章来介绍Map import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map.Entry; public class HashMap { publi......
Java学习-Hashmap
Lyq2017901206的博客
10-22 1594
JavaHashMap是基于哈希表的Map实现。 这就是为什么面试官总是要求HashMap和HashTable之间存在差异的原因。HashMap基本上等于HashTable，但以下两个区别除外。 当HashTable同步时，HashMap不同步。 HashMap允许为null，而HashTable不允许为null。
Java中HashMap数组
wfcn_zyq的博客
04-30 9887
天梯赛 package www.tianti; import java.util.ArrayList; import java.util.HashMap; import java.util.Scanner; public class L7_4_Shuai_Hash { public static void main(String[] args) { Scanner in...
深入理解Java中的HashMap
TONIYH的博客
08-05 2040
前言 在面试的过程中有一些面试官喜欢问HashMap的相关知识点，这个是一个常见的知识点。但是面试官会问的很深。因此，我想做一个深度的总结。将此总结的过程分享给大家。 什么是HashMap? 菜鸟网站中对HashMap有以下的定义： 在Java中HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。HashMap 是无序的
学习Java之HashMap的扰动函数
weixin_40090829的博客
02-21 997
学习Java之Hashmap的扰动函数 先来看个例子 ：( 65535 * i + 1234 ) % 65535 。在整体不唱过int上限的情况下，无论i是多少，结果都是一个固定值。 这种hash的结果是最差的，因为所有的对象都分配到同一个槽中。 其原因是hash中只有低16位确定分配到数组中的哪个槽，高16位没在分配槽起作用。 那么解决思路就很简单了，那就是在hash过程中，让高位也参与到低位的运算中来。 HashMap中的扰动函数 static final int hash(Object va
Java学习：HashMap
m0_57753335的博客
08-03 418
Java学习：HashMap
Java中遍历HashMap的5种方式
热门推荐
明明如月的技术博客
06-15 13万+
本教程将为你展示Java中HashMap的几种典型遍历方式。 如果你使用Java8，由于该版本JDK支持lambda表达式，可以采用第5种方式来遍历。 如果你想使用泛型，可以参考方法3。如果你使用旧版JDK不支持泛型可以参考方法4。 1、 通过ForEach循环进行遍历 mport java.io.IOException; import java.util.HashMap; import...
java集合之HashMap
初心不忘、始终方得
04-06 1433
学而时习之，不亦乐乎
java中的HashMap用法总结
笨鸟贤妃的博客
11-23 9771
文章目录前言一、HashMap是什么？二、Java HashMap 常用方法代码示例总结 前言 HashMap学习笔记 一、HashMap是什么？ HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。 HashMap 是无序的，即不会记录插入的顺序。 HashMap 继承于AbstractMap，实现了 Map、Cloneabl
Java 基础 —— HashMap
IT__learning的博客
11-16 3599
一、ArrayList 二、哈希表 三、HashMap HashMap 是用于存储 Key-Value 键值对的集合。 （1）HashMap 根据键的 hashCode 值存储数据，大多数情况下可以直接定位到它的值，所以具有很快的访问速度，但遍历顺序不确定。 （2） HashMap 中键 key 为 null 的记录至多只允许一条，值 value 为 null 的记录可以有多条。 （3） HashMap 非线程安全，即任一时刻允许多个线程同时写 HashMap，可能会导致数据的不一致。 hashmap
java在hashmap初始化时赋初值过程解析
08-25
Java 中的 HashMap 是一种常用的数据结构，一般用来做数据字典或者 Hash 查找的容器。在初始化并赋初值时，我们通常使用 `HashMap, Object> map = new HashMap();` 的方式初始化，然后使用 `put` 方法添加键值对。...
Java-HashMap.rar_hashmap_java hashmap
09-24
在Java编程语言中，`HashMap`是`java.util`包中的一个核心类，它属于集合框架的一部分，主要用于存储键值对的数据结构。`HashMap`基于哈希表（散列表）实现，提供了快速的插入、删除和查找操作，平均时间复杂度为O(1...
学习Java HashMap，看这篇就够了
08-18
"Java HashMap 详解" Java HashMap 是一种常用的数据结构，它实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度。HashMap 是一个散列表，它存储的内容是键值对（key-value）映射。 HashMap 的...
【JavaWeb】JDBC&Druid&Tomcat入门使用
lklalmq的博客
09-04 1120
预编译SQL语句并执行：预防SQL注入问题获取 PreparedStatement 对象// SQL语句中的参数值，使用？占位符替代?// 通过Connection对象获取，并传入对应的sql语句设置参数值上面的sql语句中参数使用?进行占位，在之前之前肯定要设置 这些?的值。PreparedStatement对象：setXxx(参数1，参数2)：给?赋 值Xxx：数据类型；如 setInt (参数1，参数2)参数：参数1：？的位置编号，从1 开始参数2：？的值执行SQL语句。
spring事务详细讲解-深入浅出
小电玩
09-08 355
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
最新发布
m0_63550220的博客
09-08 1343
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1332
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java 中 hashmap 用法
07-17
HashMap是Java中常用的一种集合类，用于存储键值对。它提供了快速的插入、查找和删除操作，具有很高的性能。 下面是HashMap的基本用法示例： 1. 导入HashMap类： ``` import java.util.HashMap; ``` 2. 创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值