[简单]字符串替换参数小结

        字符串替换参数一般是先解析出参数名字，然后替换掉，可以使用正则替换，也可以使用拼接字符串的方式替换，下面的代码代码演示了2种情况下如何替换参数，一种是参数名称含前缀和后缀如${key},另一种情况是只含前缀，使用空格作为后缀，如:key，代码如下：

       

package com.huse.strtest;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Set;

public class 字符串替换参数小结_S4_Test {
	public static void main(String[] args) throws Exception {
		字符串替换参数小结_S4_Test t = new 字符串替换参数小结_S4_Test();
		String str = "$ { name},${name },$ {${order}} ${${$}";
		String beforSplit = "${";
		String afterSplit = "}";
		Map<String, String> context = new HashMap<String, String>();
		context.put("name", "测试\\${");
		context.put("order", "测试值\\$1");
		context.put("${$", "测试值\\$2");
		System.out.println("#-------------测试有前缀有后缀------------------#");
		System.out.println("采用正则拿到${key}后替换:");
		System.out.println(t.replaceAllStrByRegNormal(str, beforSplit,afterSplit, context));
		System.out.println("采用字符串查找先取到所有key再直接replaceAll");
		System.out.println(t.replaceAllStrByReg(str, beforSplit, afterSplit,context));
		System.out.println("使用StringBuffer拼接替换字符串后的结果,采用subString得到${key}后替换");
		System.out.println(t.replaceAllStrByAppendStr(str, beforSplit,afterSplit, context));
		System.out.println("#-------------测试有前缀空格后缀------------------#");
		String str2 = "A: :A 测试:A :B C :D :E :F F: in( :m ,:l";
		context.put("A", "测试$:");
		context.put("B", "测试$2");
		context.put("D", "测试$3");
		context.put("F", "测试\\$4");
		context.put("l", "测试5");
		beforSplit = ":";
		System.out.println("采用正则拿到:key后替换");
		System.out.println(t.replaceAllStrByRegNormal2(str2, beforSplit, context));
		System.out.println("采用字符串查找先取到所有key再直接replaceAll");
		System.out.println(t.replaceAllStrByReg2(str2, beforSplit,context));
		System.out.println("使用StringBuffer拼接替换字符串后的结果,采用subString得到${key}后替换");
		System.out.println(t.replaceAllStrByAppendStr2(str2, beforSplit,context));
	}

	/**
	 * @Description 采用正则拿到${key}后替换
	 */
	public String replaceAllStrByRegNormal(String str, String beforSplit,
			String afterSplit, Map<String, String> paramData) throws Exception {
		// 参数校验
		if (paramData == null || paramData.size() == 0) {
			return str;
		}
		if (isEmptyStr(str)) {
			return null;
		}
		if (isEmptyStr(beforSplit)) {
			beforSplit = "${";
		}
		if (isEmptyStr(afterSplit)) {
			afterSplit = "}";
		}
		//不匹配时候原样输出
		String tmpBeforSplit = beforSplit, tmpAfterSplit = afterSplit;
		beforSplit = beforSplit.replaceAll("\\$", "\\\\\\$");
		beforSplit = beforSplit.replaceAll("\\{", "\\\\\\{");
		afterSplit = afterSplit.replaceAll("\\$", "\\\\\\$");
		afterSplit = afterSplit.replaceAll("\\{", "\\\\\\{");
		String regex = beforSplit + "(.+?)" + afterSplit;
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(str);
		StringBuffer sb = new StringBuffer();
		while (matcher.find()) {
			String key = matcher.group(1);// 键名
			String value = (String) paramData.get(trimStr(key));// 键值
			if (value == null) {
				value = tmpBeforSplit + key + tmpAfterSplit;// 如果不想保留不匹配值则value=""
			}
			value = java.util.regex.Matcher.quoteReplacement(value);
			matcher.appendReplacement(sb, value);
		}
		matcher.appendTail(sb);
		return sb.toString();
	}

	/**
	 * @Description 采用字符串查找先取到所有key再直接replaceAll ${key}
	 */
	public String replaceAllStrByReg(String str, String beforSplit,
			String afterSplit, Map<String, String> context) {
		// 参数校验
		if (context == null || context.size() == 0) {
			return str;
		}
		if (isEmptyStr(str)) {
			return null;
		}
		if (isEmptyStr(beforSplit)) {
			beforSplit = "${";
		}
		if (isEmptyStr(afterSplit)) {
			afterSplit = "}";
		}
		Map<String, String> resultMap = safetyProcessMapValue(context);
		Set<String> paramNames = getParamNames(str, beforSplit, afterSplit);
		for (String name : paramNames) {
			Object obj = resultMap.get(trimStr(name));
			if (obj != null) {
				String regex = "\\Q" + beforSplit + name + afterSplit + "\\E";
				str = str.replaceAll(regex, obj.toString());
			}
		}
		return str;
	}

	/**
	 * @Description 根据分割符从字符串中取得变量的名字
	 */
	public Set<String> getParamNames(String str, String beforeSplit,
			String afterSplit) {
		Set<String> paramNames = new HashSet<String>();
		int start = 0, end = 0;
		while (end < str.length()) {
			start = str.indexOf(beforeSplit, end);
			if (start == -1) {
				break;
			}
			start = start + beforeSplit.length();
			end = str.indexOf(afterSplit, start);
			if (end == -1) {
				break;
			}
			String param = str.substring(start, end);
			paramNames.add(param);
			end = end + afterSplit.length();
		}
		return paramNames;
	}

	/**
	 * @Description: 使用StringBuffer拼接替换字符串后的结果,采用subString得到${key}替换 适用于key
	 *               2侧都有值
	 */
	public String replaceAllStrByAppendStr(final String str, String beforSplit,
			String afterSplit, Map<String, String> map) {
		if (map == null || map.size() == 0) {
			return str;
		}
		if (isEmptyStr(str)) {
			return null;
		}
		if (isEmptyStr(beforSplit)) {
			beforSplit = "${";
		}
		if (isEmptyStr(afterSplit)) {
			afterSplit = "}";
		}
		StringBuilder sb = new StringBuilder((int) (str.length() * 1.5));
		int cursor = 0;
		for (int start, end; (start = str.indexOf(beforSplit, cursor)) != -1
				&& (end = str.indexOf(afterSplit, start)) != -1;) {
			sb.append(str.substring(cursor, start));
			String key = str.substring(start + beforSplit.length(), end);
			if (map.get(trimStr(key)) != null) {
				sb.append(map.get(trimStr(key)));
			} else {
				sb.append(beforSplit).append(key).append(afterSplit);
			}
			cursor = end + 1;
		}
		sb.append(str.substring(cursor, str.length()));
		return sb.toString();
	}

	/**
	 * @Description 采用正则拿到:key后替换
	 */
	public String replaceAllStrByRegNormal2(String str, String beforSplit,
			Map<String, String> paramData) throws Exception {
		// 参数校验
		if (paramData == null || paramData.size() == 0) {
			return str;
		}
		if (isEmptyStr(str)) {
			return null;
		}
		if (isEmptyStr(beforSplit)) {
			beforSplit = ":";
		}
		beforSplit = beforSplit.replaceAll("\\$", "\\\\\\$");
		beforSplit = beforSplit.replaceAll("\\{", "\\\\\\{");
		String regex = beforSplit + "([^\\s]+?)" + "(\\s+|$)";
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(str);
		StringBuffer sb = new StringBuffer();
		while (matcher.find()) {
			String key = matcher.group(1);// 键名
			String value = (String) paramData.get(trimStr(key));// 键值
			if (value == null) {
				value = matcher.group(0);
			} else {
				value = value + " ";
			}
			value = java.util.regex.Matcher.quoteReplacement(value);
			matcher.appendReplacement(sb, value);
		}
		matcher.appendTail(sb);
		return sb.toString();
	}

	/**
	 * @Description 拿到所有:key后replaceAll
	 */
	public String replaceAllStrByReg2(String str, String beforSplit,
			Map<String, String> context) {
		// 参数校验
		if (context == null || context.size() == 0) {
			return str;
		}
		if (isEmptyStr(str)) {
			return null;
		}
		if (isEmptyStr(beforSplit)) {
			beforSplit = ":";
		}
		Map<String, String> resultMap = safetyProcessMapValue(context);
		Set<String> paramNames = getParamNames2(str, beforSplit);
		for (String name : paramNames) {
			Object obj = resultMap.get(trimStr(name));
			if (obj != null) {
				String regex = "\\Q" + beforSplit + name + "\\E";
				str = str.replaceAll(regex, obj.toString());
			}
		}
		return str;
	}

	public Set<String> getParamNames2(String str, String beforeSplit) {
		Set<String> paramNames = new HashSet<String>();
		int start = 0, end = 0;
		while (end < str.length()) {
			start = str.indexOf(beforeSplit, end);
			if (start == -1) {
				break;
			}
			start = start + beforeSplit.length();
			end = str.indexOf(" ", start);
			if (end == -1) {
				end = str.lastIndexOf(beforeSplit);
				if (end != start-beforeSplit.length()) {
					break;
				}
				end = str.length();
			}
			String param = str.substring(start, end);
			paramNames.add(param);
			end = end + " ".length();
		}
		return paramNames;
	}

	/**
	 * @Description StringBuilder 拼接
	 */
	public String replaceAllStrByAppendStr2(final String str,
			String beforSplit, Map<String, String> map) {
		if (map == null || map.size() == 0) {
			return str;
		}
		if (isEmptyStr(str)) {
			return null;
		}
		if (isEmptyStr(beforSplit)) {
			beforSplit = ":";
		}
		StringBuilder sb = new StringBuilder((int) (str.length() * 1.5));
		int cursor = 0;
		for (int start, end; (start = str.indexOf(beforSplit, cursor)) != -1;) {
			end = str.indexOf(" ", start);
			if (end == -1) {
				if ((end=str.lastIndexOf(beforSplit)) != start) {
					break;
				} else {
					end = str.length();
				}
			}
			sb.append(str.substring(cursor, start));
			String key = str.substring(start + beforSplit.length(), end);
			if (map.get(trimStr(key)) != null) {
				sb.append(map.get(trimStr(key))).append(" ");
			} else {
				sb.append(beforSplit).append(key).append(" ");
			}
			cursor = end + 1;
		}
		if(cursor<=str.length()){
			sb.append(str.substring(cursor, str.length()));
		}
		return sb.toString();
	}

	public String trimStr(final String str) {
		return str == null ? null : str.trim();
	}

	public boolean isEmptyStr(String str) {
		return str == null || str.trim().length() == 0;
	}

	// 对特殊字符进行处理如$
	public Map<String, String> safetyProcessMapValue(Map<String, String> map) {
		Map<String, String> resultMap = new HashMap<String, String>();
		for (Entry<String, String> entry : map.entrySet()) {
			resultMap.put(entry.getKey(),
					java.util.regex.Matcher.quoteReplacement(entry.getValue()));
		}
		return resultMap;
	}

}

   结果为：

  

#-------------测试有前缀有后缀------------------#
采用正则拿到${key}后替换:
$ { name},测试\${,$ {测试值\$1} 测试值\$2
采用字符串查找先取到所有key再直接replaceAll
$ { name},测试\${,$ {测试值\$1} 测试值\$2
使用StringBuffer拼接替换字符串后的结果,采用subString得到${key}后替换
$ { name},测试\${,$ {测试值\$1} 测试值\$2
#-------------测试有前缀空格后缀------------------#
采用正则拿到:key后替换
A: 测试$: 测试测试$: 测试$2 C 测试$3 :E 测试\$4 F: in( :m ,测试5 
采用字符串查找先取到所有key再直接replaceAll
A: 测试$: 测试测试$: 测试$2 C 测试$3 :E 测试\$4 F: in( :m ,测试5
使用StringBuffer拼接替换字符串后的结果,采用subString得到${key}后替换
A: 测试$: 测试测试$: 测试$2 C 测试$3 :E 测试\$4 F: in( :m ,测试5 

     转载请注明原处，原链接http://53873039oycg.iteye.com/blog/2144339，谢谢。

     全文完。