Есть ли чистый (и нулевой безопасный) способ умножения значений карты в Java?

Моим первым побуждением было предложить Stream входного MapentrySet, который сопоставляет значения новым значениям и завершается collectors.toMap().

К сожалению, Collectors.toMap выдает NullPointerException, когда функция отображения значений возвращает null. Поэтому он не работает со значениями null вашего входного Map.

В качестве альтернативы, поскольку вы не можете изменить свой входной Map, я предлагаю вам создать его копию, а затем вызвать replaceAll:

Map<String, Double> adjustedMap = new HashMap<>(someMap);
adjustedMap.replaceAll ((k,v) -> v != null ? 2*v : null);

Вы можете добиться этого, преобразовав в поток что-то вроде:

someMap.entrySet()
        .forEach(entry -> {
            if (entry.getValue() != null) {
                adjustedMap.put(entry.getKey(), someMap.get(entry.getKey()) * 2);
            } else {
                adjustedMap.put(entry.getKey(), null);
            }
        });

который можно сократить до:

someMap.forEach((key, value) -> {
    if (value != null) {
        adjustedMap.put(key, value * 2);
    } else {
        adjustedMap.put(key, null);
    }
});

Итак, если у вас есть карта с:

Map<String, Double> someMap = new HashMap<>();
someMap.put("test1", 1d);
someMap.put("test2", 2d);
someMap.put("test3", 3d);
someMap.put("testNull", null);
someMap.put("test4", 4d);

Вы получите такой результат:

{test4=8.0, test2=4.0, test3=6.0, testNull=null, test1=2.0}

Это можно сделать так

someMap.entrySet().stream()
            .filter(stringDoubleEntry -> stringDoubleEntry.getValue() != null) //filter null values out
            .forEach(stringDoubleEntry -> stringDoubleEntry.setValue(stringDoubleEntry.getValue() * 2)); //multiply values which are not null

Если вам нужна вторая карта, где только значения, не равные нулю, просто используйте forEach, чтобы поместить их в новую карту.

Используйте вот так.

  Map<String, Double> adjustedMap = map.entrySet().stream().filter(x -> x.getValue() != null)
            .collect(Collectors.toMap(x -> x.getKey(), x -> 2*x.getValue()));
  //printing 
  adjustedMap.entrySet().stream().forEach(System.out::println);

Попробуйте что-то подобное с api потока java 8

Map<String, Double> newMap = oldMap.entrySet().stream()
    .collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue() == null ? null: x.getValue()*2));

Вы можете сделать это с помощью этого кода:

Map<String, Double> map = new HashMap<>();
map.put("1", 3.0);
map.put("3", null);
map.put("2", 5.0);

Map<String, Double> res = 
map.entrySet()
   .stream()
   .collect(
           HashMap::new, 
           (m,v)->m.put(v.getKey(), v.getValue() != null ? v.getValue() * 2 : null),
           HashMap::putAll
           );

System.out.println(res);

и вывод будет:

{1=6.0, 2=10.0, 3=null}

Это позволит вам сохранить значения null на карте.

Чтобы сохранить нулевые значения, вы можете использовать что-то простое, например:

someMap.keySet()
        .stream()
        .forEach(key -> adjustedMap.put(key, (someMap.get(key)) == null ? null : someMap.get(key) * 2));

Редактировать в ответ на Петр Янечек комментарий: вы можете применить предложенное к копии someMap:

adjustedMap.putAll(someMap);
adjustedMap.keySet()
       .stream()
       .forEach(key -> adjustedMap.put(key, (adjustedMap.get(key)) == null ? null : adjustedMap.get(key) * 2));

В качестве альтернативы потоковой передаче и / или копированию решений в Google Guava существует служебный метод Maps.transformValues():

Map<String, Double> adjustedMap = Maps.transformValues(someMap, value -> (value != null) ? (2 * value) : null);

Это возвращает ленивое представление исходной карты, которое не выполняет никакой работы самостоятельно, но применяет данную функцию при необходимости. Это может быть как профессионал (если вам вряд ли когда-либо понадобятся все значения, это сэкономит вам время на вычисления), так и недостаток (если вам понадобится одно и то же значение много раз, или если вам нужно дополнительно изменить someMap. без adjustedMap, видящего изменения) в зависимости от вашего использования.

Как насчет этого?

Map<String, Double> adjustedMap = new HashMap<>(someMap);
adjustedMap.entrySet().forEach(x -> {
      if (x.getValue() != null) {
            x.setValue(x.getValue() * 2);
      }
});

Еще один способ:

Map<String, Double> someMap = someMapFunction();

int capacity = (int) (someMap.size() * 4.0 / 3.0 + 1);
Map<String, Double> adjustedMap = new HashMap<>(capacity);

if (someMap != null) someMap.forEach((k, v) -> adjustedMap.put(k, v == null ? v : v * 2));

Обратите внимание, что я создаю новую карту с коэффициентом загрузки по умолчанию (0.75 = 3.0 / 4.0) и начальной емкостью, которая всегда больше, чем size * load_factor. Это гарантирует, что размер adjustedMap никогда не будет изменен / хеширован.

Если вас устраивают значения Optional, вам могут подойти следующие варианты:

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;

import static java.util.stream.Collectors.toMap;


public static Map<String, Optional<Double>> g(Map<String, Double> map, Function<Double, Double> f) {
    return map.entrySet().stream().collect(
            toMap(
                    e -> e.getKey(),
                    e -> e.getValue() == null ? Optional.empty() : Optional.of(f.apply(e.getValue()))
            ));
}

а потом:

public static void main(String[] args) throws Exception {
    Map<String, Double> map = new HashMap<>();
    map.put("a", 2.0);
    map.put("b", null);
    map.put("c", 3.0);


    System.out.println(g(map, x -> x * 2));
    System.out.println(g(map, x -> Math.sin(x)));
}

печатает:

{a=Optional[4.0], b=Optional.empty, c=Optional[6.0]}
{a=Optional[0.9092974268256817], b=Optional.empty, c=Optional[0.1411200080598672]}

Это довольно чисто с созданием новой карты, делегированной Collectors, и дополнительным преимуществом возвращаемого типа Map<String, Optional<Double>>, четко указывающим на возможность null и побуждающим пользователей обращаться с ними.

Ответов уже много. Некоторые из них мне кажутся несколько сомнительными. В любом случае, большинство из них встраивают проверку null в той или иной форме.

Подход, который делает один шаг вверх по лестнице абстракции, заключается в следующем:

Вы хотите применить унарный оператор к значениям карты. Таким образом, вы можете реализовать метод, который применяет унарный оператор к значениям карты. (Все идет нормально). Теперь вам нужен «специальный» унарный оператор, безопасный для null. Затем вы можете обернуть безопасный для null унарный оператор вокруг исходного.

Это показано здесь с тремя разными операторами (один из них, если на то пошло, Math::sin):

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.function.UnaryOperator;

public class MapValueOps
{
    public static void main(String[] args)
    {
        Map<String, Double> map = new LinkedHashMap<String, Double>();
        map.put("A", 1.2);
        map.put("B", 2.3);
        map.put("C", null);
        map.put("D", 4.5);

        Map<String, Double> resultA = apply(map, nullSafe(d -> d * 2));
        System.out.println(resultA);

        Map<String, Double> resultB = apply(map, nullSafe(d -> d + 2));
        System.out.println(resultB);

        Map<String, Double> resultC = apply(map, nullSafe(Math::sin));
        System.out.println(resultC);

    }

    private static <T> UnaryOperator<T> nullSafe(UnaryOperator<T> op)
    {
        return t -> (t == null ? t : op.apply(t));
    }

    private static <K> Map<K, Double> apply(
        Map<K, Double> map, UnaryOperator<Double> op)
    {
        Map<K, Double> result = new LinkedHashMap<K, Double>();
        for (Entry<K, Double> entry : map.entrySet())
        {
            result.put(entry.getKey(), op.apply(entry.getValue()));
        }
        return result;
    }
}

Я думаю, что это чисто, потому что это хорошо разделяет проблемы применения оператора и выполнения проверки null. И он безопасен для null, потому что ... об этом сказано в названии метода.

(Можно было бы поспорить о том, чтобы вытащить вызов, чтобы обернуть оператор в nullSafe, один в метод apply, но дело не в этом)

_Edit:

В зависимости от предполагаемого шаблона приложения можно сделать нечто подобное и применить преобразование на месте без создания новой карты, вызвав Map#replaceAll