字符串替换参数一般是先解析出参数名字，然后替换掉，可以使用正则替换，也可以使用拼接字符串的方式替换，下面的代码代码演示了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，谢谢。
全文完。
相关推荐
将ubk_vhost_list表中的字段userid中的字符...表的名字 field_name —— 字段名 from_str —— 需要替换的字符串 to_str —— 替换成的字符串 今天运行了一个查询 UPDATE ubk_vhost_list SET userid = replace (use
Python2.6之前，格式字符串的使用方法相对更简单些，虽然其能够接收的参数数量有限制。这些方法在Python3.3中仍然有效，但已有含蓄的警告称将完全淘汰这些方法，目前还没有明确的时间进度表。 格式化浮点数： pi = ...
replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。 关于语法 stringObject.replace(regexp/substr,replacement) 关于参数 参数 描述 regexp/substr 必需。规定...
3.3.2 替换字符串中的字符 3.3.3 使用非成员重载运算符连接 3.4 字符串的查找 3.4.1 反向查找 3.4.2 查找一组字符第1次或最后一次出现的位置 3.4.3 从字符串中删除字符 3.4.4 字符...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...
5．12．2 字符串处理库的字符串操作函数 5．13 有关对象的思考：对象间的交互 小结 术语 自测练习 自测练习答案 练习 特殊小节：建立自己的计算机 更多的指针练习 字符串操作练习 特殊小节：高级字符串操作练习 复杂...
5．12．2 字符串处理库的字符串操作函数 5．13 有关对象的思考：对象间的交互 小结 术语 自测练习 自测练习答案 练习 特殊小节：建立自己的计算机 更多的指针练习 字符串操作练习 特殊小节：高级字符串操作练习 复杂...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...
10.5 使用替换修改字符串 97 10.6 将sed结果写入文件命令 97 10.7 从文件中读文本 98 10.8 匹配后退出 98 10.9 显示文件中的控制字符 99 10.10 使用系统sed 99 10.10.1 处理控制字符 99 10.10.2 处理报文输出 101 ...