跳到主要内容

Java HashMap merge() 方法

如果指定的键已与某个值关联，该方法会将旧值替换为指定函数的结果。

merge() 方法的语法是：

hashmap.merge(key, value, remappingFunction)

这里，hashmap 是 HashMap 类的一个对象。

merge() 方法的参数​

merge() 方法接受 3 个参数：

  • key - 要与指定的 value 关联的键
  • value - 如果 key 已与某个值关联，则与 key 关联的值
  • remappingFunction - 如果 **key** 已与某个值关联，则与 key 关联的结果

merge() 方法的返回值​

  • 返回与 key 关联的 新值
  • 如果没有与 key 关联的值，则返回 null

注意：如果 remappingFunction 返回 null，则移除指定 key 的映射。

示例 1：HashMap merge() 插入新条目​

import java.util.HashMap;

class Main {
  public static void main(String[] args) {
    // 创建一个 HashMap
    HashMap<String, Integer> prices = new HashMap<>();

    // 向 HashMap 插入条目
    prices.put("Shoes", 200);
    prices.put("Bag", 300);
    prices.put("Pant", 150);
    System.out.println("HashMap: " + prices);

    int returnedValue = prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue);
    System.out.println("Shirt 的价格: " + returnedValue);

    // 打印更新后的 HashMap
    System.out.println("更新后的 HashMap: " + prices);
  }
}

输出

HashMap: {Pant=150, Bag=300, Shoes=200}
Shirt 的价格: 100
更新后的 HashMap: {Pant=150, Shirt=100, Bag=300, Shoes=200}

在上面的示例中，我们创建了一个名为 prices 的 hashmap。注意表达式，

prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue)

这里，我们使用了 lambda 表达式 (oldValue, newValue) -> oldValue + newValue) 作为重映射函数。要了解更多关于 lambda 表达式的信息，请访问 Java Lambda 表达式。

由于键 Shirt 在 prices 中不存在，merge() 方法插入了映射 Shirt=100。重映射函数的结果被忽略。

示例 2：HashMap merge() 插入具有重复键的条目​

import java.util.HashMap;

class Main {
  public static void main(String[] args) {
    // 创建一个 HashMap
    HashMap<String, String> countries = new HashMap<>();

    // 向 HashMap 插入条目
    countries.put("Washington", "America");
    countries.put("Canberra", "Australia");
    countries.put("Madrid", "Spain");
    System.out.println("HashMap: " + countries);

    // 合并键 Washington 的映射
    String returnedValue = countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue);
    System.out.println("Washington: " + returnedValue);

    // 打印更新后的 HashMap
    System.out.println("更新后的 HashMap: " + countries);
  }
}
```**输出**

```java
HashMap: {Madrid=Spain, Canberra=Australia, Washington=America}
Washington: America/USA
更新后的 HashMap: {Madrid=Spain, Canberra=Australia, Washington=America/USA},

在上述示例中，我们创建了一个名为 countries 的 hashmap。注意表达式，

countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue)

这里，我们使用了 lambda 表达式 (oldValue, newValue) -> oldValue + "/" + newValue) 作为重映射函数。

由于键 Washington 已存在于 countries 中，旧值被重映射函数返回的值替换。因此，Washington 的映射包括值 America/USA。

示例 3：HashMap merge() 合并两个 HashMap​

import java.util.HashMap;

class Main {
  public static void main(String[] args) {
    // 创建一个 HashMap
    HashMap<String, Integer> prices1 = new HashMap<>();

    // 向 HashMap 插入条目
    prices1.put("Pant", 230);
    prices1.put("Shoes", 350);
    System.out.println("HashMap 1: " + prices1);

    // 创建另一个 hashmap
    HashMap<String, Integer> prices2 = new HashMap<>();

    // 向 HashMap 插入条目
    prices2.put("Shirt", 150);
    prices2.put("Shoes", 320);
    System.out.println("HashMap 2: " + prices2);

    // forEach() 访问 prices2 的每个条目
    // merge() 将 prices2 的每个条目插入到 prices1
    prices2.forEach((key, value) -> prices1.merge(key, value, (oldValue, newValue) -> {

      // 返回较小的值
      if (oldValue < newValue) {
        return oldValue;
      }
      else {
        return newValue;
      }
    }));

    System.out.println("合并后的 HashMap: " + prices1);
  }
}

输出

HashMap 1: {Pant=230, Shoes=350}
HashMap 2: {Shirt=150, Shoes=320}
合并后的 HashMap: {Pant=230, Shirt=150, Shoes=320}

在上述示例中，我们创建了两个名为 prices1 和 prices2 的 hashmap。注意代码，

    prices2.forEach((key, value) -> prices1.merge(key, value, (oldValue, newValue) -> {
      if (oldValue < newValue) {
        return oldValue;
      }
      else {
        return newValue;
      }
    }));

这里，HashMap forEach() 方法访问了 hashmap prices2 的每个条目，并将其合并到 hashmap prices1。我们使用了两个 lambda 表达式：

  • (key, value) -> prices.merge(...) - 它访问 prices1 的每个条目并将其传递给 merge() 方法。
  • (oldValue, newValue) -> {...} - 它是一个重映射函数。它比较两个值并返回较小的值。

由于键 Shoes 在两个 hashmap 中都存在，Shoes 的值被重映射函数的结果替换。

Java HashMap merge() 与 putAll 对比​

我们也可以使用 putAll() 方法合并两个 hashmap。然而，如果一个键在两个 hashmap 中都存在，旧值将被新值替换。

与 merge() 不同，putAll() 方法不提供重映射函数。因此，我们无法决定对重复键存储什么值。

要了解更多关于 putAll() 方法的信息，请访问 Java HashMap putAll()。

最后于 更新