Returns the current count for the given key, which is 0 if it hasn't
been
seen before. This is a convenient version of <code>get</code> that casts
and extracts the primitive value.
762547
public int getIntCount(Object key) {
    MutableInteger count =  map.get(key);
    if (count == null) {
      return defaultValue; // haven't seen this object before -> 0 count
    }
    return count.intValue();
  }
1301275
public V get (Object key)
    {
        V result = _delegate.get(key);

        if (_tracking) {
            if (result == null) {
                if (_seenKeys.contains(key)) {
                    // only count a miss if we've seen the key before
                    _misses++;
                }
            } else {
                _hits++;
            }
        }

        return result;
    }
1119827
public int getCount(Object o) {
    Integer count = (Integer) cset.get(o);   
    if ( count == null ) {
      return(0);
    }
    else {
      return(count.intValue());
    }
  }
612263
public int get(int key, int defaultValue) {
    int index = getKeyIndex(key);
    if (index >= 0) {
      return values[index];
    } else {
      return defaultValue;
    }
  }
1226343
@Override
    public Number getNumber(@NonNull String key) {
        if (key == null) { throw new IllegalArgumentException("key cannot be null."); }

        final int index = indexForColumnName(key);
        return index >= 0 ? getNumber(index) : null;
    }
908897
public V get(String key)
    {
        int index = exactMatchSearch(key);
        if (index >= 0)
        {
            return getValueAt(index);
        }

        return null;
    }
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;
    }
776048
public T get(long key) {
		for (int i = 0; i < this.numTables; i++) {
			Entry<T> entry = this.tables.get(i).get(
					this.hashfunctions.get(i).hash(key));
			if (entry != null && entry.getKey() == key) {
				return entry.getValue();
			}
		}
		for (Entry<T> entry : this.stash) {
			if (entry.getKey() == key) {
				return entry.getValue();
			}
		}
		return null;
	}
374307
@Override
  public V get(K key) {
    return !isEmpty() ? get(key, hash(key)) : null;
  }
469250
@Override
    public int countMissing() {
        int count = 0;
        for (int i = 0; i < size(); i++) {
            if (MISSING_VALUE == getKeyForIndex(i)) {
                count++;
            }
        }
        return count;
    }
1220117
public int getCount (K key)
    {
        CountEntry<K> entry = _backing.get(key);
        return (entry == null) ? 0 : entry.count;
    }
378658
public V get (int key)
    {
        Record<V> rec = getImpl(key);
        return (rec == null) ? null : rec.value;
    }
692912
Object get(int key) {
    return (key >= 0 && key < list.size()) ? list.get(key) : null;
  }
356724
public int get(Object key)
  {
    if (key == null)
      key = NULL_KEY;

    int hash = key.hashCode() & _mask;

    for (Item item = _entries[hash]; item != null; item = item._next) {
      Object itemKey = item._key;
      
      if (itemKey == key || itemKey.equals(key))
        return item._value;
    }

    return NULL;
  }
1341775
public static <K> Integer getCount(Map<K, Integer> map, K k)
    {
        Integer count = map.get(k);
        if (count == null)
        {
            count = 0;
            map.put(k, count);
        }
        return count;
    }
1022418
public int getInt(int key)
    {
        Object value = map.get(key);
        if (!(value instanceof Integer))
        {
            return 0;
        }
        Integer result = (Integer)value;
        return result;
    }
946310
public int get(final int key)
    {
        int offset = endOfPositionField;

        final int position = position();
        while (offset < position)
        {
            if (statusVolatile(offset) == COMMITTED && key == key(offset))
            {
                return offset + SIZE_OF_RECORD_FRAME;
            }

            offset += slotSize;
        }

        return DID_NOT_CLAIM_RECORD;
    }