Calculate the slot from the given key.

@param key the key
@return slot
544142
public static int getSlot(ByteBuffer key) {

        int limit = key.limit();
        int position = key.position();

        int start = indexOf(key, SUBKEY_START);
        if (start != -1) {
            int end = indexOf(key, start + 1, SUBKEY_END);
            if (end != -1 && end != start + 1) {
                key.position(start + 1).limit(end);
            }
        }

        try {
            if (key.hasArray()) {
                return CRC16.crc16(key.array(), key.position(), key.limit() - key.position()) % SLOT_COUNT;
            }
            return CRC16.crc16(key) % SLOT_COUNT;
        } finally {
            key.position(position).limit(limit);
        }
    }
108608
@Override
	public synchronized CacheObject get(final Object key)
	{
		final CacheObject o = map.get(key);
		if (o != null) {
			updateAccess(o);
			++hits;
		}
		else
			++misses;
		return o;
	}
898372
public String get(String key) {
		if(key==null)return null;
		int idx=0,equal=0,amp=0;
		while(idx>=0 && (equal = tresp.indexOf('=',idx))>=0) {
			amp = tresp.indexOf('&',equal);
			if(key.regionMatches(0, tresp, idx, equal-idx)) {
				return amp>=0?tresp.substring(equal+1, amp):tresp.substring(equal+1); 
			}
			idx=amp+(amp>0?1:0);
		}
		return null;
	}
1176685
public V get(final K key) {
    Entry<V> entry = computeIfAbsent(key);
    return entry.getValue();
  }
669055
@SuppressWarnings("unchecked")
    public <T> T getCustom(String key) {
        return (T) custom.get(key);
    }
1184595
@Override
    public final int getInt(final String key) {
        Integer result = optInt(key);
        if (result == null) {
            throw new ObjectMissingException(this, key);
        }
        return result;
    }
912321
public int get(final int key)
    {
        final int[] entries = this.entries;
        final int initialValue = this.initialValue;
        @DoNotSub final int mask = entries.length - 1;
        @DoNotSub int index = Hashing.evenHash(key, mask);

        int value = initialValue;
        while (entries[index + 1] != initialValue)
        {
            if (entries[index] == key)
            {
                value = entries[index + 1];
                break;
            }

            index = next(index, mask);
        }

        return value;
    }
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;
  }
380637
public synchronized final V get(K key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V result = map.get(key);
        if (result != null) {
            return result;
        }

        result = create(key);

        if (result != null) {
            map.put(key, result);
            trimToSize(maxSize);
        }
        return result;
    }
427738
public V retrieve(K key) {
        Ref<V> ref = map.get(key);
        return ref == null ? null : ref.get();
    }
1022418
public int getInt(int key)
    {
        Object value = map.get(key);
        if (!(value instanceof Integer))
        {
            return 0;
        }
        Integer result = (Integer)value;
        return result;
    }
852959
@Override
    public ScriptableObject.Slot query(Object key, int index)
    {
        if (slots == null) {
            return null;
        }

        final int indexOrHash = (key != null ? key.hashCode() : index);
        final int slotIndex = getSlotIndex(slots.length, indexOrHash);
        for (ScriptableObject.Slot slot = slots[slotIndex];
            slot != null;
            slot = slot.next) {
            Object skey = slot.name;
            if (indexOrHash == slot.indexOrHash &&
                (skey == key ||
                    (key != null && key.equals(skey)))) {
                return slot;
            }
        }
        return null;
    }
514000
public synchronized CacheObject get(Object key)
	{
		final CacheObject o = (CacheObject) map.get(key);
		if (o != null) {
			tree.remove(o);
			updateAccess(o);
			tree.put(o, o);
			++hits;
		}
		else
			++misses;
		return o;
	}
578608
public static function getSlot($key)
    {
        if (!isset(self::$slots[$key])) {
            self::$slots[$key] = new RegisterSlot($key);
        }

        return self::$slots[$key];
    }
185468
@Override
    public V get(Object key) {
        final int index = key == null ? indexOfNull() : indexOf(key, key.hashCode());
        return index >= 0 ? (V)mArray[(index<<1)+1] : null;
    }
113629
@SuppressWarnings("unchecked")
  public static <V> V get(String key) {
    return (V) share.get().get(key);
  }
867309
public T get(Object key) {
        SoftReference<T> ref = cache.get(key);
        T ob;
        
        if( ref == null ) {
            return null;
        }
        ob = ref.get();
        if( ob == null ) {
            release(key);
        }
        if( ob instanceof CachedItem ) {
            if( !((CachedItem)ob).isValidForCache() ) {
                release(key);
                return null;
            }
        }
        return ob;
    }