code: @Override
      public final V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
          if (mappingFunction == null)
              throw new NullPointerException();
          long hash;
          return segment(segmentIndex(hash = keyHashCode(key)))
                  .computeIfAbsent(this, hash, key, mappingFunction);
      }
docs: If the specified key is not already associated with a value (or is mapped to {@code null}),
  attempts to compute its value using the given mapping function and enters it into this map
  unless {@code null}.
  
  <p>If the function returns {@code null} no mapping is recorded. If the function itself throws
  an (unchecked) exception, the exception is rethrown, and no mapping is recorded. The most
  common usage is to construct a new object serving as an initial mapped value or memoized
  result, as in:
  
  <pre> {@code
  map.computeIfAbsent(key, k -> new Value(f(k)));
  }</pre>
  
  <p>Or to implement a multi-value map, {@code Map<K,Collection<V>>},
  supporting multiple values per key:
  
  <pre> {@code
  map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
  }</pre>
  
  @param key key with which the specified value is to be associated
  @param mappingFunction the function to compute a value
  @return the current (existing or computed) value associated with
  the specified key, or null if the computed value is null
  @throws NullPointerException if the mappingFunction is null