HashMap的使用方法总结、实现原理、使用示例

最新推荐文章于 2024-05-08 12:45:32 发布
最新推荐文章于 2024-05-08 12:45:32 发布
阅读量717 收藏 2
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22701869/article/details/106990538
版权

目录

 

存值特点

数据结构：

数组+单项链表+红黑树

图解：

变量

构造函数

public HashMap()

public HashMap(int initialCapacity)：自定义数组长度

public HashMap(int initialCapacity, float loadFactor):自定义数组长度和家在因子

public HashMap(Map m)：通过map初始化

public void clear()：数组对应的值置空，即清空map

public Object clone()：克隆map

public V compute(K key, BiFunction remappingFunction)：对key在map中的值进行操作

public V computeIfAbsent(K key, Function mappingFunction)：不存在加添加

public V computeIfPresent(K key,BiFunction remappingFunction)只对已经存在key的进行操作，其他不操作

public Set> entrySet()：获取键值对Entry的Set集合

public void forEach(BiConsumer action)：遍历

public V getOrDefault(Object key, V defaultValue)：key存在返回value，key不存在返回defaultValue

public boolean isEmpty()：判断集合是不是空

public Set keySet()：获取key的set集合

public V merge(K key, V value,BiFunction remappingFunction)；key存在修改，不存在新增

public void putAll(Map m)：putmap

public V putIfAbsent(K key, V value)：key不存在就添加

public boolean remove(Object key, Object value)：对应的key、value存在就删除

public V replace(K key, V value)：替换可以对应的value的值

public void replaceAll(BiFunction function)：根据自定义规则修改元素

public int size()：map的长度

public Collection values()：获取值得集合

存值特点

key和value都可以为空

数据结构：

数组+单项链表+红黑树

链表长度>=8：链表变为红黑树

红黑树长度<=6:红黑树变为链表

链表节点

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;//hash值
    final K key;//可以值
    V value;//值
    Node<K,V> next;//指向下一个链表节点

数组

transient Node<K,V>[] table;

图解：

变量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;默认数组初始容量-必须是2的幂
static final float DEFAULT_LOAD_FACTOR = 0.75f;在构造函数中未指定时使用的加载因子。
transient Set<Map.Entry<K,V>> entrySet;保存缓存entrySet ()。HashMap中value的集合
transient int size;map包含元素容量
final float loadFactor;哈希表的装载因子
static final int MAXIMUM_CAPACITY = 1 << 30;最大数据容量
static final int MIN_TREEIFY_CAPACITY = 64;树形结构最小容量为64
transient int modCount;记录被改变的次数.主要用于iterators 的快速失败判断.
transient Node<K,V>[] table;链表数组
int threshold;调整大小的下一个大小值(容量*加载因子)。
static final int TREEIFY_THRESHOLD = 8;链表>=8，转变为红黑树
static final int UNTREEIFY_THRESHOLD = 6;红黑树<=6,转变成链表

构造函数

public HashMap()

默认加载因子：0.75f

public HashMap(int initialCapacity)：自定义数组长度

输入的数字会计算为最接近2的幂数

1 ->1
10->16
17->32
31->32
33->64

public HashMap(int initialCapacity, float loadFactor):自定义数组长度和家在因子

public HashMap(Map<? extends K, ? extends V> m)：通过map初始化

public class Test {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"1");
        map.put(3,"1");
        map.put(4,"1");
        Map<Integer,String> map2 = new HashMap<>(map);
        System.out.println(map2);
    }
}

结果：

{1=1, 2=1, 3=1, 4=1}

public void clear()：数组对应的值置空，即清空map

public class Test {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"1");
        map.put(3,"1");
        map.put(4,"1");
        map.clear();
        System.out.println(map);
    }
}

结果

{}

public Object clone()：克隆map

注意：要用全名定义HashMap<Integer,String> map = new HashMap<>(4);，不能写成Map<Integer,String> map = new HashMap<>(4);

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"1");
        map.put(3,"1");
        map.put(4,"1");
        HashMap<Integer,String> map2 = (HashMap<Integer, String>) map.clone();
        System.out.println(map2);
        map2.remove(4);
        System.out.println(map);
        System.out.println(map2);
    }
}

结果：对克隆的修改，不会影响原来的map

{1=1, 2=1, 3=1, 4=1}
{1=1, 2=1, 3=1, 4=1}
{1=1, 2=1, 3=1}

public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)：对key在map中的值进行操作

修改key=3，的value的值

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        String test = map.compute(3, (k,v) -> v+1 );
        map.compute(5,(k,v)->{
            return "test";
        });
        map.compute(2,(k,v)->{
            return "test";
        });
        System.out.println(test);
        System.out.println(map);
    }
}

结果：1、对应的key存在，修改key对应value的值，2、如果对应的key不存在，新增一个key、value

31
{1=1, 2=test, 3=31, 4=2, 5=test}

public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)：不存在加添加

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        String test = map.computeIfAbsent(3, key -> "test" );
        String test2 = map.computeIfAbsent(5, key -> "test" );

        System.out.println(test);
        System.out.println(test2);
        System.out.println(map);
    }
}

结果：1、存在直接返回；2、key不存在就添加一个值

3
test
{1=1, 2=2, 3=3, 4=2, 5=test}

public V computeIfPresent(K key,BiFunction<? super K, ? super V, ? extends V> remappingFunction)只对已经存在key的进行操作，其他不操作

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        String test = map.computeIfPresent(3, (key,value) -> "test" );
        String test2 = map.computeIfPresent(5, (key,value) -> "test" );

        System.out.println(test);
        System.out.println(test2);
        System.out.println(map);
    }
}

结果：1、对key存在的进行操作；2、对key不存在的不作处理

test
null
{1=1, 2=2, 3=test, 4=2}
public boolean containsKey(Object key)，containsValue(Object value)：包含key、包含值
public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        String test = map.computeIfPresent(3, (key,value) -> "test" );
        String test2 = map.computeIfPresent(5, (key,value) -> "test" );

        System.out.println(map.containsKey(1));
        System.out.println(map.containsKey(5));
        System.out.println(map.containsValue("1"));
        System.out.println(map.containsValue("5"));
    }
}

结果：

true
false
true
false

public Set<Map.Entry<K,V>> entrySet()：获取键值对Entry的Set集合

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

结果：

1
1
2
2
3
3
4
2

public void forEach(BiConsumer<? super K, ? super V> action)：遍历

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        map.forEach((key,value)->{
            System.out.println(key+":"+value);
        });
    }
}

结果：

1:1
2:2
3:3
4:2

public V getOrDefault(Object key, V defaultValue)：key存在返回value，key不存在返回defaultValue

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        System.out.println(map.getOrDefault(1,"5"));
        System.out.println(map.getOrDefault(5,"6"));
    }
}

结果：

1
6

public boolean isEmpty()：判断集合是不是空

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");

        System.out.println(map.isEmpty());
    }
}

结果：

false

public Set<K> keySet()：获取key的set集合

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        Set<Integer> integers = map.keySet();
        for (Integer integer : integers) {
            System.out.println(integer+":"+map.get(integer));
        }
    }
}

结果：

1:1
2:2
3:3
4:2

public V merge(K key, V value,BiFunction<? super V, ? super V, ? extends V> remappingFunction)；key存在修改，不存在新增

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.merge(1,"1",(key,value)->{
           return "test";
        });
        map.merge(2,"5",(key,value)->{
            return "test";
        });
        map.merge(7,"1",(key,value)->{
            return "test";
        });
        map.merge(5,"6",(key,value)->{
            return "test";
        });
        System.out.println(map);
    }
}

结果：

{1=test, 2=test, 3=3, 4=2, 5=6, 7=1}

public void putAll(Map<? extends K, ? extends V> m)：putmap

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        HashMap<Integer,String> map2 = new HashMap<>(4);
        map2.put(5,"7");
        map2.put(6,"7");
        map.putAll(map2);
        System.out.println(map);
    }
}

结果：

{1=1, 2=2, 3=3, 4=2, 5=7, 6=7}

public V putIfAbsent(K key, V value)：key不存在就添加

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.putIfAbsent(3,"5");
        map.putIfAbsent(4,"2");
        map.putIfAbsent(5,"2");
        System.out.println(map);
    }
}

结果：

{1=1, 2=2, 3=3, 4=2, 5=2}

public boolean remove(Object key, Object value)：对应的key、value存在就删除

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.remove(1,"3");
        map.remove(2,"2");
        System.out.println(map);
    }
}

结果：

{1=1, 3=3, 4=2}

public V replace(K key, V value)：替换可以对应的value的值

public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.replace(1,"3");
        map.replace(2,"5");
        System.out.println(map);
    }
}

结果：

{1=3, 2=5, 3=3, 4=2}
public boolean replace(K key, V oldValue, V newValue)：替换key、oldValue存在元素的value为newValue
public class Test {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<>(4);
        map.put(1,"1");
        map.put(2,"2");
        map.put(3,"3");
        map.put(4,"2");
        map.replace(1,"1","3");
        map.replace(2,"5","6");
        System.out.println(map);
    }
}

结果：

{1=3, 2=2, 3=3, 4=2}

public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)：根据自定义规则修改元素

修改key>2的value为test

public class Test {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>(4);
        map.put(1, "1");
        map.put(2, "2");
        map.put(3, "3");
        map.put(4, "2");
        map.replaceAll((key, value) -> {
            if (key > 2) {
                return "test";
            }
            return value;

        });
        System.out.println(map);
    }
}

结果：

public class Test {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>(4);
        map.put(1, "1");
        map.put(2, "2");
        map.put(3, "3");
        map.put(4, "2");
        map.replaceAll((key, value) -> {
            if (key > 2) {
                return "test";
            }
            return value;

        });
        System.out.println(map);
    }
}

public int size()：map的长度

public Collection<V> values()：获取值得集合

public class Test {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>(4);
        map.put(1, "1");
        map.put(2, "2");
        map.put(3, "3");
        map.put(4, "2");
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }
        System.out.println(map);
    }
}

结果：

1
2
3
2
{1=1, 2=2, 3=3, 4=2}

 

 

 

 

 

 

 

黑皮爱学习
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HashMap介绍和使用
09-28
### HashMap介绍和使用详解 #### 一、HashMap的数据结构 HashMap是Java集合框架的一个重要组成部分，它实现了Map接口，能够存储键值对映射。在Java编程语言中，最基本的数据结构有两种：数组和引用（模拟指针）。...
hashcode使用方法
04-03
### hashcode使用方法 在Java编程语言中，`hashCode` 方法是对象类 `Object` 的一部分，用于生成一个整数，通常用作基于哈希的数据结构（如哈希表）中的索引。为了确保数据结构的高效性，正确地重写 `hashCode` ...
HashMap实现原理分析
CoderLife9192的专栏
10-02 320
http://wiki.jikexueyuan.com/project/java-collection/hashmap.html HashMap 概述 HashMap 是基于哈希表的 Map 接口的非同步实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 此实现假定哈希函数将元素适当地分布
2024年最新React技术---速学！利用react技术实现类似某宝的tab切换效果，hashmap面试题及答案
最新发布
2401_84562041的博客
05-08 533
希望本文对你有所启发，有任何面试上的建议也欢迎留言分享给大家。好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。好了~如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。
HashSet的使用方法总结、实现原理、使用示例
一点光辉的博客
06-28 3875
HashMap的使用方法总结、实现原理、使用示例
TreeSet的使用方法总结、实现原理、使用示例
一点光辉的博客
07-02 2万+
HashMap的使用方法总结、实现原理、使用示例
HashMap的底层原理与实现
程小白的博客
08-02 3157
HashMap是InterfaceMap的实现类，HashMap底层采用了哈希表，它是一种十分重要的数据结构。对于以后学习很多其他的新知识都十分有帮助。 数据结构中使用数组和链表对数据进行存储，他们各有特点： 数组：索引效率高，但插入，删除元素效率低。 链表：插入，删除元素效率高，但是索引效率低。 而哈希表结合...
HashMap的实现原理
学而不思则忘
11-09 1091
参考文章： https://www.cnblogs.com/jing99/p/11330341.html 本文是在参考文章的基础上自己总结，因为觉得不亲手总结一下不好消化。也请多去原文查看，原文内容比本文生动，有图有代码。如果侵权，请联系我删除！！ 前叙： 先看看其他数据结构在查询、新增和删除这几个方面的性能： 数组：采用连续的存储空间来存储数据。对于指定下标的查找，时间复杂度为O(1)。对于给定的值的查找，时间复杂度为O(n)，因为要遍历数组，寻找值相等项。但是，对于有序数组的查找，可以使用二分
HashMap底层实现原理详解
热门推荐
Hai的博客
02-15 2万+
文章目录前言一、快速入门二、使用步骤1.引入库2.读入数据总结学习内容：学习时间：学习产出：前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：以下是本篇文章对HashMap的实现原理内容，下面案例可供参考 提示：以下是本篇文章正文内容，下面案例可供参考 一、快速入门 示例：有一定基础的小伙伴们可以选择性的跳过该步骤 HashMap是Java程序员使用频率最高的用于映射键值对(key和value)处理的数据类型。随着JDK版本的跟新，JDK1.8对HashMap底层的实现进行
HashMap底层实现原理
weixin_44020556的博客
08-19 480
9.4.2 HashMap底层实现详解 【节选自高淇老师300集中的内容，该文章的源码来自JDK1.6，在JDK1.8中Entry已换成Node，并且哈希算法有所改变，可自行查看源码，但底层原理是一样的】 HashMap底层实现采用了哈希表，这是一种非常重要的数据结构。对于我们以后理解很多技术都非常有帮助(比如：redis数据库的核心技术和HashMap一样)，因此，非常有必要让大家理解。 ...
HashMap实现原理
0102的博客
07-05 354
HashMap HashMap基础数据结构： 如上结构课看出，HashMap主要是有一个链表的形式来存储数据 ，上面Node类和C语言中的结构体很像，如上可以看出HashMap底层由是一个数组结构，数组中的每一项又是一个链表，新建一个HashMap的时候，会初始化数组。数组中的每个元素都是Node类，其中包括了Key，Value，还有对应的下一个节点的地址信息，类似指针。 提到Hash...
HashMap实现原理和源码分析
Altsuki的博客
05-13 8297
《算法 第4版本》 3.4 散列表 知乎-R神：关于hashMap的一些按位与计算的问题？ 知乎-美团：Java 8系列之重新认识HashMap 新浪博客-无敌宝贝：取余与位运算 1. 散列表（哈希表） 1.1 散列函数 hashCode() 1.2 除留余数法 1.3 基于拉链法的散列表 1.4 基于线性探测法的散列表（开放地址散列表） 2. HashMap源码...
JavaWeb基于Session实现的用户登陆注销方法示例
08-28
总结来说，基于Session的用户登录注销机制在JavaWeb中广泛使用，它能有效地管理用户会话，确保用户在登录状态下的安全性。同时，通过对比Cookie和Session，我们可以更好地理解它们的适用场景和优缺点，从而选择合适...
Java和Android的LRU缓存及实现原理
09-01
LRU（Least Recently Used...总结，LRU缓存策略在Java和Android中通过`LinkedHashMap`实现，它结合了哈希表和双向链表，既能快速查找，又能根据最近使用情况高效地淘汰元素，适用于内存有限但需要频繁访问数据的场景。
HashMap通过VALUE反向求KEY的方法
02-24
总结来说，这段代码展示了如何在HashMap中通过值来查找键，这通常需要遍历整个HashMap的Entry集合，并使用Map.Entry的`getValue()`和`getKey()`方法进行比较。虽然这种方法在大数据量的情况下效率较低，但在某些场景...
could not extract ResultSet； SQL [n/a]； nested exception is org.hibernate.exception.SQLGrammarExcept
一点光辉的博客
01-13 1万+
完整报错如下 org.springframework.dao.InvalidDataAccessResourceUsageException: could not extract ResultSet; SQL [n/a]; nested exception is org.hibernate.exception.SQLGrammarException: could not extract ResultSet at org.springframework.orm.jpa.vendor.HibernateJ
java的Random类生成随机的double范围【0,1）Math.random()生成0到100之间的数【0-100）【1-100】
一点光辉的博客
07-13 7916
使用Random生成随机的double，范围【0,1） double b = new Random().nextDouble(); 测试用例 public class TestRandom { public static void main(String[] args) { Random random = new Random(); for (int i = 0; i < 100; i++) { System.out.print
SourceTree拉取代码和自己本地代码冲突解决方案，git -c diff.mnemonicprefix=false -c core.quotepath=false fetch origin解决
一点光辉的博客
07-23 7276
目录 拉取代码报错 解决方案理解 解决过程 1、先把代码存到暂存区 2、点击储藏，并输入储藏名字 3、拉取最新代码 4、应用储藏区 5、修改冲突代码 6、提交代码 拉取代码报错 文字如下 git -c diff.mnemonicprefix=false -c core.quotepath=false fetch origin git -c diff.mnemonicprefix=false -c core.quotepath=false pull --no-commit.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值