正则表达式（完成）

特殊字符

所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 *，简单的说就是表示任何字符串的意思。如果要查找字符串中的 * 符号，则需要对 * 进行转义，即在其前加一个 \: runo\*ob 匹配 runo*ob。

许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符\ 放在它们前面。下表列出了正则表达式中的特殊字符：

特殊字符	描述
$	匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。
( )	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。
*	匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。
+	匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。
.	匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \. 。
[	标记一个中括号表达式的开始。要匹配 [，请使用 \[。
?	匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。
\	将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("。
^	匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。
{	标记限定符表达式的开始。要匹配 {，请使用 \{。
|	指明两项之间的一个选择。要匹配 |，请使用 \|。

限定符

限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 * 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共6种。

正则表达式的限定符有：

限定符	描述
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 、 "does" 中的 "does" 、 "doxy" 中的 "do" 。? 等价于 {0,1}。
{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?'。请注意在逗号和两个数之间不能有空格。

定位符

定位符使您能够将正则表达式固定到行首或行尾。它们还使您能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。

定位符用来描述字符串或单词的边界，^ 和 $ 分别指字符串的开始与结束，\b 描述单词的前或后边界，\B 表示非单词边界。

正则表达式的定位符有：

定位符	描述
^	匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与 \n 或 \r 之后的位置匹配。
$	匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与 \n 或 \r 之前的位置匹配。
\b	匹配一个单词边界，即字与空格间的位置。
\B	非单词边界匹配。

注意：不能将限定符与定位符一起使用。由于在紧靠换行或者单词边界的前面或后面不能有一个以上位置，因此不允许诸如 ^* 之类的表达式。

元字符

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。
^	匹配输入字符串的开始位置。^ 也匹配 '\n' 或 '\r' 之后的位置。
$	匹配输入字符串的结束位置。$ 也匹配 '\n' 或 '\r' 之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。
{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?'。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
.	匹配除换行符（\n、\r）之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用像"(.|\n)"的模式。
(pattern)	匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到。 要匹配圆括号字符，请使用 '\(' 或 '\)'。
(?:pattern)	匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern)	(?=exp)代表匹配以exp结尾的字符串，但匹配出来的结果并不带exp。例如(?=ing)匹配reading，结果为read
(?!pattern)
(?<=pattern)	(?<=exp)匹配以exp开头的字符串，但结果不带exp，例如(?<=read)匹配reading，结果为ing
(?<!pattern)
x|y	匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz]	字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。
[a-z]	字符范围。匹配指定范围内的任意字符。 例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\w	匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。
\W	匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。

正则表达式

1.校验数字表达式

描述	正则表达式
数字	^[0-9]*$
n位的数字	^\d{n}$
至少n位的数字	^\d{n,}$
m-n位的数字	^\d{m,n}$
零和非零开头的数字	^(0|[1-9][0-9]*)$
非零开头的最多带两位小数的数字	^([1-9][0-9]*)+(\.[0-9]{1,2})?$
带1-2位小数的正数或负数	^(\-)?\d+(\.\d{1,2})$
正数、负数、和小数	^(\-|\+)?\d+(\.\d+)?$
有两位小数的正实数	^[0-9]+(\.[0-9]{2})?$
有1~3位小数的正实数	^[0-9]+(\.[0-9]{1,3})?$
非零的正整数	^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
非零的负整数	^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
非负整数	^\d+$ 或 ^[1-9]\d*|0$
非正整数	^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
浮点数	^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
正浮点数	^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
负浮点数	^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$

2.校验字符表达式

描述	正则表达式
汉字	^[\u4e00-\u9fa5]{0,}$
英文和数字	^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
长度为3-20的所有字符	^.{3,20}$
由26个英文字母组成的字符串	^[A-Za-z]+$
由26个大写英文字母组成的字符串	^[A-Z]+$
由26个小写英文字母组成的字符串	^[a-z]+$
由数字和26个英文字母组成的字符串	^[A-Za-z0-9]+$
由数字、26个英文字母或者下划线组成的字符串	^\w+$ 或 ^\w{3,20}$
中文、英文、数字包括下划线	^[\u4E00-\u9FA5A-Za-z0-9_]+$
中文、英文、数字但不包括下划线等符号	^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
可以输入含有^%&',;=?$\"等字符	[^%&',;=?$\x22]+
禁止输入含有~的字符	[^~\x22]+

3.特殊需求表达式

描述	正则表达式
Email地址	^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
域名	[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
手机号码	^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)	^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
国内电话号码(0511-4405222、021-87888822)	\d{3}-\d{8}|\d{4}-\d{7}
身份证号(15位、18位数字)，最后一位是校验位，可能为数字或字符X	(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)
密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)	^[a-zA-Z]\w{5,17}$
强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在 8-10 之间)	^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])[a-zA-Z0-9]{8,10}$
强密码(必须包含大小写字母和数字的组合，可以使用特殊字符，长度在8-10之间)	^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
日期格式	^\d{4}-\d{1,2}-\d{1,2}
一年的12个月(01～09和1～12)	^(0?[1-9]|1[0-2])$
一个月的31天(01～09和1～31)	^((0?[1-9])|((1|2)[0-9])|30|31)$
钱的输入格式：必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的	^[0-9]+(.[0-9]{2})?$
钱的输入格式：这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样	^[0-9]+(.[0-9]{1,2})?$
钱的输入格式：这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样	^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
钱的输入格式：1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须	^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
钱的输入格式：一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号	^(0|-?[1-9][0-9]*)$
钱的输入格式：这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式	^(0|[1-9][0-9]*)$
xml文件	^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
中文字符的正则表达式	[\u4e00-\u9fa5]
空白行的正则表达式	\n\s*\r (可以用来删除空白行)
腾讯QQ号	[1-9][0-9]{4,} (腾讯QQ号从10000开始)
中国邮政编码	[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
IP地址	((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))

 

 

Java实现方案

String name = "context.name";
String entityRgex = "(.*?)(?=[\\.])";// 正则匹配account.name结构的entity
String fieldRgex = "(?<=[a-z]{2,}\\.)(.*?)$";// 正则匹配account.name结构的field

Pattern entityPattern = Pattern.compile(entityRgex);// 匹配的模式
Pattern filedPattern = Pattern.compile(fieldRgex);// 匹配的模式
Matcher entityMatcher = entityPattern.matcher(name);
Matcher fieldMatcher = filedPattern.matcher(name);
if (entityMatcher.find()) {
    int i = 1;
    System.out.println(entityMatcher.group(i));
    i++;
}
if (fieldMatcher.find()) {
    int j = 1;
    System.out.println(fieldMatcher.group(j));
    j++;
}

输出：
context
name

 

String str = "+"+" name:'lihuan' OR title:'文章' AND age:20";

String rgex_1 = "(?<=[\\+*]|[-]|[\\(]|(?<=[A-Z]{3}\\x20|[A-Z]{2}\\x20))(.*?)(?=[:])";

Pattern pattern = Pattern.compile(rgex_1);// 匹配的模式
   Matcher m_1 = pattern.matcher(str);
   while (m_1.find()) {
       int i = 1;
       System.out.println(m_1.group(i));
       i++;
}



String lucene_1 = " "+"account.del_flg:0 AND account.account_type:1 " +
                "AND ( account.owner_id:(644925) " +
                "OR account.inner_group_id:(32949268 OR 52045661) " +
                "OR ( ( (*:* AND (!(_exists_:account.dim_depart)))  " +
                "OR ( account.dim_depart:(344391 OR 344390 OR 579195 OR 344386 OR 579613 OR 579614 OR 344393 OR 344392) ) ))) " +
                "AND (account.dbc_select_1:(1 OR 2) " +
                "AND (account.account_name:*beijingshanghaiqiyeshagnhui* OR account.pinyin:*beijingshanghaiqiyeshagnhui*) " +
                "AND account.dbc_select_17:\"1\"";

String lucene_2 = " +account.del_flg:0 AND account.account_type:1 AND account.high_sea_status:(0 OR 1 OR 3 OR 4) AND ( account.owner_id:(571971) OR account.inner_group_id:(12409869 OR 9953328 OR 30750291) OR ( ( (*:* AND (!(_exists_:account.dim_depart))) )))  ";

String lucene_3 = " "+"+account.del_flg:0 AND account.account_type:1 AND account.high_sea_status:(0 OR 1 OR 3 OR 4) AND ( account.owner_id:(854638 OR 471062 OR 557917) OR account.inner_group_id:(12385601 OR 19796278) OR ( ( (*:* AND (!(_exists_:account.dim_depart)))  OR ( account.dim_depart:(253798 OR 254059 OR 254056 OR 254061 OR 254049 OR 254048 OR 254052 OR 254283 OR 254044 OR 254045 OR 254046 OR 254047 OR 254284 OR 254032 OR 254036 OR 254024 OR 254029 OR 254018 OR 254021 OR 351254 OR 254015 OR 254013 OR 254010 OR 254011 OR 254006 OR 254007 OR 254002 OR 253999 OR 253997 OR 253993 OR 253992 OR 253991 OR 253990 OR 253988 OR 253987 OR 253986 OR 253984 OR 253980 OR 253981 OR 253982 OR 253977 OR 253978 OR 253979 OR 253972 OR 253973 OR 253974 OR 253975 OR 253968 OR 253969 OR 253970) ) ))) ";

String lucene_4 = " "+"account.owner_id : (25101) OR ( ( (*:* AND -account.dim_depart:* )  OR ( account.dim_depart:(116211) ) ))";

String lucene = " "+"account.owner_id : (25101) OR ( ( (*:* AND -account.dim_depart:* )  OR ( account.dim_depart:(116211) ) ))";

String luceneRgex = "(?<=[\x20]|[\+]|[-]|[\(]|[\x20\(]|(?<=[A-Z]{3}\x20|[A-Z]{2}\x20))[a-z]+[\.]?(.*?)(?=[:])";


Pattern pattern = Pattern.compile(luceneRgex);// 匹配的模式
    Matcher m_1 = pattern.matcher(lucene_4);
    while (m_1.find()) {
        int i = 1;
        System.out.println(m_1.group(i));
        i++;
}

String string = "rows=[Rowcolumns=[1, c], Rowcolumns=[2, java], Rowcolumns=[3, ruby], Rowcolumns=[4, go], Rowcolumns=[5, python], Rowcolumns=[6, lua], Rowcolumns=[7, csharp], Rowcolumns=[8, ajax], Rowcolumns=[9, jsp]]";
Pattern pattern1 = Pattern.compile("(?<=ns\\=\\[).*?(?=\\])");
Matcher matcher = pattern1.matcher(string);
   while(matcher.find()){
   System.out.println(matcher.group());
}

正则表达式执行逻辑

• 首先，读取正则表达式第一个匹配符 a 和字符串第一个字符 a 比较，匹配了。于是读取正则表达式第二个字符。
• 读取正则表达式第二个匹配符 b{1,3} 和字符串的第二个字符 b 比较，匹配了。但因为 b{1,3} 表示 1-3 个 b 字符串，以及 NFA 自动机的贪婪特性(也就是说要尽可能多地匹配)。

所以此时并不会再去读取下一个正则表达式的匹配符，而是依旧使用 b{1,3} 和字符串的第三个字符 b 比较，发现还是匹配。于是继续使用 b{1,3} 和字符串的第四个字符 c 比较，发现不匹配了。此时就会发生回溯。

• 发生回溯是怎么操作呢?发生回溯后，我们已经读取的字符串第四个字符 c 将被吐出去，指针回到第三个字符串的位置。

转载于:https://my.oschina.net/u/3727895/blog/2051091