Remove the specific key

@param key the key
@param <V> the expected return type
@return the previous value associated with <tt>key</tt>, or <tt>null</tt> if there was no mapping for <tt>key</tt>.
325925
@SuppressWarnings("unchecked")
  public static <V> V remove(String key) {
    return (V) share.get().remove(key);
  }
440521
@Override
    public String remove(Object key) {

        String result = m_configurationStrings.remove(key);
        m_configurationObjects.remove(key);
        return result;
    }
1279411
public final Object remove(Object key)
    {
        java.util.Map subMap = getSubMap(key);
        synchronized (subMap) {
            return subMap.remove(key);
        } // synchronized (subMap).
    }
913157
public void remove(String key) {
        int i = indexOfKey(key);
        if (i != NotFound)
            remove(i);
    }
394023
public int removeKey(final K key)
    {
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(key, mask);

        int value;
        while (missingValue != (value = values[index]))
        {
            if (key.equals(keys[index]))
            {
                keys[index] = null;
                values[index] = missingValue;
                --size;

                compactChain(index);
                break;
            }

            index = ++index & mask;
        }

        return value;
    }
1264470
public void removeKey(String key) {
        if (key != null && !key.isEmpty()) {
            for (int i=0; i<map.size(); i++) {
                KeyValue kv = map.get(i);
                if (key.equals(kv.getKey())) {
                    map.remove(i);
                    return;
                }
            }
        }
    }
1018939
@Override
	public Object remove(java.lang.Object key) {
		return internalMap.remove(key);
	}
141653
public V remove (K key)
    {
        SoftReference<V> ref = _map.remove(key);
        return (ref == null) ? null : ref.get();
    }
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;
    }
380579
public V getAndRemove(String key) {
		try {
			V objToShare = retrieveSharedQueue(key).take();
			mediations.remove(key);
			return objToShare;
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
781278
public synchronized void remove(E key)
    {    
        Entry<E, T> entry = map.get(key);
        this.tail.prev = entry.prev;
        entry.prev.next = this.tail;
        map.remove(entry.key);
        this.length--;   
    }
1225113
@SuppressWarnings({"unused", "WeakerAccess"})
    public void removeValueForKey(final String key) {
        postAsyncSafely("removeValueForKey", new Runnable() {
            @Override
            public void run() {
                _removeValueForKey(key);
            }
        });
    }
1172633
public long remove(K key) {
    AtomicLong atomic = map.get(key);
    if (atomic == null) {
      return 0L;
    }

    for (;;) {
      long oldValue = atomic.get();
      if (oldValue == 0L || atomic.compareAndSet(oldValue, 0L)) {
        // only remove after setting to zero, to avoid concurrent updates
        map.remove(key, atomic);
        // succeed even if the remove fails, since the value was already adjusted
        return oldValue;
      }
    }
  }
649
public final void remove(final String key) {
        final Property prop = find(key);
        if (prop != null) {
            prop.setValue(null);
        }
    }
1060112
public void remove(String key) {
    Iterator<Pair<String, ArrayList<String>>> it = store.iterator();
    while (it.hasNext()) {
      String thisKey = it.next().first;
      if (key.equals(thisKey)) {
        it.remove();
        break;
      }
    }
  }
724627
public Object remove(Object key)
    {
        synchronized (objects)
        {
            Object remove = objects.remove(key);
            objectTimeStamps.remove(key);
            if (remove != null)
            {
                findNextExpireTime();
            }
            return remove;
        }
    }
882526
public Object remove(Object key) {
        mCacheMap.remove(key);
        return mBackingMap.remove(key);
    }