Removes all mappings for the given key and returns the first value if there where mappings or <code>null</code> if not.

@param key
@return the first value of the given key or null.
541213
public V remove(Object key) {
        List<V> res = map.remove(key);
        if (res == null) {
            return null;
        }
        assert (!res.isEmpty());
        return res.iterator().next();
    }
260479
public Map<Object, Object> removeAll(final Object key) {
		lock.writeLock().lock();
		try {
			final Map<Object, Object> result = new HashMap<Object, Object>();
			Object resultObj;
			if (containsValidPrefix(key)) {
				resultObj = properties.remove(key);
				if (resultObj != null) {
					result.put(key, resultObj);
				}
			} else {
				for (final String prefix : getPrefixes()) {
					final String pkey = prefix + PrefixConfig.PREFIXDELIMITER + key;
					resultObj = properties.remove(pkey);
					if (resultObj != null) {
						result.put(pkey, resultObj);
					}
				}
				resultObj = properties.remove(key);
				if (resultObj != null) {
					result.put(key, resultObj);
				}
			}
			return result;
		} finally {
			lock.writeLock().unlock();
		}
	}
894362
@Nullable
  public <T> Iterable<T> getAll(final Key<T> key) {
    for (int i = 0; i < size; i++) {
      if (bytesEqual(key.asciiName(), name(i))) {
        return new IterableAt<>(key, i);
      }
    }
    return null;
  }
860182
public final V remove(K key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V previous;
        synchronized (this) {
            previous = map.remove(key);
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }

        if (previous != null) {
            entryRemoved(false, key, previous, null);
        }

        return previous;
    }
1236537
public V remove (K key) {
		int hashCode = key.hashCode();
		int index = hashCode & mask;
		if (key.equals(keyTable[index])) {
			keyTable[index] = null;
			V oldValue = valueTable[index];
			valueTable[index] = null;
			size--;
			return oldValue;
		}

		index = hash2(hashCode);
		if (key.equals(keyTable[index])) {
			keyTable[index] = null;
			V oldValue = valueTable[index];
			valueTable[index] = null;
			size--;
			return oldValue;
		}

		index = hash3(hashCode);
		if (key.equals(keyTable[index])) {
			keyTable[index] = null;
			V oldValue = valueTable[index];
			valueTable[index] = null;
			size--;
			return oldValue;
		}

		if (bigTable) {
			index = hash4(hashCode);
			if (key.equals(keyTable[index])) {
				keyTable[index] = null;
				V oldValue = valueTable[index];
				valueTable[index] = null;
				size--;
				return oldValue;
			}
		}

		return removeStash(key);
	}
680952
@NullSafe
  @Override
  public void evict(KEY key) {

    if (key != null) {
      this.map.remove(key);
    }
  }
1018939
@Override
	public Object remove(java.lang.Object key) {
		return internalMap.remove(key);
	}
1334743
public String get(String key) {
        Preconditions.checkNotNull(key, "key is null");
        return values.get(key);
    }
1293100
public V first(K key) {
		key = sanitizeKey(key);
		List<V> values = map.get(key);

		/*
		 * The list can be null, but never empty. Empty lists are removed from
		 * the map.
		 */
		return (values == null) ? null : values.get(0);
	}
355403
public int delete(String key)
    {
        if (key == null)
        {
            return -1;
        }
        int curState = 1;
        int[] ids = this.charMap.toIdList(key);

        int[] path = new int[ids.length + 1];
        int i = 0;
        for (; i < ids.length; i++)
        {
            int c = ids[i];
            if ((getBase(curState) + c >= getBaseArraySize())
                || (getCheck(getBase(curState) + c) != curState))
            {
                break;
            }
            curState = getBase(curState) + c;
            path[i] = curState;
        }
        int ret = -1;
        if (i == ids.length)
        {
            if (getCheck(getBase(curState) + UNUSED_CHAR_VALUE) == curState)
            {
                --this.size;
                ret = getLeafValue(getBase(getBase(curState) + UNUSED_CHAR_VALUE));
                path[(path.length - 1)] = (getBase(curState) + UNUSED_CHAR_VALUE);
                for (int j = path.length - 1; j >= 0; --j)
                {
                    boolean isLeaf = true;
                    int state = path[j];
                    for (int k = 0; k < this.charMap.getCharsetSize(); k++)
                    {
                        if (isLeafValue(getBase(state)))
                        {
                            break;
                        }
                        if ((getBase(state) + k < getBaseArraySize())
                            && (getCheck(getBase(state) + k) == state))
                        {
                            isLeaf = false;
                            break;
                        }
                    }
                    if (!isLeaf)
                    {
                        break;
                    }
                    addFreeLink(state);
                }
            }
        }
        return ret;
    }
1279411
public final Object remove(Object key)
    {
        java.util.Map subMap = getSubMap(key);
        synchronized (subMap) {
            return subMap.remove(key);
        } // synchronized (subMap).
    }
15115
public V remove(final int key) {
		IntLinkedEntry<V> entry = removeEntry(key);
		if (entry == null) {
			return null;
		}
		V ret = entry.value;
		reuseAfterDelete(entry);

		return ret;
	}
928473
private static String stripKey(final String key) {
        int index = key.indexOf(".");
        if (index > 0) {
            return key.substring(0, index);
        }
        return null;
    }
131324
@Override
    public V remove(@NonNull K key) {
        V removed = super.remove(key);
        mHashMap.remove(key);
        return removed;
    }
920311
public T remove(final int key) {
		int index = ((key & 0x7FFFFFFF) % elementKeys.length);

		int entry = elementKeys[index];
		if (key == entry) {
			final T oldvalue = elementValues[index];
			elementKeys[index] = Integer.MIN_VALUE;
			elementValues[index] = null;
			elementCount--;
			return oldvalue;
		}
		return null;
	}
1279394
public String getFirst(final String key) {
    final ArrayList<String> values = super.get(key);
    return values == null ? null : values.get(0);
  }
1168986
public V remove(Object key) {
        clean();

        ValueRef<K, V> valueRef = mValues.remove(key);
        V value;

        if (valueRef != null && (value = valueRef.get()) != null) {
            valueRef.clear();
            return value;
        }

        return null;
    }