Put.

@param key the key
@param v the v
@return the entry
353756
protected Entry<K, V> put(@NonNull K key, @NonNull V v) {
        Entry<K, V> newEntry = new Entry<>(key, v);
        mSize++;
        if (mEnd == null) {
            mStart = newEntry;
            mEnd = mStart;
            return newEntry;
        }

        mEnd.mNext = newEntry;
        newEntry.mPrevious = mEnd;
        mEnd = newEntry;
        return newEntry;

    }
392366
public void put(K key, Class<? extends V> cls) {
    classMap.put(key, new Entry<>(cls));
  }
514537
public void put(K key,V value){
		List<V> list;
		if (map.containsKey(key)){
			list=(List<V>)map.get(key);
		} else {
			list=new Vector<V>();
			map.put(key,list);
		}		
		list.add(value);		
	}
873746
public final Object put(Object key, Object value) {
        return internalData.put(key, value);
    }
446002
public void add(Key k, Value v) throws IllegalArgumentException {
    add(k, v.get());
  }
173019
@SuppressWarnings("unchecked")
    public M with(final String key, final String value) {
        put(key, value);
        return (M) this;
    }
573170
@Override
    public V put(final K key, final V value) {
        map.merge(key, value, defaultMerger);
        return previousValue;
    }
991618
public Object put(int key, Object value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "put");
        }
        if (value == null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "value == null");
            }
            throw new NullPointerException("Missing value");
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "key " + key);
        }
        // check the table
        FastSyncHashBucket bucket = getBucket(key);
        Object retVal = syncGetValueFromBucket(bucket, key, false);
        if (retVal != null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                Tr.exit(tc, "put: key is already defined in bucket...returning value from bucket and new key value will be discarded.");
            return retVal;
        }
        // new entry
        FastSyncHashEntry e = new FastSyncHashEntry(key, value);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "put: put new key and value into bucket");
        }
        return syncPutIntoBucket(bucket, e);
    }
630044
public Object put(String key, Object o) {
		return _properties.put(key, o);
	}
1309776
public V _put(K key, V value) {
        V retval=map.put(key, value);
        for(Notification notif:notifs)
            notif.entrySet(key, value);
        return retval;
    }
546528
final public Vector vector(K key)
    {
        Vector vector = storage.get(key);
        if (vector == null) return null;
        return vector;
    }
1183076
public void put(K[] key, V value) {
        Node child = root.get(key[0]);
        if (child == null) {
            child = new Node(key[0]);
            root.put(key[0], child);
        }
        child.addChild(key, value, 1);
    }
938718
public void put(K key, V value) {
        final int hash = key.hashCode();
        final int row = hash / SIZE_ROW;
        final int column = hash & (SIZE_ROW - 1); // DON'T use the % operator as we
                                                  // need the result to be
                                                  // non-negative (-1%16 is -1 for
                                                  // example)
        validateKey(hash);
        validateTable(row);
        this.values[row][column] = value;
        this.keys[hash] = key;
    }
160171
public MapBuilder<K, V> put(K k, V v) {
		map.put(k, v);
		return this;
	}
906995
public synchronized StorableProperties put(String key, Object val) {
        if (!key.equals(toLowerCase(key)))
            throw new IllegalArgumentException("Do not use upper case keys (" + key + ") for StorableProperties since 0.7");

        map.put(key, val.toString());
        return this;
    }
369968
public T put(final int key, final T value) {
		int index = ((key & 0x7FFFFFFF) % elementKeys.length);
		T oldvalue = null;

		long entry = elementKeys[index];
		if (entry == Integer.MIN_VALUE) {
			++elementCount;
		} else {
			oldvalue = elementValues[index];
			collisions++;
		}
		elementKeys[index] = key;
		elementValues[index] = value;
		return oldvalue;
	}
951925
public void put(final K key, V value) {
        ManagedReference<V> ref = new ManagedReference<V>(bundle, value) {
            @Override
            public void finalizeReference() {
                super.finalizeReference();
                internalMap.remove(key, get());
            }
        };
        internalMap.put(key, ref);
    }