Get map value by path.
@param <A> map key type
@param <B> map value type
@param map subject
@param path nodes to walk in map
@return value
423078
public static <A, B> Map<A, B> getMapUnsafe(final Map map, final Object... path) {
        return getUnsafe(map, Map.class, path);
    }
613450
public static String dotGetNullableString(final Map map, final String pathString) {
        return dotGetNullable(map, String.class, pathString);
    }
1257412
public Routed<T> route(String path) {
    Routed<T> ret = first.route(path);
    if (ret != null) return ret;

    ret = other.route(path);
    if (ret != null) return ret;

    ret = last.route(path);
    if (ret != null) return ret;

    if (notFound != null) return new Routed<T>(notFound, true, Collections.<String, String>emptyMap());

    return null;
  }
1039212
public static <K, KK, VV> Map<KK, VV> getAndPutMapIfAbsent(final Map<K, Map<KK, VV>> map, final K key) {
        Map<KK, VV> v = map.get(key);

        if (v == null) {
            v = new HashMap<>();
            v = map.put(key, v);
        }

        return v;
    }
331013
public static <T> Optional<Optional<T>> getOptional(final Map map, final Class<T> clazz, final Object... path) {
        return get(map, Optional.class, path).map(opt -> (Optional<T>) opt);
    }
1328216
@Override
    public final PathMappingResult apply(PathMappingContext mappingCtx) {
        ensureAbsolutePath(mappingCtx.path(), "path");
        return doApply(mappingCtx);
    }
1210888
public static <BEAN, KEYTYPE> Set<KEYTYPE> getNoDataKeySet(Map<KEYTYPE, BEAN> map) {
		Set<KEYTYPE> keySet = null;
		Iterator<Entry<KEYTYPE, BEAN>> iterator = map.entrySet().iterator();
		while (iterator.hasNext()) {
			Entry<KEYTYPE, BEAN> entry = iterator.next();
			BEAN bean = entry.getValue();
			if (bean == null) {
				if (keySet == null) {
					keySet = new LinkedHashSet<KEYTYPE>();
				}
				keySet.add(entry.getKey());
			}
		}
		return keySet;
	}
814442
public static <A, B> Map<A, B> getNullableMap(final List list, final Integer... path) {
        return getNullable(list, Map.class, path);
    }
221513
@SuppressWarnings("unchecked")
  public <T> T get(String key) {

    T value = (T) map.get(key);
    return value;
  }
1524
public <K, V> MapPath<K, V, PathBuilder<V>> getMap(String property, Class<K> key, Class<V> value) {
        return this.<K, V, PathBuilder<V>>getMap(property, key, value, PathBuilder.class);
    }
1250436
private String getReqValue(Map<String, String[]> map, String key) {

        return map.get(key) != null ? map.get(key)[0] : null;
    }
687105
public static <T> Optional<T> get(final Map map, final Class<T> clazz, final Object... path) {
        if (path == null || path.length == 0) {
            throw new IllegalArgumentException(PATH_MUST_BE_SPECIFIED);
        }
        if (path.length == 1) {
            return Optional.ofNullable((T) map.get(path[0]));
        }
        final Object[] pathToLastNode = Arrays.copyOfRange(path, 0, path.length - 1);
        final Object lastKey = path[path.length - 1];
        Map<Object, Object> intermediateMap = map;
        for (Object key : pathToLastNode) {
            final Object node = intermediateMap.get(key);
            if (node != null) {
                final Optional<Map> nodeMapOption = ClassApi.cast(node, Map.class);
                if (nodeMapOption.isPresent()) {
                    intermediateMap = nodeMapOption.get();
                } else {
                    throw new IllegalAccessError("Node with key '" + key + "' is not a map!");
                }
            } else {
                return Optional.empty();
            }
        }
        return Optional.ofNullable((T) intermediateMap.get(lastKey));
    }
885845
@SuppressWarnings("unchecked")
  public String path(T target, Object... params) {
    if (params.length == 0) return path(target, Collections.emptyMap());

    if (params.length == 1 && params[0] instanceof Map<?, ?>) return pathMap(target, (Map<Object, Object>) params[0]);

    if (params.length % 2 == 1) throw new RuntimeException("Missing value for param: " + params[params.length - 1]);

    final Map<Object, Object> map = new HashMap<Object, Object>();
    for (int i = 0; i < params.length; i += 2) {
      final String key   = params[i].toString();
      final String value = params[i + 1].toString();
      map.put(key, value);
    }
    return pathMap(target, map);
  }
742041
public static <A, B> B safeLookup(Map<A, B> map, A key) {

        if (map == null) {
            return null;
        }
        return map.get(key);
    }
219263
public static HashMap<String, String> getMapFromJSONPath(JSONObject record, String path) {
        return getObjectFromJSONPath(record, path);
    }
990040
private static String getValue(Map<String, String> map, String keyName) {
    String value = map.get(keyName);
    return value == null ? "-" : value;
  }
445638
public static Map mapValues(Mapper mapper, Map map) {
        return mapValues(mapper, map, false);
    }