Numbers adder via generics
The following code is very inefficient:

    Double sum = 0.0;

    for (Number num : value){
        sum += num.doubleValue();
    }


It creates a Double object for 0.0, and then, since Double objects are immutable, for every num in the value list, it creates yet another Double object for the resulting partial sum.  If you replaced Double with double, then you won't be creating new objects for each iteration through the loop.



Since you are already using the stream API, why not use DoubleStream::sum to sum the values as a double?

    double sum = value.stream().mapToDouble(Number::doubleValue).sum();




Finally, you could use the Collectors.toMap() stream method to create the map.

public Map&lt;String, Double&gt; add(Map&lt;String, List&lt;? extends Number&gt;&gt; map) {
    return map.entrySet().stream()
          .collect(Collectors.toMap(Map.Entry::getKey,
                                    e -&gt; e.getValue().stream()
                                              .mapToDouble(Number::doubleValue)
                                              .sum()));
}


Whether or not this last step is an "improvement" may be a matter of taste.

Note: the return type is no longer a HashMap; it just a Map.



The add() method doesn't depend on any members of Adder, so the method should be static.  Then you can get rid of the Adder adder = new Adder() object.



Using List.of(...) and Map.of(...) can simplify your test code:

public static void main(String[] args) {

    List&lt;Integer&gt; list1 = List.of(1, 2, 3);
    List&lt;BigDecimal&gt; list2 = List.of(new BigDecimal("9.87654321e300"),
                                     new BigDecimal("987654321"),
                                     new BigDecimal("987654321"));

    Map&lt;String, List&lt;? extends Number&gt;&gt; hashMap = Map.of("list1", list1,
                                                         "list2", list2);

    System.out.println(Adder.add(hashMap));
}