Returns the value to which the specified key is mapped in this hashtable.
@param   key a key in the hashtable.
@return  The value to which the key is mapped in this hashtable;
<code>null</code> if the key is not mapped to any value in
this hashtable.
338281
public Object get(Object key) {
      NonSyncHashtableEntry tab[] = table;
      int hash = key.hashCode();
      int index = (hash & 0x7FFFFFFF) % tab.length;
      for (NonSyncHashtableEntry e = tab[index]; e != null; e = e.next) {
         if ((e.hash == hash) && e.key.equals(key)) {
            return e.value;
         }
      }
      return null;
   }
1033216
public V get(final int key) {
		final int index = (key & 0x7FFFFFFF) % elementData.length;

		IntLinkedEntry<V> m = elementData[index];
		while (m != null) {
			if (key == m.key) {
				if (accessOrder) {
					// if (log.isDebugEnabled()) log.debug("reliking " + this.key);
					m.remove();
					m.addBefore(header);
				}
				return m.value;
			}
			m = m.nextInSlot;
		}
		return null;
	}
908897
public V get(String key)
    {
        int index = exactMatchSearch(key);
        if (index >= 0)
        {
            return getValueAt(index);
        }

        return null;
    }
873181
public String get(String key) {
    	if(requestedKeys == null) requestedKeys = new HashSet<String>();
    	String value = map.get(key);
    	requestedKeys.add(key);
    	return value;
    }
49148
@Override
    public boolean containsKey(Object key) {
        return key == null ? (indexOfNull() >= 0) : (indexOf(key, key.hashCode()) >= 0);
    }
838905
public Map.Entry<K, V> getEntry(Object key) {
    EntryImpl<K, V> entry = _entries[keyHash(key) & _mask];
    while (entry != null) {
      if (key.equals(entry._key)) { return entry; }
      entry = entry._next;
    }
    return null;
  }
743657
@SuppressWarnings("unchecked")
  public <T> T getRequiredValue(String key) {

    T value = (T) map.get(key);
    if (value == null) {
      throw new RequiredParameterException();
    }
    return value;
  }
263687
final Entry<K, V> getEntry(Object key) {
	int hash = (key == null) ? 0 : hash(key);
	for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
	    if (e.hash == hash && ((e.key) == key || (key != null && key.equals(e.key)))) return e;
	}
	return null;
    }
1189794
public final String get(final String key) {
        final Property prop = find(key);
        if (prop == null) {
            return null;
        }
        return prop.getValue();
    }
1066749
public String getKey(String key) {
        try {
            String _response = evCache.<String>get(key);
            return _response;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
541855
public boolean containsValues(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetValues().getMap().containsKey(key);
  }
1085516
public String getValueForDisplayValue(final String key) {
        if (mapDisplayValuesToValues.containsKey(key)) {
            return mapDisplayValuesToValues.get(key);
        }
        return key;
    }
660067
@Override
    public V get(Object key) {
        // Keys can not be null
        if (key == null) {
            throw new NullPointerException("Key can not be null");
        }
        if (!(key instanceof String)) {
            throw new ClassCastException("Only String keys are supported -- got " + key.getClass());
        }
        // Empty keys are stored in the root
        if (key.equals("")) {
            if (root.getRight() == null) {
                return null;
            } else {
                return root.getRight().getValue();
            }
        }

        // Find nearest node
        PatriciaNode<V> nearest = findNearestNode((String) key);

        // If the nearest node matches key, we have a match
        if (key.equals(nearest.getKey())) {
            return nearest.getValue();
        } else {
            return null;
        }
    }
1250436
private String getReqValue(Map<String, String[]> map, String key) {

        return map.get(key) != null ? map.get(key)[0] : null;
    }
1094193
public int getExisting(Object key) {
        if (key == null) { key = UniqueTag.NULL_VALUE; }
        int index = findIndex(key);
        if (0 <= index) {
            return values[index];
        }
        // Key must exist
        Kit.codeBug();
        return 0;
    }
889844
public T get(String key) {
        purge();
        final Value val = map.get(key);
        final long time = System.currentTimeMillis();
        return val != null && time < val.expire ? val.token : null;
    }
630515
public synchronized V get(final K key) {
		if (!validState) {
			throw new InvalidStateException();
		}
		if (_isEmpty()) {
			return null;
		}
		if (key == null) {
			return null;
		}
		try {
			final LeafNode<K, V> node = findLeafNode(key, false);
			if (node == null) {
				return null;
			}
			int slot = node.findSlotByKey(key);
			if (slot >= 0) {
				return node.values[slot];
			}
			return null;
		} finally {
			releaseNodes();
		}
	}