类似于正则的用法. \\\\四个反斜线,最后会表示为一个\反斜线.
String s = "a(bc)d_abcd";
System.out.println(s.replaceAll("_", "\\\\_"));
结果:
a(bc)d\_abcd

String testg = "amfooniceshow";
//$2 相当于对前面正则表达式的第二组进行引用
System.out.println(testg.replaceAll("(am)(foo)", "$2haha"));
结果:
foohahaniceshow

//结果是1, 相当于有一个组,这种是()被认为是一个分组.
Pattern p = Pattern.compile("(?<xxx>)");
System.out.println(p.matcher("ab").groupCount());
//常规的结果是0, 相当于没有新建分组
Pattern pp = Pattern.compile("xxx");
System.out.println(pp.matcher("ab").groupCount());
//常规的非捕获组结果也是0, 相当于没有新建分组
Pattern ppp = Pattern.compile("(?<=xxx)");
System.out.println(ppp.matcher("ab").groupCount());

package com.xjl456852.manager;

import java.util.regex.Matcher;

/**
 * Created by xjl456852 on 2017/3/9.
 */
public class StringTest {
    public static void main(String args[]) {
        String s = "a(bc)d_abcd";
        System.out.println(s.replaceAll("_", "\\\\_"));
        //会出错
//        System.out.println(s.replaceAll("_", "\\\\$"));
        System.out.println(s.replaceAll("_", "\\\\\\$"));
        //可用Matcher.quoteReplacement() 对replaceAll的第二个参数进行转义
        System.out.println(s.replaceAll("_", Matcher.quoteReplacement("\\$")));
        System.out.println(s.replaceAll("_", "\\$"));
        System.out.println(s.replaceAll("_", "\\."));
        System.out.println(s.replaceAll("_", "."));
        System.out.println(s.replaceAll("_", "\\\\%"));
        System.out.println(s.replaceAll("_", "\\5"));
        System.out.println(s.replaceAll("_", "5"));
        System.out.println(s.replaceAll("_", "5"));
        System.out.println(s.replaceAll("_", "\""));
        System.out.println(s.replaceAll("_", "\\\""));
        System.out.println(s.replaceAll("_", "\\${1}"));
        //会出错 ${} 这个大括号里面不能是数字
//        System.out.println(s.replaceAll("_", "${1}"));

        String testg = "amfooniceshow";
        //$2 相当于对前面正则表达式的第二组进行引用
        System.out.println(testg.replaceAll("(am)(foo)", "$2haha"));

        System.out.println("--------------");
        String test = "hahaam${foo}niceshow";
        System.out.println(test.replaceAll("\\$\\{.*\\}", "\\\\\\$\\{ss\\}"));
        
        System.out.println(test.replaceAll("\\$\\{.*\\}", Matcher.quoteReplacement("\\${ss}")));
        //会出现错误
//        System.out.println(test1.replaceAll("\\$\\{.*\\}", "${ss}"));

    }
}

a(bc)d\_abcd
a(bc)d\$abcd
a(bc)d\$abcd
a(bc)d$abcd
a(bc)d.abcd
a(bc)d.abcd
a(bc)d\%abcd
a(bc)d5abcd
a(bc)d5abcd
a(bc)d5abcd
a(bc)d"abcd
a(bc)d"abcd
a(bc)d${1}abcd
foohahaniceshow
--------------
hahaam\${ss}niceshow
hahaam\${ss}niceshow

package com.xjl456852.manager;

import java.util.regex.Pattern;

/**
 * Created by xjl456852 on 2017/3/9.
 */
public class StringTest {
    public static void main(String args[]) {
        
        System.out.println("下面是${name}格式的replaceAll替换");
        String test1 = "hahaamfooniceshowerqwhdfgsd";
        System.out.println("--------------------");
        //${name} 属于有名字的领宽度匹配的引用.name必须是大写或小写字母,不能是其它符号或者数字.这种用法真是少见,感觉没什么实际的意义.
        //${name} 中的name,是一种分组的名字,也就是说在前面的正则中需要写入这样的名字.而且这个名字的写法比较特殊.
        //我查看源码之后了解到这种写法必须是<?name>的格式.
        //例如下面.它的意思是:sho为零宽度匹配,这个可以匹配wer
        System.out.println(test1.replaceAll("(?<sho>)wer", "${sho}123456"));
        //下面这两个虽然按理说不能匹配wer,因为<sh>中少了个o,但其实可以匹配wer(这种用法真是不知道在那种场景中才能用到),所以将wer替换为123456
        System.out.println(test1.replaceAll("(?<sh>)wer", "123456"));
        System.out.println(test1.replaceAll("(?<sh>)wer", "${sh}123456"));
        //这个参数b中使用了$1,而(?<sh>)会被认为是一个分组,但是这个又是零宽度的,所以$1相当于没有引用.而$1已经被使用,所以1不会打印出来,只会打印23456
        System.out.println(test1.replaceAll("(?<sh>)wer", "$123456"));
        System.out.println("----------------------");
        //下面这两个写的<xxx>这种字符是不存在的,但是后面的we也会被替换
        System.out.println(test1.replaceAll("(?<xxx>)we", "123${xxx}456"));
        //下面这个和上面那个一样,<xxx>这个是不存在的,但是ho和we都会被替换掉
        System.out.println(test1.replaceAll("ho(?<xxx>)we", "123${xxx}456"));
        //这个h后面少了o,后面紧接着是we,故无法匹配字符串,所以会以原字符串输出
        System.out.println(test1.replaceAll("h(?<xxx>)we", "123${xxx}456"));
        System.out.println("------------------");
        //这个也匹配不到,所以无法替换,所以会以原字符串输出
        System.out.println(test1.replaceAll("(?<sho>)dwer", "123456"));
        //下面这两个都是领宽度匹配,前后都没条件,无论<>中写的是什么字符串,前后都没有条件,就不会匹配任何字符串,按领宽度匹配处理,所以会在每个字符串的前后都插入123.
        System.out.println(test1.replaceAll("(?<sho>)", "123"));
        System.out.println(test1.replaceAll("(?<xxx>)", "123"));
        System.out.println("=============================");
        //这个是用非捕获组进行的匹配.会在sh后面插入123
        System.out.println(test1.replaceAll("(?<=sh)", "123"));
        //其实用非捕获字也能实现这种每个字符的前后都插入相同目标字符串的功能.但是这个有一个特点就是原字符串中必须不包含xxx
        System.out.println(test1.replaceAll("(?<!xxx)", "123"));
        //比如下面的这个,原字符串中就包含sh,使用?<!sh ,意思是不是sh的字符串都插入123.这时结果跟上一个字符串相比就少了一组123.
        // 因为检查到字符s时,发现不是sh,所以会插入123,再次检查到h时,发现是sh,所以不插入,这时会跳过.h后面就会少一组123
        System.out.println(test1.replaceAll("(?<!sh)", "123"));
        System.out.println("-------------");
        
        //下面是一些其它的写法可以根据结果自己理解.
        System.out.println(test1.replaceAll("(?<ha>)haam.*?(ce)(?<sh>).*?(fg)", "12${ha}34${sh}56"));
        System.out.println(test1.replaceAll("(?<ha>)haam", "123456${ha}"));
        System.out.println(test1.replaceAll("(ce)(?<sh>)", "1234${sh}56"));
        System.out.println(test1.replaceAll("ce(?<sh>)", "123456"));
        System.out.println("-------------");
        System.out.println(test1.replaceAll("(?<sh>)ow", "1234${sh}56"));
        System.out.println(test1.replaceAll("(?<sh>)ow", "123456"));
        System.out.println("-------------");
        System.out.println(test1.replaceAll("(ce)(?<sh>)(ow)", "1234${sh}56"));
        System.out.println(test1.replaceAll("ce(?<sh>)ow", "1234${sh}56"));
        System.out.println(test1.replaceAll("(?<sh>)", "1234${sh}56"));
        System.out.println(test1.replaceAll("(?<haam>)", "123${haam}456"));
        System.out.println("---------------------");
        System.out.println(test1.replaceAll("(?<xxx>)", "123${xxx}456"));
        System.out.println(test1.replaceAll("(?<xxx>)", "123456"));

        //结果是1, 相当于有一个组,这种是()被认为是一个分组.
        Pattern p = Pattern.compile("(?<xxx>)");
        System.out.println(p.matcher("ab").groupCount());
        //常规的结果是0, 相当于没有新建分组
        Pattern pp = Pattern.compile("xxx");
        System.out.println(pp.matcher("ab").groupCount());
        //常规的非捕获组结果也是0, 相当于没有新建分组
        Pattern ppp = Pattern.compile("(?<=xxx)");
        System.out.println(ppp.matcher("ab").groupCount());
        
       
    }
}