正则表达式的使用

前言

每次用到正则的时候都是去查一下，再写，写完下次再写的时候就用忘了。用的频率挺高，有必要总结一下，加深一下印象。
在JDK1.3及之前的JDK版本中并没有包含正则表达式的类，如果要在Java中使用正则表达式必须使用第三方提供的正则表达式库。从JDK1.4开始提供了支持正则表达式API，它们位于java.util.regex包中。

示例

//?:0或1个, *:0或多个, +:1或多个 
 Boolean isNumber= str.matches("-?[0-9]+\\.?[0-9]*");

语法

1 预定义字符类

符号	说明
.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]
\	转义字符，比如"\“匹配”" ,"{“匹配”{"

2 数量词

符号	说明
*	等价于｛0，｝匹配0至多个在它之前的字符。例如正则表达式“zo*”能匹配“z”以及“zoo”；正则表达式“.*”意味着能够匹配任意字符串。
+	等价于｛1，｝匹配前面的子表达式一次或多次。例如正则表达式9+匹配9、99、999等。
?	等价于｛0，1｝ 匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 或 “does” 中的"do" 。此元字符还有另外一个用途，就是表示非贪婪模式匹配，后边将有介绍
{n}	匹配确定的 n 次。例如，“e{2}”不能匹配“bed”中的“e”，但是能匹配“beed”中的两个“e”。
{n,}	至少匹配n次。例如，“e{2,}”不能匹配“bed”中的“e”，但能匹配“beeeeeeeed”中的所有“e”
{n,m}	最少匹配 n 次且最多匹配 m 次。“e{1,3}”将匹配“beeeeeeeed”中的前三个“e”

3 边界匹配符号

符号	说明
^	行的开头
$	行的结尾
\b	单词边界
\B	非单词边界
\A	输入的开头
\G	上一个匹配的结尾
\Z	输入的结尾，仅用于最后的结束符（如果有的话）
\z	输入的结尾

4 其他常见符号

[ ]	说明
[ ]	匹配括号中的任何一个字符
[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]	a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]	d、e 或 f（交集）
[a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]	a 到 z，而非 m 到 p：[a-lq-z]（减去）

()	说明
（）	将 () 之间括起来的表达式定义为“组”(group)，并且将匹配这个表达式的字符保存到一个临时区域,这个元字符在字符串提取的时候非常有用。捕获组可以通过从左到右计算其开括号来编号。
(\d)	第一组
((A)(B (D) ))	第一组 ((A)(B(D))) 第二组 (A) 第三组(B(D)) 第四组(D)

PS:更多其他符号，可参照 http://www.cnblogs.com/Mustr/p/6057159.html

Java使用到的类

Pattern 类：

pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

Matcher 类：

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

 // 按指定模式在字符串查找
 String line = "This order was placed for QT3000! OK1234?";
 String pattern = "(\\D*)(\\d+)(.?)";

 // 创建 Pattern 对象
 Pattern r = Pattern.compile(pattern);

 // 现在创建 matcher 对象
 Matcher m = r.matcher(line);

 boolean matches = line.matches(pattern);//String的底层用的也是下面这个方法
 while (m.find()){
     System.out.println("groupCount : " +  m.groupCount());
     System.out.println("Found value: " + m.group() );//匹配到的字符串 同下
     //匹配到的字符串 它总是代表整个表达式。该组不包括在 groupCount 的返回值中。
     System.out.println("Found value: " + m.group(0) );
     System.out.println("Found value: " + m.group(1) );
     System.out.println("Found value: " + m.group(2) );
     System.out.println("Found value: " + m.group(3) );
     System.out.println(m.start()+"...."+m.end());
 }

find()与matches()的区别
首先find()和matches()都会改变游标的位置，比如matches后，再find的字符串是从全局匹配完成（从左到右匹配，直到配到完成或者匹配失败）后的位置开始的。
再者，两者的方式不同，find()是从原字符串里找能匹配上的字串，而matches是用整个原字符串去匹配。
最后，如果要重置匹配位置，可以使用find(0)（说明：find(int start)，重置匹配器，然后尝试查找索引start开始的下一个满足匹配的子序列，所以find(0)相当于重置为最原始状态）。

// 按指定模式在字符串查找
String line = "Don't 123 you wanna be my Soldier 123adv";
String pattern = ".* 123.?";

// 创建 Pattern 对象
Pattern r = Pattern.compile(pattern);

// 现在创建 matcher 对象
Matcher m = r.matcher(line);

System.out.println(m.matches());
while (m.find()){
   System.out.println("Found value:---" + m.group() + "---" );
   System.out.println(m.start()+"...."+m.end());
}

使用

1 匹配

String matches（）方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。
举例：

public static void checkQQ(){
        String qq = "123a45664";
		//第一位是1-9 后面跟4-14位的数字
        String regex = "[1-9]\\d{4,14}";

        boolean flag = qq.matches(regex);
        if(flag)
            System.out.println(qq+"...is ok");
        else
            System.out.println(qq+"... 不合法");
         
}

	/*
    匹配
    手机号段只有 13xxx 15xxx 18xxxx

    */
    public static void checkTel()
    {
        String tel = "16900001111";
        String telReg = "1[358]\\d{9}";
        System.out.println(tel.matches(telReg));
    }

2 切割

String split()方法; 根据给定正则表达式的匹配拆分此字符串。返回一个数组。
举例：

public static void splitDemo()
        {
    
        String str = "avg   bb   geig   glsd   abc";
        String reg = " +";//按照多个空格来进行切割
        String[] arr = str.split(reg);  
        System.out.println(arr.length);
        for(String s : arr)
        {
            System.out.println(s);
        }
    }

组group举例：

public static void splitDemo()
        {
    
        String str = "erkktyqqquuizzzzzo";
        String reg ="(q)(u)\\2+";//按照叠词来进行切割
        
        String str = "erkktyqqquizzzzzo";
        String reg ="(.)\\1+";//按照叠词来进行切割
            //可以将规则封装成一个组。用()完成。组的出现都有编号。
            //从1开始。 想要使用已有的组可以通过  \n(n就是组的编号)的形式来获取。
            //正则表达式中的小括号"()"。是代表分组的意思。 如果再其后面出现\1则是代表与第一个小括号中要匹配的内容相同。
 			//注意：\1必须与小括号配合使用
        String[] arr = str.split(reg);  
        System.out.println(arr.length);
        for(String s : arr)
        {
            System.out.println(s);
        }
    }  
     // er，ty，ui，o

3 替换

String replaceAll(regex,str)方法; 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

ps：如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式中的已有的组。

举例：

public static void replaceAllDemo()
    {
    
        String str = "w1234er1389980000ty1234564uiod234345675f";//将字符串中的数字替换成#。
 
        str = str.replaceAll("\\d{5,}","#");

        System.out.println(str);
    }

组group举例：

public static void replaceAllDemo()
    {
    
        String str = "erkktyqqquizzzzzo";//将叠词替换成$.  //将重叠的字符替换成单个字母。zzzz->z
 
        str = str.replaceAll("(.)\\1+","$1");

        System.out.println(str);
    }

\1 类似于$1,必须和()分组联合使用，表示第几组的值。

String str = "2020-11-06";
System.out.println(str.matches("(\\d{4})(-)(\\d{2})(-)(\\d{2})"));
str = str.replaceAll("(\\d{4})(-)(\\d{2})(-)(\\d{2})","$1年$3月$5日");
System.out.println(str);

replaceAll 和 replace区别

1.replace 的参数是 char 和 CharSequence，即可以支持字符的替换，也支持字符串的替换(CharSequence 即字符串序列的意思，说白了也就是字符串)；
2.replaceAll 的参数是 regex，即基于正则表达式的替换。replaceFirst也是正则。
3.String 类执行了替换操作后，返回一个新的对象，源字符串的内容是没有发生改变的。（subString是会变的）

        String str = "2020-11-06***2020-11-06";
        String str_ = str.replace("2020-11-06","$1年$3月$5日");
        System.out.println(str);
        System.out.println(str_);

        String str2 = "2020-11-06***2020-11-06";
        String str2_ = str2.replaceAll("(\\d{4})(-)(\\d{2})(-)(\\d{2})","$1年$3月$5日");
        System.out.println(str2);
        System.out.println(str2_);

        String str3 = "2020-11-06***2020-11-06";
        String str3_ = str3.replaceFirst("(\\d{4})(-)(\\d{2})(-)(\\d{2})","$1年$3月$5日");
        System.out.println(str3);
        System.out.println(str3_);

4 获取

----将字符串中的符合规则的子串取出。
操作步骤：
　　　　1，将正则表达式封装成对象。
　　　　2，让正则对象和要操作的字符串相关联。
　　　　3，关联后，获取正则匹配引擎。
　　　　4，通过引擎对符合规则的子串进行操作，比如取出。

举例：

public static void getDemo()
    {
        String str = "yin yu shi wo zui cai de yu yan";
        System.out.println(str);
        String reg = "\\b[a-z]{3}\\b";//匹配只有三个字母的单词

        //将规则封装成对象。
        Pattern p = Pattern.compile(reg);

        //让正则对象和要作用的字符串相关联。获取匹配器对象。
        Matcher m  = p.matcher(str);

        //System.out.println(m.matches());//其实String类中的matches方法。用的就是Pattern和Matcher对象来完成的。
        //只不过被String的方法封装后，用起来较为简单。但是功能却单一。

       // boolean b = m.find();//将规则作用到字符串上，并进行符合规则的子串查找。
       // System.out.println(b);
       // System.out.println(m.group());//用于获取匹配后结果。
        
        
        while(m.find())
        {
            System.out.println(m.group());
            System.out.println(m.start()+"...."+m.end());
                // start()  字符的开始下标（包含）
                //end()  字符的结束下标（不包含）
        }
    }