Get and return the value in the Map that corresponds to the specified key, or if there is no value
at the key, return the result of evaluating the specified {@link Function0}.
777169
public static <K, V> V getIfAbsent(Map<K, V> map, K key, Function0<? extends V> instanceBlock)
    {
        if (map instanceof UnsortedMapIterable)
        {
            return ((MapIterable<K, V>) map).getIfAbsent(key, instanceBlock);
        }
        V result = map.get(key);
        if (MapIterate.isAbsent(result, map, key))
        {
            result = instanceBlock.value();
        }
        return result;
    }
692912
Object get(int key) {
    return (key >= 0 && key < list.size()) ? list.get(key) : null;
  }
1326042
public V get (K key)
    {
        V value = null;
        SoftReference<V> ref = _map.get(key);
        if (ref != null) {
            value = ref.get();
            if (value == null) {
                _map.remove(key);
            }
        }
        return value;
    }
527987
public V get(K key) {
		V value = null;
		long stamp = lock.tryOptimisticRead();
		if (stamp != 0) {
			try {
				value = map.get(key);
			} catch (Exception modified) {
				stamp = 0;
			}
		}
		if (!lock.validate(stamp) || stamp == 0) {
			stamp = lock.readLock();
			try {
				value = map.get(key);
			} finally {
				lock.unlockRead(stamp);
			}
		}
		return value;
	}
435740
public boolean get(int key, boolean valueIfKeyNotFound) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i < 0) {
            return valueIfKeyNotFound;
        } else {
            return mValues[i];
        }
    }
1085516
public String getValueForDisplayValue(final String key) {
        if (mapDisplayValuesToValues.containsKey(key)) {
            return mapDisplayValuesToValues.get(key);
        }
        return key;
    }
296477
function(k) {
            	if(!k)
            	    k = 0;
            	
            	return this.map(function(x, i, j) {
            	    return j - i >= k ? x : 0;
            	});
                }
184388
@Override
  public V get(Object key)
  {
    if (key == null)
      return _nullValue;

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

    K []keys = _keys;

    for (; count > 0; count--) {
      K mapKey = keys[hash];

      if (mapKey == null)
        return null;

      if (key.equals(_keys[hash]))
        return _values[hash];

      hash = (hash + 1) & _mask;
    }

    return null;
  }
320551
def get_as_map(self, key):
        
        value = self.get(key)
        return AnyValueMap.from_value(value)
481979
long get(final long key) {
    final int probe = hashProbe(key);
    if (states[probe] > 0) {
      assert (keys[probe] == key);
      return values[probe];
    }
    return 0;
  }
210129
public static <K,V> Function<K,V> lookup(Map<K, V> map) {
        return Functions.forMap(map);
    }
1211383
public static <K, V> V getIfAbsentDefault(Map<K, V> map, K key, V defaultValue)
    {
        V result = map.get(key);
        if (MapIterate.isAbsent(result, map, key))
        {
            result = defaultValue;
        }
        return result;
    }
1281449
@SuppressWarnings("unchecked")
	protected Map<String, Object> getNestedMap(Map<String, Object> map, String key) {
		Object value = map.get(key);
		if (value == null) {
			return Collections.emptyMap();
		}
		return (Map<String, Object>) value;
	}
1189440
public V get(final K1 firstKey, final K2 secondKey) {
		// existence check on inner map
		final HashMap<K2, V> innerMap = map.get(firstKey);
		if( innerMap == null ) {
			return null;
		}
		return innerMap.get(secondKey);
	}
242007
public V get(Object key) {
        final int index = indexOfKey(key);
        return index >= 0 ? (V)mArray[(index<<1)+1] : null;
    }
946558
public Object get(Object key) {
        Object value = mMap.get(key);
        if (value instanceof List) {
            return ((List)value).get(0);
        }
        else {
            return value;
        }
    }
149677
public V get(K key) {
    if (root == null) {
      return null;
    }
    return root.get(key, key.hashCode(), 0);
  }