Breaks up a string, and places it into a map. ampersands (&) are used to
split into key value pairs, while equals (=) are used to assign key vs
values

@return Map: a map with values
493562
private Map<String, String> parseMap() {
        final Map<String, String> map = new HashMap<>();
        for (String pair : browserInput.split("&")) {
            String[] kv = pair.split("=");
            map.put(kv[0], kv[1]);
        }
        return map;
    }
546132
@SuppressWarnings("unused")
        public Map<A, B> toMap() {
            Map<A, B> m = new HashMap<A, B>();
            m.put(_1, _2);
            return m;
        }
857700
public static String mapToString(Map map)
    {
        Set entries = map.entrySet();
        Iterator iter = entries.iterator();
        StringBuffer buff = new StringBuffer();
        while (iter.hasNext())
        {
            Map.Entry entry = (Map.Entry) iter.next();
            buff.append("[" + entry.getKey() + "," + entry.getValue() + "]\n");
        }
        return buff.toString();
    }
1184178
private static String convertMap2Pair(Map<String, String> map) {

        if (CommonUtils.isEmpty(map)) {
            return StringUtils.EMPTY;
        }

        StringBuilder sb = new StringBuilder(128);
        for (Map.Entry<String, String> entry : map.entrySet()) {
            sb.append(getKeyPairs(entry.getKey(), entry.getValue()));
        }

        return sb.toString();
    }
544186
public List<String> split(String s) {

        List<String> result = new ArrayList<String>();

        if (s == null) {
            return result;
        }

        boolean seenEscape = false;

        // Used to detect if the last char was a separator,
        // in which case we append an empty string
        boolean seenSeparator = false;

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            seenSeparator = false;
            char c = s.charAt(i);
            if (seenEscape) {
                if (c == escapeChar || c == separator) {
                    sb.append(c);
                } else {
                    sb.append(escapeChar).append(c);
                }
                seenEscape = false;
            } else {
                if (c == escapeChar) {
                    seenEscape = true;
                } else if (c == separator) {
                    if (sb.length() == 0 && convertEmptyToNull) {
                        result.add(null);
                    } else {
                        result.add(sb.toString());
                    }
                    sb.setLength(0);
                    seenSeparator = true;
                } else {
                    sb.append(c);
                }
            }
        }

        // Clean up
        if (seenEscape) {
            sb.append(escapeChar);
        }

        if (sb.length() > 0 || seenSeparator) {

            if (sb.length() == 0 && convertEmptyToNull) {
                result.add(null);
            } else {
                result.add(sb.toString());
            }

        }

        return result;
    }
1213578
function makeMap (
  str,
  expectsLowerCase
) {
  const map = Object.create(null);
  const list = str.split(',');
  for (let i = 0; i < list.length; i++) {
    map[list[i]] = true;
  }
  return expectsLowerCase
    ? val => map[val.toLowerCase()]
    : val => map[val]
}
106302
public static Map<String, String> parseQuery(String query) {
		Map<String, String> result = new LinkedHashMap<String, String>();
		
		if (query != null) {
			for (String keyValue: query.split("&")) {
				String[] pair = keyValue.split("=");
				result.put(StringUtils.urlDecode(pair[0]), StringUtils.urlDecode(pair[1]));
			}
		}
		
		return result;
	}
1347170
public Map<String, Object> sub(Map<String, Object> data, String prefix, String exclusiveAttrNames) {
    return sub(data, prefix, exclusiveAttrNames, true);
  }
676706
private Map<String, String> flatten(Map<String, ?> input) {
        Map<String, String> result = new HashMap<String, String>();

        for (Map.Entry<String, ?> entry : input.entrySet()) {
            for (Map.Entry<String, String> flattened : flatten(entry)) {
                if (flattened.getValue() != null) {
                    result.put(flattened.getKey(), flattened.getValue());
                }
            }
        }

        return result;
    }
684120
Map<String, String> stringToTags(String tagsmapstring) {
        String[] sb = tagsmapstring.split("\\r");
        Map<String, String> map = new HashMap<>();
        for (String key : sb) {
            if (key.contains("=")) {
                String[] set = key.split("=");
                if (set.length == 2)
                    map.put(set[0], set[1]);
            }
        }
        return map;
    }
270580
private static Map<String, String> split(String pAgentArgs) {
        Map<String,String> ret = new HashMap<String, String>();
        if (pAgentArgs != null && pAgentArgs.length() > 0) {
            for (String arg : EscapeUtil.splitAsArray(pAgentArgs, EscapeUtil.CSV_ESCAPE, ",")) {
                String[] prop = arg.split("=",2);
                if (prop == null || prop.length != 2) {
                    throw new IllegalArgumentException("jolokia: Invalid option '" + arg + "'");
                } else {
                    ret.put(prop[0],prop[1]);
                }
            }
        }
        return ret;
    }
731452
public static Map<String, String> parseProperties(String s) {
		Map<String, String> properties = new HashMap<String, String>();
		if (!StringUtils.isEmpty(s)) {
			Matcher matcher = PROPERTIES_PATTERN.matcher(s);
			int start = 0;
			while (matcher.find()) {
				addKeyValuePairAsProperty(s.substring(start, matcher.start()), properties);
				start = matcher.start() + 1;
			}
			addKeyValuePairAsProperty(s.substring(start), properties);
		}
		return properties;
	}
890904
Map convertToMap() {
        Map ret = new HashMap();
        for (Enumeration e = enumerateKeys(); e.hasMoreElements();) {
            Object key = e.nextElement();
            Object value = getValue(key);
            ret.put(key, value);
        }
        return ret;
    }
1041782
public java.util.Map<String, String> getExprs() {
        if (exprs == null) {
            exprs = new com.amazonaws.internal.SdkInternalMap<String, String>();
        }
        return exprs;
    }
250909
private String _serializeMap(Map map, Set<Object> done) throws ConverterException {
	StringBuilder sb = new StringBuilder(goIn() + "<struct>");

	Iterator it = map.keySet().iterator();

	deep++;
	while (it.hasNext()) {
	    Object key = it.next();
	    sb.append(goIn() + "<var name=" + del + XMLUtil.escapeXMLString(key.toString()) + del + ">");
	    sb.append(_serialize(map.get(key), done));
	    sb.append(goIn() + "</var>");
	}
	deep--;

	sb.append(goIn() + "</struct>");
	return sb.toString();
    }
266999
public static Map<String, String> parseQueryString(String s) {
        Map<String, String> ht = new HashMap<String, String>();
        StringTokenizer st = new StringTokenizer(s, "&");
        while (st.hasMoreTokens()) {
            String pair = st.nextToken();
            int pos = pair.indexOf('=');
            if (pos == -1) {
                ht.put(pair.toLowerCase(), "");
            } else {
                ht.put(pair.substring(0, pos).toLowerCase(),
                       pair.substring(pos + 1));
            }
        }
        return ht;
    }
54129
public Map<String, String> getArgMap(){
		Map<String, String> ret = new LinkedHashMap<String, String>();
		String[] ar = StringUtils.split(this.getArgs(), ',');
		if(ar!=null){
			for(String s : ar){
				String[] kv = StringUtils.split(s, ":", 2);
				if(kv!=null && kv.length==2){
					ret.put(StringUtils.trim(kv[0]), StringUtils.trim(kv[1]));
				}
				else{
					//TODO error log?
				}
			}
		}
		return ret;
	}