【JAVA8】Map新方法，别再重复造车轮了

最新推荐文章于 2023-06-22 15:09:59 发布
最新推荐文章于 2023-06-22 15:09:59 发布
阅读量8.3k 收藏 14
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leilei1366615/article/details/120114749
版权

文章目录


java8 发布后，map类库增加了多个新的方法，利用这些新方法能更加便利地操纵Map中的数据

新增的方法有：

getOrDefault，forEach，compute，computeIfAbsent，computeIfPresent，merge，putIfAbsent，remove(key,value)，replace，replaceAll

getOrDefault

getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值。

语法：

hashmap.get(Object key, V defaultValue)

参数说明：

  • key - 键
  • defaultValue - 当指定的key并不存在映射关系中，则返回的该默认值

返回值:

返回 key 相映射的的 value，如果给定的 key 在映射关系中找不到，则返回指定的默认值。

模拟数据:

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);

java8之前的方式

Map<String, Integer> map = new HashMap<>(4);
map.put("lisa", 1);
int lisaValue = 0;
if (map.containsKey("lisa")) {
    lisaValue = map.get("lisa");
}
System.out.println(lisaValue);

java8

// key为 lisa 的映射存在则返回对应value,否则返回默认值-1
Integer java8lisaValue = map.getOrDefault("lisa", -1);
// 1
System.out.println(java8lisaValue);
// key为 adas 的映射存在则返回对应value,否则返回默认值-999
Integer adasValue = map.getOrDefault("adas", -999);
// adas
System.out.println(adasValue);

forEach

foreach 可以让我们以Lambda的方式快速遍历映射集（map）

语法：

map.forEach(BiConsumer<K, V> action)

参数说明：

  • BiConsumer- java8新提供的函数式接口，我们可以定义遍历消费逻辑

返回值：

无

模拟数据：

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);

java8之前的方式

这种是以前Map遍历获取键值对信息最高效的方式，因为每组键值对只需遍历一次，但写法较为古老

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

java8

实际上Java8 map的foreach底层仍是用的entrySet,只是上层用了BiConsumer 函数式接口，简化了我们直接遍历的代码。

 map.forEach((k, v) -> System.out.println(k + "=" + v));

具体实现如下：

image-20210905104814367

compute

尝试计算指定键及其当前映射值的映射（如果没有当前映射，则返回null）

公式：

map.compute(K key, BiFunction remappingFunction)

参数说明：

  • key - 键
  • remappingFunction - 重新映射函数，用于重新计算值

返回值

如果 key 对应的 value 不存在，则返回该 null，如果存在，则返回通过 remappingFunction 重新计算后的值并保存到映射集中（如重新计算后的值为Null,不会保存,且会将该映射从映射集中删除）。

模拟数据：

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);

java8 之前操作

private static Integer computeBefore(String key, Integer newValue) {
    Map<String, Integer> map = new LinkedHashMap<>(4);
    map.put("lisa", 1);
    map.put("jone", 2);
    map.put("selina", 3);
    Integer oldValue = map.get(key);
    if (newValue != null) {
        if (map.containsKey(key) && oldValue != null) {
            map.remove(key);
        }
        return null;
    } else {
        map.put(key, newValue);
        return newValue;
    }
}

java8操作

Key在Map中存在

// jone key存在,且 新value不为null,则会返回最新jone对应的value (v + 234),并添加到映射集map中
Integer joneNewValue = map.compute("jone", (k, v) -> v == null ? 0 : v + 234);
// joneNewValue:236
System.out.println("joneNewValue:" + joneNewValue);
// {lisa=1, jone=236, selina=3}
System.out.println(map);

System.out.println("================");
// jone key存在,且 新value为null,则会返回最新jone对应的value null,并将映射在原集中删除
Integer joneNewValue2 = map.compute("jone", (k, v) -> null);
// joneNewValue2:null
System.out.println("joneNewValue2:" + joneNewValue2);
// 此时会 移除 KEY  jone
// {lisa=1, selina=3}
System.out.println(map);

Key在Map中不存在

// asd key不存在,且 新value不为null,则会返回最新asd对应的value 111,并保存到映射集map中
Integer asdNewValue = map.compute("asd", (k, v) -> 111);
// asdNewValue:111
System.out.println("asdNewValue:" + asdNewValue);
// {lisa=1, selina=3, asd=111}
System.out.println(map);

System.out.println("================");
// box key不存在,且 新value为null,则会返回null, 不保存到映射集map中
Integer boxNewValue = map.compute("box", (k, v) -> null);
// boxNewValue:null
System.out.println("boxNewValue:" + boxNewValue);
// {lisa=1, selina=3, asd=111}
System.out.println(map);

computeIfAbsent

如果指定的KEY 的键值对(k,v)不存在，或者 对应的Value 为空，则将键值对新增至映射集（Map）中

语法：

map.computeIfAbsent(K key, Function remappingFunction)

参数说明：

  • key - 键
  • remappingFunction - 重新映射函数，用于重新计算值

返回值:

如果 key 对应的 value 不存在，则使用获取 remappingFunction 重新计算后的值，并保存为该 key 的 value，否则返回 value。

模拟数据：

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);
map.put("ddd", null);

java8 之前操作

Integer lisaValue = map.get("adas");
if ( !map.containsKey("adas")|| map.get("adas") == null) {
    map.put("adas", 2345);
}

java8操作

// 原映射集无 key为 adas的键值对，且 新key  adas 对应的 value 不为null (2345) 则会将其添加到map映射集中并返回该值
Integer adas = map.computeIfAbsent("adas", x -> 2345);
// 2345
System.out.println(adas);
// {lisa=1, jone=2, selina=3, ddd=null, adas=2345}
System.out.println(map);

System.out.println("--------------");

// 原映射集无 key为 dml的键值对，且 新key  ml 对应的 value 为null,则忽略添加，并返回null
Integer dmlValue = map.computeIfAbsent("dml", x -> null);
// null
System.out.println(dmlValue);
// {lisa=1, jone=2, selina=3, ddd=null, adas=2345}
System.out.println(map);

System.out.println("--------------");
// 原映射集有 Key为 ddd的键值对,但ddd对应的value 为空,如果我们再次添加有效value到ddd,则会将原键值对覆盖
Integer dddNewValue = map.computeIfAbsent("ddd", x -> 0);
// 0
System.out.println(dddNewValue);
// {lisa=1, jone=2, selina=3, ddd=0, adas=2345}
System.out.println(map);

computeIfPresent

如果指定KEY的映射存在且Value非null，则将指定KEY的原Value,替换为现在的Value，保存存在映射集中,如果现Value为null，会将指定KEY的映射删除

语法：

map.computeIfPresent(K key, BiFunction remappingFunction)

参数说明：

  • key - 键
  • remappingFunction - 重新映射函数，用于重新计算值

返回值:

如果 key 对应的 value 不存在，则返回该 null，如果存在，则返回通过 remappingFunction 重新计算后的值。

模拟数据：

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);
map.put("ddd", null);

java8之前操作

if (map.get("selina") != null) {
    Integer oldValue = map.get("selina");
    Integer newValue = 1232312;
    if (newValue != null) {
        map.put("selina", newValue);
    } else {
        map.remove("selina");
    } 
}

java8

// 原映射集中存在对应KEY  ,原Value不为null,现value不为null,则覆盖原来 键值对映射
Integer selinaNewValue = map.computeIfPresent("selina", (k, v) -> 888999);
// 888999
System.out.println(selinaNewValue);
// {lisa=1, jone=2, selina=888999, ddd=null}
System.out.println(map);

System.out.println("-------------------");
// 原映射集中存在对应KEY  ,原Value不为null,现value为null,则移除对应键值对
Integer selinaNewValue2 = map.computeIfPresent("selina", (k, v) -> null);
// null
System.out.println(selinaNewValue2);
// 移除了selina
System.out.println(map);

System.out.println("-------------------");
// 原映射集中存在对应KEY  ,原Value为null,现value 不为null,  对原映射集不做任何操作
Integer dddNewValue = map.computeIfPresent("ddd", (k, v) -> 2222222);
System.out.println(dddNewValue);
System.out.println(map);

System.out.println("-------------------");
// 原映射集中不存在对应KEY  ,现value 不为null  对原映射集不做任何操作
Integer mqNewValue = map.computeIfPresent("mq", (k, v) -> -1);
System.out.println(mqNewValue);
System.out.println(map);

merge

merge() 方法会先判断指定的 key 是否存在，如果不存在，则添加键值对到 hashMap 中，如果存在则根据逻辑重新映射该KEY键值对（如何合并相同KEY的新旧VALUE）

语法:

map.merge(key, value, remappingFunction)

参数说明：

  • key - 键
  • value - 值
  • remappingFunction - 重新映射函数，用于重新计算值

返回值:

如果 key 对应的 value 不存在，则返回该 value 值，如果存在，则返回通过 remappingFunction 重新计算后的值。

模拟数据:

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);
map.put("ddd", null);

我们都知道，Map 的KEY,如果相同了，后插入的值会覆盖新的值

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);
// {lisa=1, jone=2, selina=3}
System.out.println(map);
map.put("lisa", 2);
// {lisa=2, jone=2, selina=3}
System.out.println(map);

merge，可以让我们根据自己选择如何处理相同KEY的值，类似于冲突合并（怎么合并，自己决定）

// 采用旧值
map.merge("lisa", 100, (oldValue, newValue) -> oldValue);

// 采用新值
map.merge("lisa", 100, (oldValue, newValue) -> newValue);

// 新旧值逻辑处理合并
map.merge("lisa", 100, (oldValue, newValue) -> oldValue + newValue);
  map.merge("lisa", 100, Integer::sum);

注意：

java8 Stream Collectors.toMap() 方法便要我们去合并冲突，否则如果出现相同KEY的数据，或者Value为null，程序会报错！

User adas = new User("adas", 23);
User adas2 = new User("adas", 28);
User mlg = new User("mlg", 34);
ArrayList<User> list = new ArrayList<>();
list.add(adas);
list.add(adas2);
list.add(mlg);
Map<String, Integer> userMap = list.stream().collect(Collectors.toMap(User::getName, User::getValue));
System.out.println(userMap);

提示我们键冲突了！

image-20210905135211281

解决:

Map<String, Integer> userMap = list.stream()
        .filter(x->x.name!=null && x.value!=null)
        // 这里采用新值覆盖旧值
        .collect(Collectors.toMap(User::getName, User::getValue,(oldValue,newValue)->newValue));
// {adas=28, mlg=34}
System.out.println(userMap);

putIfAbsent

putIfAbsent() 方法会先判断指定的键（key）是否存在，不存在则将键/值对插入到映射集中，并返回null，存在则返回原本Value

语法：

map.putIfAbsent(K key, V value)

参数说明：

  • key - 键
  • value - 值

返回值：

如果所指定的 key 已经在Map 中存在，返回和这个 key 值对应的 value, 如果所指定的 key 在Map 中不存在，则返回 null。

注意如果指定 key 之前已经和一个 null 值相关联了 ，则该方法也返回 null。

模拟数据：

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);

java8 之前写法

Integer newValue = 222;
Integer joneValue = map.get("jone");
if (joneValue == null) {
    joneValue = map.put("lisa", newValue);
} else {
    joneValue = joneValue;
}

java8

// selina 在源映射集中不存在,则返回null 做插入操作
Integer adasValue = map.putIfAbsent("adas", 1);
System.out.println(adasValue);
System.out.println(map);

System.out.println("----------");

// selina 在源映射集中存在,则返回原值 不做插入操作
Integer selinaValue = map.putIfAbsent("selina", 33333);
System.out.println(selinaValue);
System.out.println(map);

remove(key,value)

当指定的 KEY 与VALUE 在映射集中存在，且为绑定的键值对关系时，才移除

语法：

map.remove(K key, V value)

参数说明：

  • key - 键
  • value - 值

返回值：

仅当 key-value 映射存在，且二者为绑定关系时，才会移除该数据，返回true,其他情况为false

模拟数据：

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);

演示

// lisa-2 无映射关系，因为不会移除
map.remove("lisa", 2);
// {lisa=1}
System.out.println(map);

replace

replace() 方法替换 映射集中是指定的 key 对应的 value。

语法：

map.replace(K key, V oldValue, V newValue)

参数说明：

  • key - 键
  • oldValue - 旧的 value 值
  • newValue - 新的 value 值

返回值:

如果 oldValue 不存在，对 key 对应对 value 执行替换，返回 key 对应的旧值，如果存在则替换,并返回旧值。

如果 KEY 不存在，则不做任何操作,返回null

模拟数据：

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);

演示

// key 存在 且原 value 不为null
Integer lisaOldValue = map.replace("lisa", 333);
// 返回原来旧值 1
System.out.println(lisaOldValue);
// lisa的值已被替换  {lisa=333, hobo=null}
System.out.println(map);

System.out.println("___________________");

// key 存在 且原 value 为null
Integer hoboOldValue = map.replace("hobo", -1);
// 返回旧值 null
System.out.println(hoboOldValue);
// hobo的值已被替换 {lisa=333, hobo=-1}
System.out.println(map);
System.out.println("___________________");

// key 不存在
Integer adasOldValue = map.replace("adas", -1);
// null
System.out.println(adasOldValue);
// 未变 {lisa=333, hobo=-1}
System.out.println(map);

replaceAll

replaceAll() 方法将 映射集中的所有映射Value替换成给定的函数所执行的结果

语法：

map.replaceAll(Bifunction<K, V> function)

**注：**hashmap 是 HashMap 类的一个对象。

参数说明：

  • function - 函数式接口实例，生成映射对函数

返回值：

无，只会对映射集中的值做替换处理。

模拟数据：

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);
map.put("qq", null);

演示

// replaceAll之前:{lisa=1, jone=2, selina=3, qq=null}
System.out.println("replaceAll之前:" + map);
map.replaceAll((k, v) -> v == null ? -1 : v * 100);

// replaceAll之后:{lisa=100, jone=200, selina=300, qq=-1}
System.out.println("replaceAll之后:" + map);

values

values() 方法返回映射中所有 value 组成的集合

语法：

hashmap.values()

参数说明：

  • 无

返回值:

返回 Map 中所有 value 值所组成的集合

模拟数据：

Map<String, Integer> map = new LinkedHashMap<>(4);
map.put("lisa", 1);
map.put("jone", 2);
map.put("selina", 3);
map.put("qq", null);

演示

// [lisa, jone, selina, qq]
System.out.println(map.keySet());
// [1, 2, 3, null]
System.out.println(map.values());
保护我方胖虎
关注
专栏目录
2018最新Android 面试指南
陈万洲的专栏
03-21 1124
数据结构与算法问题的难度完全取决于你所申请的公司数组数组由一组相同的数据类型组成。它存储在连续的内存空间内，使用索引可以找到元素的地址。数组包括一维数组和多维数组,一维数组是最简单的数据结构,也是最常用的。算法平均最坏空间（Space）O(n)O(n)查找（Search）O(n)O(n)插入（Insert）O(n)O(n)删除（Delete）O(n)O(n)链表链表看起来更像树，而不是数组，它使用...
Java程序员必备，史上最详细常用的八种设计模式讲解丨建议收藏
Java_supermanNO1的博客
11-15 415
本文转载自：[Java程序员必备，史上最详细常用的八种设计模式讲解丨建议收藏](https://segmentfault.com/a/1190000021026645 一、Proxy代理模式 1. 什么是代理模式 抽象点说是一个类代表另一个类的功能，或者说一个对象为另一个对象提供一个代理或者占位符以控制对这个对象的访问。同样我也会举例子来说明，这里我举一个买车票的例子。通常我们我们买车票需要去车...
Java8-Map
zym_1321的博客
06-19 302
Map新增的方法 1、getOrDefault(Object key, V defaultValue) 如果Map中存在该key，则返回键对应的值。如果不存在，则会返回设置的默认值。 private static void getOrDefaultTest() { Map<String, String> map = new HashMap<>(); map.put("A", "1"); String value = map.getOrDefault("B", "2"); Sy
Java基础之Java8中Map
m0_56565321的博客
06-15 4299
什么是Map map属于java中的顶级接口之一，区别于list，map是键值对的形式存在。有个大神举例的好，map就相当于夫妻，而list相当于单身狗。 类图
Java8中那些方便又实用的Map函数
fm18771120556的博客
11-12 661
java8之后，常用的Map接口中添加了一些非常实用的函数，可以大大简化一些特定场景的代码编写，提升代码可读性，一起来看看吧。
Java8Map
进无止境
03-01 266
public class Java8Map { public static void main(String[] args) { Map<Integer,String> map = new HashMap<>(); for (int i = 0; i < 6; i++) { map.put(i,"val" + i); } map.put(10,null); //map
Java8：Java8 中 Map 接口的新方法
wanghao112956的博客
10-23 547
我们提一个需求：给定一个 List<String>，统计每个元素出现的所有位置。 比如，给定 list：["a", "b", "b", "c", "c", "c", "d", "d", "d", "f", "f", "g"]，那么应该返回： a : [0] b : [1, 2] c : [3, 4, 5] d : [6, 7, 8] f : [9, 10] g : [11] 很明显...
Java Object 类方法解析
指点
08-11 2070
前言
java学习笔记（面试必备）
Riztal的博客
12-17 9933
第一式：java基础 第一招：java的四大特性：抽象，继承，封装，多态 抽象的概念： 这里我先补充一下对象的概念，在java中世界万物皆对象，对象就是客观存在的事物，比如一个人，一支笔。而抽象就是将对象的某些细节和特征抽取出来，用程序代码表示，抽取出来的东西一般我们称之为类或者接口，因此抽象分为两个方面，数据抽象和过程抽象。 数据抽象：就是将事物的共同的特征用程序代码表示，通过抽象成为对...
java基础理论知识点
qq_43306376的博客
11-21 964
Java 核心 解释一下 OOP 的概念 面向对象编程是使用类，对象，继承性，多态性，封装性和抽象的一种程序设计方法。。 抽象 在面向对象的概念中，所有对象都是由类来描述，但是反过来，并不是所有类都是用来描述对象的。如果一个类中没有包含足够信息来描绘一个具体的对象，这样的类就是抽象类。 继承 继承（英语：inheritance）是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B，就把这个A称为“B的子类别”，而把B称为“A的父类别”也可以称“B是A的超类”。继承可以使得子类别具有父类别的
JAVA8独有的map遍历方式(非常好用)
08-25
主要介绍了JAVA8独有的map遍历方式(非常好用)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【创作赢红包】Java8中的Map函数
weixin_38256051的博客
04-01 244
java8之后，常用的Map接口中添加了一些非常实用的函数，可以大大简化一些特定场景的代码编写，提升代码可读性，一起来看看吧。
Java8 map技巧
yxl626571494的博客
04-23 662
List的处理: demo代码如下。
java 8 map_Java8（3）：Java8 中 Map 接口的新方法
weixin_30104235的博客
02-12 153
我们提一个需求：给定一个 List，统计每个元素出现的所有位置。比如，给定 list：["a", "b", "b", "c", "c", "c", "d", "d", "d", "f", "f", "g"] ，那么应该返回：a : [0]b : [1, 2]c : [3, 4, 5]d : [6, 7, 8]f : [9, 10]g : [11]很明显，我们很适合使用 Map 来完成这件事情：pu...
【Java】Java8中那些方便又实用的Map函数
最新发布
DreamSun的博客
06-22 983
java8之后，常用的Map接口中添加了一些非常实用的函数，可以大大简化一些特定场景的代码编写，提升代码可读性，一起来看看吧。一直以来，java因代码编写太繁琐而被开发者们所广泛诟病，但从java8开始，从Map、Stream、var、multiline-string再到record，java在代码编写层面做了大量的简化，java似乎开窍了🤔。
Java 8中的Map类
实践求真知
04-12 409
Java 8中Map新增了不少新方法，下面将演示常见方法的典型应用。 1 代码示例 import java.util.*; public class MapTest2 { public static void main(String[] args) { Map map = new HashMap(); // 成对放入多个key-value对 map.put("
Java8 Map新功能详解：实用方法实战演示
Java8 Map中新增了许多实用的默认方法，这些改进使得处理Map数据结构更加高效和简洁。本文将详细介绍其中几个关键方法，包括`putIfAbsent`, `replace`, `replaceAll`, `computeIfPresent`, `computeIfAbsent`, `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值