Str map to str.

@param map
the map
@return the string
500820
public static String strMapToStr(Map<String, String> map) {

        StringBuilder sb = new StringBuilder();

        if (map == null || map.isEmpty())
            return sb.toString();

        for (Entry<String, String> entry : map.entrySet()) {

            sb.append("< " + entry.getKey() + ", " + entry.getValue() + "> ");
        }
        return sb.toString();

    }
1182963
public String[] getKeysAsStrings(Map<String, ?> map) {
        String[] result = null;
        Set<String> keySet = map.keySet();
        int keySize = keySet.size();
        if (keySize > 0) {          
            result = keySet.toArray(new String[keySize]);
        }
        
        return result;
    }
50095
public String format(Map<?, ?> map, char keyValueSeparator) {
    if (map == null) {
      return StringUtils.EMPTY;
    }
    Preconditions.checkArgument(keyValueSeparator != ' ');

    StringBuilder rowString = new StringBuilder();
    for (Iterator<?> itr = map.entrySet().iterator(); itr.hasNext(); ) {
      Map.Entry<?, ?> entry = Cast.as(itr.next());
      String key = entry.getKey() == null ? "null" : entry.getKey().toString();
      String value = entry.getValue() == null ? "null" : entry.getValue().toString();

      key = key.replaceAll(Pattern.quote(escape), doubleEscape + doubleEscape);
      value = value.replaceAll(Pattern.quote(escape), doubleEscape + doubleEscape);

      rowString.append(quote);

      if (key.indexOf(keyValueSeparator) >= 0) {
        rowString.append(doubleQuote).append(key.replaceAll(quote, doubleQuote))
                 .append(doubleQuote);
      } else {
        rowString.append(key.replaceAll(quote, doubleQuote));
      }

      rowString.append(keyValueSeparator);

      if (value.indexOf(keyValueSeparator) >= 0) {
        rowString.append(doubleQuote).append(value.replaceAll(quote, doubleQuote))
                 .append(doubleQuote);
      } else {
        rowString.append(value.replaceAll(quote, doubleQuote));
      }

      rowString.append(quote);

      if (itr.hasNext()) {
        rowString.append(delimiter);
      }

    }

    return rowString.toString();
  }
957784
public static Map<String, ?> hidePasswords(Map<String, ?> map) {
        Map<String, Object> result = new LinkedHashMap<String, Object>();
        result.putAll(map);
        for (String key : map.keySet()) {
            Object value = map.get(key);
            if (value instanceof String) {
                if (isPassword(key)) {
                    result.put(key, "#");
                }
            } else if (value instanceof Map) {
                @SuppressWarnings("unchecked")
                Map<String, ?> bare = (Map<String, ?>) value;
                result.put(key, hidePasswords(bare));
            }
        }
        return result;
    }
862554
private static String getOrderedMapString(Map<Object, Object> map) {
		ArrayList<String> list = new ArrayList<String>();
		for (Map.Entry<Object, Object> entry : map.entrySet()) {
			if (entry.getValue() != null) {
				Object key = entry.getKey();
				Object value = entry.getValue();
				String objectString = getObjectString(value);
				if (!StringUtils.isEmpty(objectString)) {
					list.add(getObjectString(key) + "=" + objectString + "&");
				}

			}
		}
		int size = list.size();
		String[] arrayToSort = list.toArray(new String[size]);
		Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER);
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < size; i++) {
			sb.append(arrayToSort[i]);
		}
		return "{" + sb.toString() + "}";
	}
298317
protected static function translate($string, $map)
    {
        $out = '';
        foreach (range(0, strlen($string) - 1) as $i) {
            $out .= !empty($map[$i]) ? $map[$i] : $string[$i];
        }

        return $out;
    }
1184723
public void parseMember(Map map) {
    String key = T.getString();
    check(TokenType.STRING, "a string");
    check(TokenType.COLON, ":");
    Object val = parseValue();
    map.put(key, val);
  }
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;
    }
575751
public static String propertiesToString(Map<String,Object> map)
    {
        String strProperties = null;
        Properties properties = Utility.mapToProperties(map);
        ByteArrayOutputStream baOut = new ByteArrayOutputStream();
        try   {
            properties.store(baOut, PROPERTIES_COMMENT);
            byte[] rgBytes = baOut.toByteArray();
            ByteArrayInputStream baIn = new ByteArrayInputStream(rgBytes);
            InputStreamReader isIn = new InputStreamReader(baIn); // byte -> char
            char[] cbuf = new char[rgBytes.length];
            isIn.read(cbuf, 0, rgBytes.length);
            if (cbuf.length == rgBytes.length)
                strProperties = new String(cbuf);
        } catch (IOException ex)    {
            ex.printStackTrace();
        }
        return strProperties;
    }
1131849
public static ValueMap map(Object... map) {
        if (map.length / 2 * 2 != map.length)
            throw new IllegalArgumentException("Arguments should be <String> key - <?> value pairs");

        Builder builder = new Builder();
        for (int i = 0; i < map.length; i += 2)
            builder.put((String)map[i], map[i + 1]);

        return builder.build();
    }
1063067
public JsonWriter value(Map<String, ?> map) throws IOException {
      if (map == null) {
         nullValue();
      } else {
         boolean inObject = inObject();
         if (!inObject) beginObject();
         for (Map.Entry<String, ?> entry : map.entrySet()) {
            property(entry.getKey(), entry.getValue());
         }
         if (!inObject) endObject();
      }
      popIf(JsonTokenType.NAME);
      return this;
   }
1286612
public String serialize(Map<String, T> map) throws IOException {
        StringWriter sw = new StringWriter();
        JsonGenerator jsonGenerator = LoganSquare.JSON_FACTORY.createGenerator(sw);
        serialize(map, jsonGenerator);
        jsonGenerator.close();
        return sw.toString();
    }
394677
public static String mapToJson(final Map<String, Object> map) {
        try {
            return MAPPER.writeValueAsString(map);
        } catch (JsonProcessingException e) {
            return null;
        }
    }
809644
public static String format(String s, Map<String, String> map) {
		StringBuilder sb = new StringBuilder((int)(s.length() * 1.5));
		int cursor = 0;
		for (int start, end; (start = s.indexOf("${", cursor)) != -1 && (end = s.indexOf('}', start)) != -1;) {
			sb.append(s.substring(cursor, start));
			String key = s.substring(start + 2, end);
			sb.append(map.get(StringUtils.trim(key)));
			cursor = end + 1;
		}
		sb.append(s.substring(cursor, s.length()));
		return sb.toString();
	}
214994
def from_maps(*maps):
        
        result = StringValueMap()
        
        if maps == None or len(maps) == 0:
            return result

        for map in maps:
            for (k, v) in map.items():
                key = StringConverter.to_string(k)
                result.put(key, v)

        return result
438118
protected String getAndRemoveValue(Map<String, String> map, String key) {

        String value = map.get(key);
        if (value != null) {
            map.remove(key);
        }
        return value;
    }
835515
def mapping_to_str(mapping):
    """"""
    result = ["<"]
    for i, (key, value) in enumerate(mapping.items()):
        if i > 0:
            result.append(",")
        result += [key, "=", serialize_for_header(key, value)]
    result += [">"]
    return "".join(result)