Update the map in Riak by removing the counter mapped to the provided key.
@param key the key the counter is mapped to.
@return a reference to this object.
356736
public MapUpdate removeCounter(String key)
    {
        BinaryValue k = BinaryValue.create(key);
        removes.add(new MapOp.MapField(MapOp.FieldType.COUNTER, k));
        return this;
    }
380637
public synchronized final V get(K key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V result = map.get(key);
        if (result != null) {
            return result;
        }

        result = create(key);

        if (result != null) {
            map.put(key, result);
            trimToSize(maxSize);
        }
        return result;
    }
1018939
@Override
	public Object remove(java.lang.Object key) {
		return internalMap.remove(key);
	}
1102820
@Override
    public GroovyRunner remove(Object key) {
        if (key == null) {
            return null;
        }
        Map<String, GroovyRunner> map = getMap();
        writeLock.lock();
        try {
            cachedValues = null;
            return map.remove(key);
        } finally {
            writeLock.unlock();
        }
    }
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;
	}
390659
public RiakMap getMap(BinaryValue key)
    {
        if (entries.containsKey(key))
        {
            for (RiakDatatype dt : entries.get(key))
            {
                if (dt.isMap())
                {
                    return dt.getAsMap();
                }
            }
        }
        return null;
    }
989927
public V remove(Object key) {
        final int index = indexOfKey(key);
        if (index >= 0) {
            return removeAt(index);
        }

        return null;
    }
534365
@Nullable
  public CloseableReference<V> get(final K key) {
    Preconditions.checkNotNull(key);
    Entry<K, V> oldExclusive;
    CloseableReference<V> clientRef = null;
    synchronized (this) {
      oldExclusive = mExclusiveEntries.remove(key);
      Entry<K, V> entry = mCachedEntries.get(key);
      if (entry != null) {
        clientRef = newClientReference(entry);
      }
    }
    maybeNotifyExclusiveEntryRemoval(oldExclusive);
    maybeUpdateCacheParams();
    maybeEvictEntries();
    return clientRef;
  }
1291792
public synchronized void remove(Object key)
	{
		final Object o = map.remove(key);
		if (o != null)
			tree.remove(o);
	}
1342594
@Override
  public V remove(Object key)
  {
    if (key == null) {
      V value = _nullValue;
      _nullValue = null;
      return value;
    }

    int hash = key.hashCode() & _mask;
    int count = _size + 1;

    V item = null;

    for (; count > 0; count--) {
      item = _values[hash];

      if (item == null)
        return null;

      if (_keys[hash].equals(key)) {
        _keys[hash] = null;
        _values[hash] = null;
        _size--;

        refillEntries(hash);
        break;
      }

      hash = (hash + 1) & _mask;
    }

    if (count < 0)
      throw new RuntimeException("internal cache error");

    return item;
  }
599593
@Override
    public V remove(Object key) {
        int index = key == null ? indexOfNull() : indexOf(key, key.hashCode());
        if (index >= 0) {
            return removeAt(index);
        }

        return null;
    }
1239828
public synchronized void remove(final String key) {
		try {
			list.remove(key);
		} catch (Exception e) {
			log.log(Level.SEVERE, "remove", e);
		}
		super.remove(key);
	}
569511
public V remove (int key)
    {
        Record<V> removed = removeImpl(key, true);
        return (removed == null) ? null : removed.value;
    }
1098424
public Object remove(Serializable key) {
        if(component.initialStateMarked()) {
            Object retVal = deltaMap.remove(key);

            if(retVal==null) {
                return defaultMap.remove(key);
            }
            else {
                defaultMap.remove(key);
                return retVal;
            }
        }
        else {
            return defaultMap.remove(key);
        }
    }
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;
	}
131324
@Override
    public V remove(@NonNull K key) {
        V removed = super.remove(key);
        mHashMap.remove(key);
        return removed;
    }
694359
private <K> void increase(Map<K, Integer> map, K key) {
        map.put(key, map.getOrDefault(key, 0)+1);
    }