我的StreamEx库增强了标准流API，提供了一个EntryStream类，更适合转换地图:

Map<String, Integer> output = EntryStream.of(input).mapValues(Integer::valueOf).toMap();

像这样的一般解

public static <X, Y, Z> Map<X, Z> transform(Map<X, Y> input,
        Function<Y, Z> function) {
    return input
            .entrySet()
            .stream()
            .collect(
                    Collectors.toMap((entry) -> entry.getKey(),
                            (entry) -> function.apply(entry.getValue())));
}

例子

Map<String, String> input = new HashMap<String, String>();
input.put("string1", "42");
input.put("string2", "41");
Map<String, Integer> output = transform(input,
            (val) -> Integer.parseInt(val));

Map<String, String> x;
Map<String, Integer> y =
    x.entrySet().stream()
        .collect(Collectors.toMap(
            e -> e.getKey(),
            e -> Integer.parseInt(e.getValue())
        ));

它不像列表代码那么好。你不能构造新的地图。映射到map()调用中，因此工作被混合到collect()调用中。

如果你不介意使用第三方库，我的cyclops-react库有所有JDK集合类型的扩展，包括Map。我们可以直接使用'map'操作符转换map(默认情况下map作用于map中的值)。

   MapX<String,Integer> y = MapX.fromMap(HashMaps.of("hello","1"))
                                .map(Integer::parseInt);

Bimap可用于同时转换键和值

  MapX<String,Integer> y = MapX.fromMap(HashMaps.of("hello","1"))
                               .bimap(this::newKey,Integer::parseInt);

下面是Sotirios Delimanolis的答案的一些变化，它以(+1)开始非常好。考虑以下几点:

static <X, Y, Z> Map<X, Z> transform(Map<? extends X, ? extends Y> input,
                                     Function<Y, Z> function) {
    return input.keySet().stream()
        .collect(Collectors.toMap(Function.identity(),
                                  key -> function.apply(input.get(key))));
}

这里有几点。首先是在泛型中使用通配符;这使得函数在某种程度上更加灵活。通配符是必要的，例如，如果你想要输出映射有一个键是输入映射的键的超类:

Map<String, String> input = new HashMap<String, String>();
input.put("string1", "42");
input.put("string2", "41");
Map<CharSequence, Integer> output = transform(input, Integer::parseInt);

(这里也有一个映射值的例子，但这真的是人为的，我承认为Y设置有界通配符只在边缘情况下有用。)

第二点是，我没有在输入映射的entrySet上运行流，而是在keySet上运行流。我认为这使得代码更简洁，代价是必须从map条目中获取值，而不是从map条目中获取值。顺便说一句，我最初有key -> key作为toMap()的第一个参数，由于某种原因，这失败了，导致类型推断错误。将其更改为(X键)->键，就像Function.identity()一样。

另一种说法如下:

static <X, Y, Z> Map<X, Z> transform1(Map<? extends X, ? extends Y> input,
                                      Function<Y, Z> function) {
    Map<X, Z> result = new HashMap<>();
    input.forEach((k, v) -> result.put(k, function.apply(v)));
    return result;
}

它使用Map.forEach()而不是流。我认为，这甚至更简单，因为它省去了收集器，而收集器与地图一起使用有些笨拙。原因是map . foreach()将键和值作为单独的参数提供，而流只有一个值——您必须选择是使用键还是使用映射条目作为该值。缺点是，这种方法缺乏其他方法丰富、流畅的优点。: -)

尽管可以在流的collect部分重新映射键或/和值，如其他答案所示，但我认为它应该属于map部分，因为该函数被设计用于转换流中的数据。其次，它应该易于重复，而不会引入额外的复杂性。可以使用SimpleEntry对象，该对象自Java 6以来已经可用。

使用java8

import java.util.AbstractMap.SimpleEntry;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

public class App {

    public static void main(String[] args) {
        Map<String, String> x;
        Map<String, Integer> y = x.entrySet().stream()
                .map(entry -> new SimpleEntry<>(entry.getKey(), Integer.parseInt(entry.getValue())))
                .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
    }

}

使用Java 9+

随着Java 9的发布，Map接口内引入了一个静态方法，以便更容易地创建一个条目，而不需要实例化一个新的SimpleEntry，如前面的示例所示。

import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

public class App {

    public static void main(String[] args) {
        Map<String, String> x;
        Map<String, Integer> y = x.entrySet().stream()
                .map(entry -> Map.entry((entry.getKey(), Integer.parseInt(entry.getValue())))
                .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
    }

}