code: public static <K, V1, V2> Map<K, V2> transformValues(
        Map<K, V1> fromMap, Function<? super V1, V2> function) {
      return transformEntries(fromMap, asEntryTransformer(function));
    }
docs: 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.