get() calls the readBack function if the value is not in HashMap
otherwise serve copy from hash directly.
335319
@SuppressWarnings("unchecked")
    @Override
    synchronized public V get(Object key) {
        if(!this.containsKey(key)) {
            super.put((K) key, readBack((K) key));
        }

        return super.get(key);
    }
448809
@Override
    public Object get(int index, Scriptable start)
    {
        if (externalData != null) {
            if (index < externalData.getArrayLength()) {
                return externalData.getArrayElement(index);
            }
            return Scriptable.NOT_FOUND;
        }

        Slot slot = slotMap.query(null, index);
        if (slot == null) {
            return Scriptable.NOT_FOUND;
        }
        return slot.getValue(start);
    }
800011
public Object get(long key)
	{
		if (tc.isEntryEnabled()) Tr.entry(tc, "get", new Object[]{new Long(key), this});
		
		int hash = getHashForExistingEntry(key);
		Object value = null;
         
        if (hash >= 0)
        {
            value = _values[hash];
        }
		
		if (tc.isEntryEnabled()) Tr.exit(tc, "get", value);				
		return value;
	}
1105365
public Response get(String path, Map<String, String> params) throws IOException, RESTException {
        return get(path, params, null);
    }
444766
@SuppressWarnings("unchecked")
    public V get(final long key) {
        int index = longHash(key, mask);
        Object value;
        while (null != (value = values[index])) {
            if (key == keys[index]) {
                return (V) value;
            }
            index = ++index & mask;
        }
        return null;
    }
868435
@Override
    public Object get(int index, Scriptable start) {
        if (0 <= index && index < string.length()) {
            return String.valueOf(string.charAt(index));
        }
        return super.get(index, start);
    }
696997
function _get(key){
	var ret = null;

	// Pull from cache or re-read from fs.
	//console.log('key: ' + key)
	//console.log('use_zcache_p: ' + use_zcache_p)
	if( use_zcache_p ){
	    ret = zcache[key];
	}else{
	    ret = afs.read_file(path_cache[key]);
	}

	return ret;
    }
151090
def get(self, key, failobj=None, exact=0):

        """"""

        if not exact:
            try:
                key = self.getfullkey(key)
            except KeyError:
                return failobj
        return self.data.get(key,failobj)
164270
public T get(T dest, int index) {
    checkBounds(index);
    // We would rather do
    //   UnsafeHelper.copyMemory(null, offset(index), dest, firstFieldOffset, elementSize);
    // but this is unsupported by the Unsafe class
    copier.copy(dest, offset(index));
    return dest;
  }
512428
private HashMap duplicate(HashMap funcs, boolean deepCopy) {
	if (deepCopy) throw new PageRuntimeException(new ExpressionException("deep copy not supported"));

	Iterator it = funcs.entrySet().iterator();
	Map.Entry entry;
	HashMap cm = new HashMap();
	while (it.hasNext()) {
	    entry = (Entry) it.next();
	    cm.put(entry.getKey(), deepCopy ? entry.getValue() : // TODO add support for deepcopy ((FunctionLibFunction)entry.getValue()).duplicate(deepCopy):
		    entry.getValue());
	}
	return cm;
    }
843923
@SuppressWarnings("unchecked")
	public Result<List<DATA>> get(TRANS trans, String key, Getter<DATA> getter) {
		List<DATA> ld = null;
		Result<List<DATA>> rld = null;
		
		int cacheIdx = cacheIdx(key);
		Map<String, Dated> map = ((Map<String,Dated>)cache[cacheIdx]);
		
		// Check for saved element in cache
		Dated cached = map.get(key);
		// Note: These Segment Timestamps are kept up to date with DB
		Date dbStamp = info.get(trans, name,cacheIdx);
		
		// Check for cache Entry and whether it is still good (a good Cache Entry is same or after DBEntry, so we use "before" syntax)
		if(cached!=null && dbStamp.before(cached.timestamp)) {
			ld = (List<DATA>)cached.data;
			rld = Result.ok(ld);
		} else {
			rld = getter.get();
			if(rld.isOK()) { // only store valid lists
				map.put(key, new Dated(rld.value));  // successful item found gets put in cache
//			} else if(rld.status == Result.ERR_Backend){
//				map.remove(key);
			}
		}
		return rld;
	}
1030294
long get(final T key) {
    if (key == null) { return 0; }
    final int probe = hashProbe(key);
    if (states[probe] > 0) {
      assert (keys[probe]).equals(key);
      return values[probe];
    }
    return 0;
  }
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;
	}
355462
public final T get(Object... args) {
        // Grab a read lock to try retrieving the object
        this.readLock.lock();
        try {

            // See if the object already exists and is valid
            final T value = this.retrieve(args);
            if (!this.invalid(value, args)) {
                if (getLogger().isDebugEnabled()) {
                    getLogger().debug("Using retrieved (first attempt) Object='" + value + "'");
                }

                return value;
            }
        } finally {
            // Release the read lock
            this.readLock.unlock();
        }

        // Object must not be valid, switch to a write lock
        this.writeLock.lock();
        try {
            // Check again if the object exists and is valid
            T value = this.retrieve(args);
            if (this.invalid(value, args)) {

                // Object is not valid, create it
                value = this.create(args);

                if (getLogger().isDebugEnabled()) {
                    getLogger().debug("Created new Object='" + value + "'");
                }
            } else if (getLogger().isDebugEnabled()) {
                getLogger().debug("Using retrieved (second attempt) Object='" + value + "'");
            }

            return value;
        } finally {
            // switch back to the read lock
            this.writeLock.unlock();
        }
    }
755176
private <D,S> JMapper<D,S> getJMapper(HashMap<String,JMapper> map,Object source){
		Class<?> sourceClass = source instanceof Class?((Class<?>)source):source.getClass();
		JMapper<D,S> jMapper = map.get(sourceClass.getName());
		if(jMapper == null) Error.classNotMapped(source, configuredClass);
		return jMapper;
	}
513777
public boolean get(final T key, final GetOp op) {
    if (SHOULD_CHECK) {
      requireNonNull(key);
      requireNonNull(op);
      checkNotClosed();
      txn.checkReady();
    }
    kv.keyIn(key);

    final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv
                                      .pointerVal(), op.getCode());

    if (rc == MDB_NOTFOUND) {
      return false;
    }

    checkRc(rc);
    kv.keyOut();
    kv.valOut();
    return true;
  }
435740
public boolean get(int key, boolean valueIfKeyNotFound) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i < 0) {
            return valueIfKeyNotFound;
        } else {
            return mValues[i];
        }
    }