Remove the property with the given key. The internal property object is not deleted itself but it's value is set to <code>null</code>
and the method <code>isDeleted()</code> will return <code>true</code> .

@param key
Key for the property to remove.
649
public final void remove(final String key) {
        final Property prop = find(key);
        if (prop != null) {
            prop.setValue(null);
        }
    }
50554
public static void remove(String key) {
        if (setContext()) {
            m_context.remove(key);
        } else {
            m_defaultContext.remove(key);
        }
    }
1231420
public void removeKey(int key) { 
    	if (key == first.value) {
    		removeMin();
    		return;
    	}
    	if (key == last.value) {
    		removeMax();
    		return;
    	}
    	// if both children of root are black, set root to red
    	if ((root.left == null || !root.left.red) && (root.right == null || !root.right.red))
            root.red = true;

        root = removeKey(root, key);
        if (root != null) root.red = false;
    }
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);
	}
707240
@Override
  public void deleteRow(K key) {
    createMutator().delete(key, getColumnFamily(), null, null);
  }
796565
public Object remove(Object key)
    {
        Object retVal = null;

        if (null == key) throw new IllegalArgumentException("key must not be null");
        if (this.containsKey(key))
        {
            retVal = super.remove(key);

            for (int i = 0; i < this.order.size(); i++)
            {
                Object obj = this.order.get(i);
                if (obj.equals(key))
                {
                    this.order.remove(i);
                    break;
                }
            }
        }
        return retVal;
    }
632492
public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            System.arraycopy(mKeys, i + 1, mKeys, i, mSize - (i + 1));
            System.arraycopy(mValues, i + 1, mValues, i, mSize - (i + 1));
            mSize--;
        }
    }
89398
public V remove(@NonNull K key) {
        Entry<K, V> toRemove = get(key);
        if (toRemove == null) {
            return null;
        }
        mSize--;
        if (!mIterators.isEmpty()) {
            for (SupportRemove<K, V> iter : mIterators.keySet()) {
                iter.supportRemove(toRemove);
            }
        }

        if (toRemove.mPrevious != null) {
            toRemove.mPrevious.mNext = toRemove.mNext;
        } else {
            mStart = toRemove.mNext;
        }

        if (toRemove.mNext != null) {
            toRemove.mNext.mPrevious = toRemove.mPrevious;
        } else {
            mEnd = toRemove.mPrevious;
        }

        toRemove.mNext = null;
        toRemove.mPrevious = null;
        return toRemove.mValue;
    }
913157
public void remove(String key) {
        int i = indexOfKey(key);
        if (i != NotFound)
            remove(i);
    }
654528
public final V remove(Object key) {
	
	if(key == null) return null;

	int key_hash_code = key.hashCode();
	BinTreeNode<K,V> prev = null;
	int son = 0;
	BinTreeNode<K,V> node = root;

	while(node != null) {
	    if(key_hash_code < node.keyHashCode) {
		prev = node;
		node = node.left;
		son  = 0;
	    }
	    else {
		if((key_hash_code > node.keyHashCode) || !node.key.equals(key)) {
		    prev = node;
		    node = node.right;
		    son  = 1;
		}
		else {
		    size--;
		    cachedHashCode -= node.hashCode();
		    return remove_node(node, prev, son);
		}
	    }
	}
	return null;
    }
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;
	}
141653
public V remove (K key)
    {
        SoftReference<V> ref = _map.remove(key);
        return (ref == null) ? null : ref.get();
    }
1228774
public void remove(String key) {
        Map<String, String> map = inheritableThreadLocal.get();
        if (map != null) {
            map.remove(key);
        }
    }
331489
@Override
    public V remove(Object key) {
        CachedValue<K, V> entry = map.remove(key);
        if (entry != null) {
            onValueRemove(entry);
            if (!isValueExpired(entry)) {
                return (V) entry.getValue();
            }
        }
        return null;
    }
1291792
public synchronized void remove(Object key)
	{
		final Object o = map.remove(key);
		if (o != null)
			tree.remove(o);
	}
989927
public V remove(Object key) {
        final int index = indexOfKey(key);
        if (index >= 0) {
            return removeAt(index);
        }

        return null;
    }