[PATCH] 8202521: Add overloaded methods of Map#compute, Map#computeIfAbsent, Map#computeIfPresent (original) (raw)

Thu May 3 17:43:10 UTC 2018

map.computeIfAbsent("key", ArrayList::new).add(1);
* {@link java.util.ConcurrentModificationException} if the
* supplier modified this map during computation.
*
* @throws ConcurrentModificationException if it is detected that the
* supplier modified this map
*/
 return computeIfAbsent(key, k -> supplier.get());
* {@inheritDoc}
*
* This method will, on a best-effort basis, throw a
* {@link java.util.ConcurrentModificationException} if the remapping
* function modified this map during computation.
*
 /**
* If the specified key is not already associated with a value (or is
* to {@code null}), attempts to compute its value using the given
* and enters it into this map unless {@code null}.
*
* If the supplier returns {@code null}, no mapping is recorded.
* If the supplier 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 that does not depend on the key,
* as in:
*
* <pre> {@code
* map.computeIfAbsent(key, () -> new Value());
* }</pre>
*
* Or to implement a multi-value map, {@code Map<K,Collection<V>>},
* supporting multiple values per key:
*
* <pre> {@code
* map.computeIfAbsent(key, HashSet::new).add(v);
* }</pre>
*
* The supplier should not modify this map during computation.
*
* @implSpec
* The default implementation is equivalent to the following steps for
* {@code map}, then returning the current value or {@code null} if now
* absent:
*
* <pre> {@code
* if (map.get(key) == null) {
* V newValue = supplier.get();
* if (newValue != null)
* map.put(key, newValue);
* }
* }</pre>
*
* The default implementation makes no guarantees about detecting
* supplier modifies this map during computation and, if appropriate
* reporting an error. Non-concurrent implementations should
* override this method and, on a best-effort basis, throw a
* {@code ConcurrentModificationException} if it is detected that the
* supplier modifies this map during computation. Concurrent
* implementations should override this method and, on a best-effort
* throw an {@code IllegalStateException} if it is detected that the
* supplier modifies this map during computation and as a result
* computation would never complete.
*
* The default implementation makes no guarantees about
* or atomicity properties of this method. Any implementation providing
* atomicity guarantees must override this method and document its
* concurrency properties. In particular, all implementations of
* subinterface {@link java.util.concurrent.ConcurrentMap} must
* whether the supplier is applied once atomically only if the value
* is not present.
*
* @param key key with which the specified value is to be associated
* @param supplier the supplier 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 specified key is null and
* this map does not support null keys, or the supplier
* is null
* @throws UnsupportedOperationException if the {@code put} operation
* is not supported by this map
* (<a
* @throws ClassCastException if the class of the specified key or
* prevents it from being stored in this map
* (<a
* @throws IllegalArgumentException if some property of the specified
* or value prevents it from being stored in this map
* (<a
* @since 11
*/
 return computeIfAbsent(key, k -> supplier.get());
 // null -> null
 assertTrue(map.containsKey(null), "null key absent");
 assertNull(map.get(null), "value not null");
 assertSame(map.computeIfAbsent(null, () -> null), null, "not
 assertTrue(map.containsKey(null), "null key absent");
 assertNull(map.get(null), "value not null");
 assertSame(map.computeIfAbsent(null, () -> EXTRA_VALUE),
 // null -> EXTRA_VALUE
 assertTrue(map.containsKey(null), "null key absent");
 assertSame(map.get(null), EXTRA_VALUE, "not expected value");
 assertSame(map.remove(null), EXTRA_VALUE, "removed unexpected
 // null -> <absent>
 assertFalse(map.containsKey(null), "null key present");
 assertSame(map.computeIfAbsent(null, () -> EXTRA_VALUE),
 // null -> EXTRA_VALUE
 assertTrue(map.containsKey(null), "null key absent");
 assertSame(map.get(null), EXTRA_VALUE, "not expected value");
@Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all
 @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all
 // 1 -> 1
 assertTrue(map.containsKey(KEYS[1]));
 Object expected = map.get(KEYS[1]);
 assertTrue(null == expected || expected == VALUES[1], description
 expected = (null == expected) ? EXTRA_VALUE : expected;
 assertSame(map.computeIfAbsent(KEYS[1], () -> EXTRA_VALUE),
 assertSame(map.get(KEYS[1]), expected, description);
 // EXTRA_KEY -> <absent>
 assertFalse(map.containsKey(EXTRA_KEY));
 assertNull(map.computeIfAbsent(EXTRA_KEY, () -> null));
 assertFalse(map.containsKey(EXTRA_KEY));
 assertSame(map.computeIfAbsent(EXTRA_KEY, () -> EXTRA_VALUE),
 // EXTRA_KEY -> EXTRA_VALUE
 assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);
@Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=withNull

[PATCH] 8202521: Add overloaded methods of Map#compute, Map#computeIfAbsent, Map#computeIfPresent (original) (raw)

HG changeset patch

User jhg023

Date 1525366367 25200

Thu May 03 09:52:47 2018 -0700

Node ID 395def2871e8d077b382d722efc59b38373327d1

Parent ea246151be08995543d0c9281099608bc9207a19