Get the value associated with the given key (Interval). Interval must match exactly.

@return null if no such key
769767
private Node<K, V> get(Node<K, V> x, Interval1D<K> interval) {
    if (x == null) {
      return null;
    }
    int cmp = interval.compareTo(x.interval);
    if (cmp < 0) {
      return get(x.left, interval);
    } else if (cmp > 0) {
      return get(x.right, interval);
    } else {
      return x;
    }
  }
534771
public Object get(long key)
  {
    int hash = (int) (key & mask);

    while (true) {
      long mapKey = keys[hash];

      if (mapKey == key)
        return values[hash];
      else if (mapKey == DEAD_KEY) {
        if ((flags[hash] & DELETED) == 0)
          return null;
      }

      hash = (hash + 1) & mask;
    }
  }
833527
public V get(long key) {
		if (size == 0) {
			return null;
		}
		if (size == 1) {
			int posDiff = compare(key, rootKey);
			if (posDiff == -1) {
				return rootVal;
			}
			return null;
		}
		Node<V> n = root;
		while (true) {
			if (!doesInfixMatch(n, key)) {
				return null;
			}			
			
			//infix matches, so now we check sub-nodes and postfixes
			if (getBit(key, n.posDiff)) {
				if (n.hi != null) {
					n = n.hi;
					continue;
				} 
				if (compare(key, n.hiPost) == -1) {
					return n.hiVal;
				}
			} else {
				if (n.lo != null) {
					n = n.lo;
					continue;
				}
				if (compare(key, n.loPost) == -1) {
					return n.loVal;
				}
			}
			return null;
		}
	}
678466
public V get(Object key) {
    V value = highPrioMap.get(key);
    return value != null ? value : lowPrioMap.get(key);
  }
713835
public function getValue($key)
    {
        if (!isset($this->values[$key])) {
            return null;
        }
        return $this->values[$key];
    }
550447
public Object get(String key) {
    	if(config != null) {
    		return config.get(key);
    	}
    	else
    		return null;
    }
692912
Object get(int key) {
    return (key >= 0 && key < list.size()) ? list.get(key) : null;
  }
168680
public String get(String key) throws EtcdClientException {
        Preconditions.checkNotNull(key, "key can't be null");

        URI uri = buildUriWithKeyAndParams(key, null);
        HttpGet httpGet = new HttpGet(uri);

        EtcdResult result = syncExecute(httpGet, new int[] {200, 404}, 100);
        if (result.isError()) {
            if (result.errorCode == 100) {
                return null;
            }
        }

        return result.node != null ? result.node.value : null;
    }
50469
@Override
    public <T> T getValue(String key) {
        ValueObject vo = get(key);
        if (null == vo) {
            return null;
        }
        return vo.value();
    }
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;
	}
49481
public V get( final K key ) {
        synchronized ( _map ) {
            final ManagedItem<V> item = _map.get( key );
            if ( item == null ) {
                return null;
            }
            if ( _ttl > -1 && System.currentTimeMillis() - item._insertionTime > _ttl ) {
                _map.remove( key );
                return null;
            }
            return item._value;
        }
    }
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;
	}
1333388
public V get(String key)
    {
        int index = exactMatchSearch(key);
        if (index >= 0)
        {
            return v[index];
        }

        return null;
    }
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;
   }
378658
public V get (int key)
    {
        Record<V> rec = getImpl(key);
        return (rec == null) ? null : rec.value;
    }
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();
		}
	}
505361
public T getValueByString(String key) {
        for (T value : values) {
            if (keyFactory.generateKey(value).equals(key)) {
                return value;
            }
        }
        return null;
    }