JavaSE正则表达式用法总结大全

[a-z] //匹配 a到z任意一个字符

[a-z] //匹配 a到z任意一个字符

[0-9] //匹配 0到9任意一个数字

[^a-z] //匹配 不是a到z任意一个字符

[^a-z] //匹配 不是a到z任意一个字符

[^0-9] //匹配 不是0到9任意一个数字

[abcd] //匹配 abcd中的任意一个字符

abc   //匹配 abc字符串区分大小写
    
(?i)abc //匹配 abc字符串不区分大小写

a(?i)bc //匹配 abc字符串后面的bc不区分大小写

a((?i)b)c //匹配 abc字符串中间的b不区分大小写    
    
\\d //匹配数字字符，等价于 [0-9]。
    
\\d //匹配非数字字符，等价于 [^0-9]    

\\w //匹配字母、数字或下划线，等价于 [a-za-z0-9_]
    
\\w //匹配非字母、数字或下划线，等价于 [^a-za-z0-9_] 

\\s //匹配空白字符（包括空格、制表符、换行符等） 
    
\\s //匹配非空白字符（包括空格、制表符、换行符等）\s的反义   
    
. //匹配出\n外的任意字符，如果向匹配.字符本身，可以使用\\.   
    
| //选择匹配符，例如 ab|bc 表示匹配ab或者bc的字符串
    
* //指定字符重复0次或n次(无要求)零到多 示例 (abc)* 匹配输入 abc,abcabcabc

+ //指定字符重复1次或n次（至少一次） 示例 m+(abc)* 以至少1个m开头，后接任意个abc的字符串  匹配输入 m,mabc,mabcabc,mmabc 

? //指定字符重复0次或1次（最多一次） 示例 m+abc? 以至少一个m开头，后接ab或者abc的字符串 匹配输入 mab,mabc,mmmab,mmabc
    
{n} //只能输入n个字符 [abcd]{3} 由abcd中字母组成的任意长度为3的字符串 匹配输入 abc,dbc,adc    

{n,} //指定至少n个匹配 示例 [abcd]{3,} 说明：由abcd中字母组成的任意长度不小于3的字符串

{n,m} //指定至少n个但不多于m个匹配 示例 [abcd]{3,5} 说明：由abcd中字母组成的任意长度不小于3，不大于5的字符串

^ //指定起始字符 示例 ^[0-9]+[a-z]* 说明：以至少1个数字开头，后接任意个小写字母的字符串 匹配输入：123,6aa,555edf
    
$ //指定结束符 示例 ^[0-9]\\-[a-z]+$ 说明：以1个数字开头后连接字符 "-" ,并以至少1个小写字母结尾的字符串 匹配输入：1-a

\\b //匹配目标字符串的边界 示例 han\\b 说明：这里说的字符串边界指的是子串间有空格，或者是目标字符串的结束文字 匹配输入：asfasdffate asdfafate   
    
\\b //匹配目标字符串的非边界 示例 han\\b 说明：和\b的含义刚刚相反 匹配输入：fateafadsfafa fateafadsfasdf    
    
(pattern) //非命名捕获。捕获匹配的子字符串，编号为零的第一个捕获的是由整个正则表达式模式匹配的文本，其他捕获结果则根据左括号的顺序从1开始自动编号
    
(?<name> pattern) //命名捕获。将匹配的子字符串捕获到一个组名称或编号名称中，用于name的字符串不能包含任何标点符号，并且不能以数字开头

(?:pattern) //匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用“or”字符(||)组合模式部件的情况很有用。例如，'industr'(?:y|lies)是对‘industry|industries'更经济的表达式

(?=pattren) //它是一个非捕获匹配。例如，‘windows(?=95|98|nt|2000)'匹配“windows 2000”中的"windows",但不匹配“windows 3.1”中的“windows”

(?!pattren) //该表达式匹配不处于匹配 pattren 的字符串的起始点的搜索字符串。它是一个非捕获匹配。例如，‘windows(?!95|98|nt|2000)'匹配“windows 3.1”中的"windows",但不匹配“windows 2000”中的“windows”
    
//注意点:java默认是遵循贪婪匹配的，比如一个字符串为 2009 编写的正则表达式为 \\d+ 最后在程序执行后 结果为 2009 (优先匹配到数量多的 即2009)
//如果不想遵循贪婪匹配，可以在对应的正则表达式后添加?符号 例如 \\d+? 匹配上面的结果就为2 0 0 9
 
//当创建pattern对象时，指定pattern.case_insensitive,表示匹配字符串是不区分字母大小写的
pattern pattern = pattern.compile(regstr,pattern.case_insensitive);
matcher matcher = pattern.matcher(str);    

//非命名分组和命名分组的代码验证
public class test {
    public static void main(string[] args) {
        string str = "mioyuimugi1989fateafadsfasdf1999 ";
        //非命名分组
//        string regstr = "(\\d\\d)(\\d\\d)";//匹配连续的4个数字
        //命名分组
        string regstr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";//匹配连续的4个数字
        pattern pattern = pattern.compile(regstr);
        matcher matcher = pattern.matcher(str);
        while(matcher.find()) {
            system.out.println("找到："+matcher.group(0));
            system.out.println("找到分组[1]="+matcher.group(1));
            system.out.println("找到分组[g1]="+matcher.group("g1"));
            system.out.println("找到分组[2]="+matcher.group(2));
            system.out.println("找到分组[g2]="+matcher.group("g2"));
        }
    }
}

public class test {
    public static void main(string[] args) {
        //非捕获分组 (?:pattern) 代码演示如下
        //不能使用 matcher.group(1)
        string str = "轻音少女2009 轻音少女2010 轻音少女2011";
        string regexp = "轻音少女(?:2009|2010|2011)";
        pattern pattern = pattern.compile(regexp);
        matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            system.out.println("找到："+matcher.group(0));
        }
    }
}

public class test {
    public static void main(string[] args) {
        //非捕获分组 (?!pattern) 代码演示如下
        //不能使用 matcher.group(1)
        string str = "轻音少女2009 轻音少女2010 轻音少女2011 轻音少女2025";
        string regexp = "轻音少女(?!2009|2010|2011)";
        pattern pattern = pattern.compile(regexp);
        matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            system.out.println("找到："+matcher.group(0));//该模式下匹配到的是轻音少女2025
        }
    }
}

public class test {
    public static void main(string[] args) {
        //默认贪婪匹配和非贪婪匹配的区别和演示
        string str = "轻音少女2009 轻音少女2010 轻音少女2011 轻音少女2025";
        string regexp = "\\d+";//默认贪婪匹配
        pattern pattern = pattern.compile(regexp);
        matcher matcher = pattern.matcher(str);
        system.out.println("============================贪婪模式下匹配结果=========================");
        while (matcher.find()) {
            system.out.println("找到："+matcher.group(0));
        }
        regexp = "\\d+?";//改成了非贪婪匹配
        pattern = pattern.compile(regexp);
        matcher = pattern.matcher(str);
        system.out.println("============================非贪婪模式下匹配结果=========================");
        while (matcher.find()) {
            system.out.println("找到："+matcher.group(0));
        }
    }
}

public class test {
    public static void main(string[] args) {
        //默认贪婪匹配和非贪婪匹配的区别和演示
        string str = "轻音少女2009 轻音少女2010 轻音少女2011 轻音少女2025";
        string regexp = "\\d*";//默认贪婪匹配
        pattern pattern = pattern.compile(regexp);
        matcher matcher = pattern.matcher(str);
        system.out.println("============================贪婪模式下匹配结果=========================");
        while (matcher.find()) {
            system.out.println("找到："+matcher.group(0));
        }
        regexp = "\\d*?";//改成了非贪婪匹配
        pattern = pattern.compile(regexp);
        matcher = pattern.matcher(str);
        system.out.println("============================非贪婪模式下匹配结果=========================");
        while (matcher.find()) {
            system.out.println("找到："+matcher.group(0));
        }
    }
}

public class regexpdemo1 {
public static void main(string[] args) {
    string content = "jdk1.3 jdk1.4";
    system.out.println("content="+content);
    content = content.replaceall("(jdk)(?:1.3|1.4)","$1");
    system.out.println("content="+content);
}
}

public class regexpdemo1 {
    public static void main(string[] args) {
       //要求验证是不是整数或者小数
        //注意：该题要考虑正数和负数 比如：123 -345 34.89 -87.9 -0.001 0.45 等
        string numstr = "+45";
        string regexp = "^[-+]?([1-9]\\d*|0)(\\.\\d+)?$";
        if (numstr.matches(regexp)) {
            system.out.println("匹配成功，是整数或小数！"+numstr);
        } else {
            system.out.println("匹配不成功，不是整数或小数！"+numstr);
        }
    }
}