正则表达式的表示

public class T{
    public static void main(String[] args) {
     String str="你的职位是${manager}";
     String newstr=str.replace("${manager}", "经理");
     System.out.println(newstr);
  }
}

public static void main( String[] args )
{ String s = "你的职位是${manager}";
// 把不是中文的部分换成经理
s = s.replaceAll( "[^\u4e00-\u9fa5]+", "经理" );
System.out.println( s );
}

str = str.replaceAll("\\$\\{manager\\}", "经理");
// $,{,}都是特殊元字符,要转义

这是个简单问题对于正则LZ您看看我的收藏http://www.javaeye.com/topic/30728贴一段
在对正则表达式的功能和作用有了初步的了解之后，我们就来具体看一下正则表达式的语法格式。
 
 正则表达式的形式一般如下：　　
 
 /love/　　其中位于“/”定界符之间的部分就是将要在目标对象中进行匹配的模式。用户只要把希望查找匹配对象的模式内容放入“/”定界符之间即可。为了能够使用户更加灵活的定制模式内容，正则表达式提供了专门的“元字符”。所谓元字符就是指那些在正则表达式中具有特殊意义的专用字符，可以用来规定其前导字符（即位于元字符前面的字符）在目标对象中的出现模式。
 较为常用的元字符包括： “+”， “*”，以及 “?”。
 
 “+”元字符规定其前导字符必须在目标对象中连续出现一次或多次。
 
 “*”元字符规定其前导字符必须在目标对象中出现零次或连续多次。
 
 “?”元字符规定其前导对象必须在目标对象中连续出现零次或一次。
 
 下面，就让我们来看一下正则表达式元字符的具体应用。
 
 /fo+/　　因为上述正则表达式中包含“+”元字符，表示可以与目标对象中的 “fool”, “fo”, 或者 “football”等在字母f后面连续出现一个或多个字母o的字符串相匹配。
 
 /eg*/　　因为上述正则表达式中包含“*”元字符，表示可以与目标对象中的 “easy”, “ego”, 或者 “egg”等在字母e后面连续出现零个或多个字母g的字符串相匹配。
 
 /Wil?/　　因为上述正则表达式中包含“？”元字符，表示可以与目标对象中的 “Win”, 或者“Wilson”,等在字母i后面连续出现零个或一个字母l的字符串相匹配。
 
 有时候不知道要匹配多少字符。为了能适应这种不确定性，正则表达式支持限定符的概念。这些限定符可以指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。
 
 {n} n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
 
 {n,} n 是一个非负整数。至少匹配 n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
 
 {n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
 
 除了元字符之外，用户还可以精确指定模式在匹配对象中出现的频率。例如，/jim {2,6}/ 上述正则表达式规定字符m可以在匹配对象中连续出现2-6次，因此，上述正则表达式可以同jimmy或jimmmmmy等字符串相匹配。
 在对如何使用正则表达式有了初步了解之后，我们来看一下其它几个重要的元字符的使用方式。
 <PRE class=java name="code">\s：用于匹配单个空格符，包括tab键和换行符；
\S：用于匹配除单个空格符之外的所有字符；
\d：用于匹配从0到9的数字；
\w：用于匹配字母，数字或下划线字符；
\W：用于匹配所有与\w不匹配的字符；
. ：用于匹配除换行符之外的所有字符。
</PRE>
 （说明：我们可以把\s和\S以及\w和\W看作互为逆运算）
 下面，我们就通过实例看一下如何在正则表达式中使用上述元字符。
 /\s+/ 上述正则表达式可以用于匹配目标对象中的一个或多个空格字符。
 /\d000/　如果我们手中有一份复杂的财务报表，那么我们可以通过上述正则表达式轻而易举的查找到所有总额达千元的款项。
 除了我们以上所介绍的元字符之外，正则表达式中还具有另外一种较为独特的专用字符，即定位符。定位符用于规定匹配模式在目标对象中的出现位置。较为常用的定位符包括： “^”, “$”, “\b” 以及 “\B”。
 <PRE class=java name="code">“^”定位符规定匹配模式必须出现在目标字符串的开头
“$”定位符规定匹配模式必须出现在目标对象的结尾
“\b”定位符规定匹配模式必须出现在目标字符串的开头或结尾的两个边界之一
“\B”定位符则规定匹配对象必须位于目标字符串的开头和结尾两个边界之内，
 即匹配对象既不能作为目标字符串的开头，也不能作为目标字符串的结尾。
</PRE>
 同样，我们也可以把“^”和“$”以及“\b”和“\B”看作是互为逆运算的两组定位符。举例来说： /^hell/　因为上述正则表达式中包含“^”定位符，所以可以与目标对象中以 “hell”, “hello”或“hellhound”开头的字符串相匹配。 /ar$/　因为上述正则表达式中包含“$”定位符，所以可以与目标对象中以 “car”, “bar”或 “ar” 结尾的字符串相匹配。 /\bbom/　因为上述正则表达式模式以“\b”定位符开头，所以可以与目标对象中以 “bomb”, 或 “bom”开头的字符串相匹配。/man\b/　因为上述正则表达式模式以“\b”定位符结尾，所以可以与目标对象中以 “human”, “woman”或 “man”结尾的字符串相匹配。
 为了能够方便用户更加灵活的设定匹配模式，正则表达式允许使用者在匹配模式中指定某一个范围而不局限于具体的字符。例如：
 <PRE class=java name="code">/[A-Z]/　　上述正则表达式将会与从A到Z范围内任何一个大写字母相匹配。
/[a-z]/　　上述正则表达式将会与从a到z范围内任何一个小写字母相匹配。
/[0-9]/ 　上述正则表达式将会与从0到9范围内任何一个数字相匹配。
/([a-z][A-Z][0-9])+/　上述正则表达式将会与任何由字母和数字组成的字符串，如 “aB0” 等相匹配。
</PRE>
 这里需要提醒用户注意的一点就是可以在正则表达式中使用 “()” 把字符串组合在一起。“()”符号包含的内容必须同时出现在目标对象中。因此，上述正则表达式将无法与诸如 “abc”等的字符串匹配，因为“abc”中的最后一个字符为字母而非数字。
 如果我们希望在正则表达式中实现类似编程逻辑中的“或”运算，在多个不同的模式中任选一个进行匹配的话，可以使用管道符 “|”。例如：/to|too|2/　上述正则表达式将会与目标对象中的 “to”, “too”, 或 “2” 相匹配。
 正则表达式中还有一个较为常用的运算符，即否定符 “[^]”。与我们前文所介绍的定位符 “^” 不同，否定符 “[^]”规定目标对象中不能存在模式中所规定的字符串。例如：/[^A-C]/　上述字符串将会与目标对象中除A，B，和C之外的任何字符相匹配。一般来说，当“^”出现在 “[]”内时就被视做否定运算符；而当“^”位于“[]”之外，或没有“[]”时，则应当被视做定位符。
 最后，当用户需要在正则表达式的模式中加入元字符，并查找其匹配对象时，可以使用转义符“\”。例如：/Th\*/ 　上述正则表达式将会与目标对象中的“Th*”而非“The”等相匹配。
 在构造正则表达式之后，就可以象数学表达式一样来求值，也就是说，可以从左至右并按照一个优先级顺序来求值。优先级如下：
 <PRE class=java name="code">1．\ 转义符
2．(), (?:), (?=), [] 圆括号和方括号
3．*, +, ?, {n}, {n,}, {n,m} 限定符
4．^, $, \anymetacharacter 位置和顺序
5．|“或”操作

$,{ 这两个是特殊字符,右大括号不用理它str = str.replaceAll("\\$\\{manager}","经理");

Pattern p = Pattern.compile("\\$\\{manager\\}");
String str="你的职位是${manager}";
Matcher m = p.matcher(str);
System.out.println(m.replaceAll("经理"));要这样写才能转过来。楼主你“\\$\\{manager\\}”这个规则没有写错

楼主，这个可以用模板做。。
你应该查查　velocity　　的资料。

Up java 超级群：有时间大家共同交流 51177847

为挣扎在JDK1.4平台上的朋友们，共享一个支持多参数${}替换的工具类。
其代码如下：别骂我BT，功能还是很强悍的。
import java.util.Map;
import java.lang.StringBuffer;public class DynamicString {
 abstract class DynamicPattern{
 DynamicPattern next;
 public abstract String convert(Map pattern);
 }
 class StringPattern extends DynamicPattern{
 private String pattern;
 public StringPattern(String pattern){
 this.pattern=pattern;
 }
 public StringPattern(StringBuffer buff,int start,int end){
 this.pattern=buff.substring(start,end);
 }
 public StringPattern(StringBuffer buff){
 this.pattern=buff.toString();
 }
 public String convert(Map map){
 return pattern;
 }
 }
 class MappedPattern extends DynamicPattern{
 private String key;
 public MappedPattern(String key){
 this.key=key;
 }
 public MappedPattern(StringBuffer buff,int start,int end){
 this.key=buff.substring(start,end);
 }
 public String convert(Map param){
 return param.get(key)==null?null:param.get(key).toString();
 }
 } private String dynStr ;
 private DynamicPattern header;
 private DynamicPattern tail;
 public DynamicString(String dynStr) {
 this.dynStr=dynStr;
 init(dynStr);
 }
 private DynamicString appendPattern(DynamicPattern pattern){
 if(header==null){
 header = pattern;
 tail=header;
 }else{
 tail.next=pattern;
 tail=pattern;
 }
 return this;
 }
 private void init(String dynStr){
 header = tail = null;
 StringBuffer buff = new StringBuffer(dynStr);
 int len = buff.length();
 int start = 0,ptr=1;
 boolean noMatching=true;
 for (ptr = start; ptr < len; ptr++) {
 if (buff.charAt(ptr) == '$' && buff.charAt(ptr + 1) == '{' ) {
 if (ptr==0 || buff.charAt(ptr - 1) != '\\') {
 if (ptr>2 && buff.charAt(ptr - 2) == '\\') {
 buff.deleteCharAt(ptr - 2);
 --ptr;
 }
 noMatching=false;
 int end = ptr;
 StringPattern sp = new StringPattern(buff, start, end);
 appendPattern(sp);
 ptr += 2;
 for (; ptr < len; ptr++) {
 if (buff.charAt(ptr) == '}' && buff.charAt(ptr - 1) != '\\') {
 if (buff.charAt(ptr - 2) == '\\') {
 buff.deleteCharAt(ptr - 2);
 --ptr;
 }
 MappedPattern mp = new MappedPattern(buff, end+2, ptr);
 appendPattern(mp);
 noMatching=true;
 start = ++ptr;break;
 }
 }
 }
 }
 }
 if(noMatching && ptr<=len)appendPattern(new StringPattern(buff,start,ptr));
 }
 public String parse(Map param){
 if(header==null)return null;
 DynamicPattern ptr = header;
 StringBuffer sb = new StringBuffer();
 while(ptr!=null){
 sb.append(ptr.convert(param));
 ptr=ptr.next;
 }
 return sb.toString();
 }
}用例：DynamicString dynStr = new DynamicString("你的职位是${manager}");
HashMap param = new HashMap(4);
param.put("manager","经理");
String result = dynStr.parse(param);

调试易

正则表达式的表示

解决方案 »