android/guava/src/com/google/common/collect/Maps.java
public static <K, V1, V2> Map<K, V2> transformValues(
      Map<K, V1> fromMap, Function<? super V1, V2> function) {
    return transformEntries(fromMap, asEntryTransformer(function));
  }
public static <K, V1, V2> Map<K, V2> transformValues(
      Map<K, V1> fromMap, Function<? super V1, V2> function) {
    return transformEntries(fromMap, asEntryTransformer(function));
  }
Returns a view of a map where each value is transformed by a function. All other properties of
the map, such as iteration order, are left intact. For example, the code:

<pre>{@code
Map<String, Integer> map = ImmutableMap.of("a", 4, "b", 9);
Function<Integer, Double> sqrt =
new Function<Integer, Double>() {
public Double apply(Integer in) {
return Math.sqrt((int) in);
}
};
Map<String, Double> transformed = Maps.transformValues(map, sqrt);
System.out.println(transformed);
}</pre>

... prints {@code {a=2.0, b=3.0}}.

<p>Changes in the underlying map are reflected in this view. Conversely, this view supports
removal operations, and these are reflected in the underlying map.

<p>It's acceptable for the underlying map to contain null keys, and even null values provided
that the function is capable of accepting null input. The transformed map might contain null
values, if the function sometimes gives a null result.

<p>The returned map is not thread-safe or serializable, even if the underlying map is.

<p>The function is applied lazily, invoked when needed. This is necessary for the returned map
to be a view, but it means that the function will be applied many times for bulk operations
like {@link Map#containsValue} and {@code Map.toString()}. For this to perform well, {@code
function} should be fast. To avoid lazy evaluation when the returned map doesn't need to be a
view, copy the returned map into a new map of your choosing.