黑马程序员 知识点总结-Java正则表达式

[align=center]----------------------Android培训、Java培训、期待与您交流！ ----------------------[/align]

【正则表达式】

      正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是由普通的字符

 （例如字符a到z）以及特殊字符（元字符）组成的文字模式，它用以描述在查找文字主

 体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的

 字符串进行匹配。

      特点：用一些特定的符号来表示一些代码，简化书写

      好处：可以简化对字符串的复杂操作

【正则表达式的构造摘要】

构造	匹配
字符
x	字符x
\\	反斜线字符
\0n	带有八进制值 0的字符n (0 <= n <= 7)
\0nn	带有八进制值 0的字符nn (0 <= n <= 7)
\0mnn	带有八进制值 0的字符mnn（0 <= m <= 3、0 <= n <= 7）
\xhh	带有十六进制值 0x的字符hh
\uhhhh	带有十六进制值 0x的字符hhhh
\t	制表符 ('\u0009')
\n	新行（换行）符 ('\u000A')
\r	回车符 ('\u000D')
\f	换页符 ('\u000C')
\a	报警 (bell)符 ('\u0007')
\e	转义符 ('\u001B')
\cx	对应于x的控制符
字符类
[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]（减去）
预定义字符类
.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]
POSIX字符类（仅 US-ASCII）
\p{Lower}	小写字母字符：[a-z]
\p{Upper}	大写字母字符：[A-Z]
\p{ASCII}	所有 ASCII：[\x00-\x7F]
\p{Alpha}	字母字符：[\p{Lower}\p{Upper}]
\p{Digit}	十进制数字：[0-9]
\p{Alnum}	字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct}	标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}	可见字符：[\p{Alnum}\p{Punct}]
\p{Print}	可打印字符：[\p{Graph}\x20]
\p{Blank}	空格或制表符：[ \t]
\p{Cntrl}	控制字符：[\x00-\x1F\x7F]
\p{XDigit}	十六进制数字：[0-9a-fA-F]
\p{Space}	空白字符：[ \t\n\x0B\f\r]
java.lang.Character类（简单的java字符类型）
\p{javaLowerCase}	等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase}	等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace}	等效于 java.lang.Character.isWhitespace()
\p{javaMirrored}	等效于 java.lang.Character.isMirrored()
Unicode块和类别的类
\p{InGreek}	Greek 块（简单块）中的字符
\p{Lu}	大写字母（简单类别）
\p{Sc}	货币符号
\P{InGreek}	所有字符，Greek块中的除外（否定）
[\p{L}&&[^\p{Lu}]]	所有字母，大写字母除外（减去）
边界匹配器
^	行的开头
$	行的结尾
\b	单词边界
\B	非单词边界
\A	输入的开头
\G	上一个匹配的结尾
\Z	输入的结尾，仅用于最后的结束符（如果有的话）
\z	输入的结尾
Greedy数量词
X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好n次
X{n,}	X，至少n次
X{n,m}	X，至少n次，但是不超过m次
Reluctant数量词
X??	X，一次或一次也没有
X*?	X，零次或多次
X+?	X，一次或多次
X{n}?	X，恰好n次
X{n,}?	X，至少n次
X{n,m}?	X，至少n次，但是不超过m次
Possessive数量词
X?+	X，一次或一次也没有
X*+	X，零次或多次
X++	X，一次或多次
X{n}+	X，恰好n次
X{n,}+	X，至少n次
X{n,m}+	X，至少n次，但是不超过m次
Logical运算符
XY	X后跟Y
X|Y	X或Y
(X)	X，作为捕获组
Back引用
\n	任何匹配的nth捕获组
引用
\	Nothing，但是引用以下字符
\Q	Nothing，但是引用所有字符，直到 \E
\E	Nothing，但是结束从 \Q开始的引用
特殊构造（非捕获）
(?:X)	X，作为非捕获组
(?idmsux-idmsux)	Nothing，但是将匹配标志idmsuxon - off
(?idmsux-idmsux:X)	X，作为带有给定标志idmsux on - off的非捕获组
(?=X)	X，通过零宽度的正 lookahead
(?!X)	X，通过零宽度的负 lookahead
(?<=X)	X，通过零宽度的正 lookbehind
(?<!X)	X，通过零宽度的负 lookbehind
(?>X)	X，作为独立的非捕获组

【正则表达式的具体功能】

匹配：

public boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。

regex - 用来匹配此字符串的正则表达式

如：

// 验证QQ号 reg为规则
String reg = "[1-9]\\d{4,9}";
String qq = "012345a";
boolean flag = qq.matches(reg);
if (flag)
System.out.println(qq + "是合法的！");
else
System.out.println(qq + "是不合法的！");

切割：

public
String[]split(String regex)：根据给定正则表达式的匹配拆分此字符串。

如：

public static void main(String[] args) {

// 按照多个空格进行切割
splitStr("zhangsan lisi wangwu", " +");
// 按照'.'进行切割，由于'.'表示任意字符，所以要用转义字符表示
splitStr("zhangsan.lisi.wangwu", "\\.");
// 按照叠词进行切割，为了可以让规则被重用，可以讲规则封装成一个组，用
// ()完成租的出现都有编号，从1开始；想要使用已有的组可以通过\n(n为组
// 的编号)的形式获取
splitStr("asferqqqqpoiknbmmrgggcvfd", "(.)\\1+");
}

// 定义方法，将字符串切割为数组，并打印
public static void splitStr(String str, String regex) {
String[] arr = str.split(regex);
System.out.println(arr.length);
for (String s : arr) {
System.out.println(s);
}
}

替换：

public String replaceAll(Stringregex,String replacement)：使用给定的 replacement替换此字符串所有匹配给定的正则表达式的子字符串。

如：

public static void main(String[] args) {

// 将字符串中的数字替换为#
repsStr("sfjfi39347nbjgfbh8y7423gvefy7", "\\d{1,}", "#");
// 将字符串中的叠词替换为叠词中的单个字符，$可以获取正则表达式中的
// 组,$1表示正则表达式中的第一组
repsStr("erqqqqpoiknbmmr", "(.)\\1+", "$1");// erqpoiknbmr
}

public static void repsStr(String str, String reg, String newStr) {
String s = str.replaceAll(reg, newStr);
System.out.println(s);
}

获取：将字符串中符合规则的子串取出

思路：

将正则表达式封装成对象

将正则对象与要操作的字符串相关联

获取正则匹配引擎

通过引擎对符合规则的子串进行操作

【Pattern】

public finalclass Pattern extends Objectimplements Serializable

正则表达式的编译表示形式。指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建Matcher对象，依照正则表达式，该对象可以与任意字符序列匹配。该类未向外部提供可用的构造方法，可以利用静态方法compile方法获取本类对象。

public static
Pattern compile(String regex)：将给定的正则表达式编译到模式中。

public
Matcher matcher(CharSequence input)：创建匹配给定输入与此模式的匹配器。input
- 要匹配的字符序列

【Macher】

public finalclass Matcher extends Objectimplements MatchResult

通过解释Pattern对character
sequence执行匹配操作的引擎。

public
Stringgroup()：返回由以前匹配操作所匹配的输入子序列。对于具有输入序列s的匹配器m，表达式
m.group()和 s.substring(m.start(), m.end())是等效的。

public boolean matches()：尝试将整个区域与模式匹配。该方法与String类的matches方法作用相同，实际上String类的matches方法封装的是该方法

public
StringreplaceAll(String replacement)：替换模式与给定替换字符串相匹配的输入序列的每个子序列。该方法与String类的replaceAll方法作用相同，实际上String类的replaceAll方法封装的是该方法

public boolean find()：尝试查找与该模式匹配的输入序列的下一个子序列。

public int end()：返回最后匹配字符之后的偏移量。

public int start()：返回以前匹配的初始索引。

如：

String str = "da jia hao hei me cheng xu yuan";
String reg = "\\b[a-z]{3}\\b";
// 将正则表达式封装成对象
Pattern p = Pattern.compile(reg);
// 获取匹配引擎
Matcher m = p.matcher(str);
while (m.find()) {
System.out.println(m.group());
}

      遇到的问题：代码如下
String str = "da jia hao hei me cheng xu yuan";
// 定义正则表达式为连续俩个字母字符
String reg = "\\b[a-z]{2}\\b";
// 将正则表达式封装成对象
Pattern p = Pattern.compile(reg);
// 获取匹配引擎
Matcher m = p.matcher(str);
// 验证字符串是否符合正则表达式
System.out.println(m.matches());
// 从字符串中偏移量0开始从查找符合正则表达式的子串，若有符合的就返回
// true，若为查找到则偏移量后移
while (m.find()) {
// 获取符合正则表达式的子串
System.out.println(m.group());
}

      正确结果应为：da me xu但实际结果为：me
xu

      原因：因为matches方法是将整个字符穿与正则表达式进行比较，比较时位偏

              移量也会后移，当验证完毕，执行循环判断find方法时位偏移量不是从

             0开始的，而是使用matches对位偏移量操作后的值，所以未读到da

【常用的正则表达式】

      1、整数或者小数：^[0-9]+\.{0,1}[0-9]{0,2}$

2、只能输入数字："^[0-9]*$"。

3、只能输入n位的数字："^\d{n}$"。

4、只能输入至少n位的数字："^\d{n,}$"。

5、只能输入m~n位的数字：。"^\d{m,n}$"

6、只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。

7、只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。

8、只能输入有1~3位小数的正实数："^[0-9]+(.[0-9]{1,3})?$"。

9、只能输入非零的正整数："^\+?[1-9][0-9]*$"。

10、只能输入非零的负整数："^\-[1-9][]0-9"*$。

11、只能输入长度为3的字符："^.{3}$"。

12、只能输入由26个英文字母组成的字符串："^[A-Za-z]+$"。

13、只能输入由26个大写英文字母组成的字符串："^[A-Z]+$"。

14、只能输入由26个小写英文字母组成的字符串："^[a-z]+$"。

15、只能输入由数字和26个英文字母组成的字符串："^[A-Za-z0-9]+$"。

16、只能输入由数字、26个英文字母或者下划线组成的字符串："^\w+$"。

17、验证用户密码："^[a-zA-Z]\w{5,17}$"正确格式为：以字母开头，长度在6~18之间，

      只能包含字符、数字和下划线。

18、验证是否含有^%&',;=?$\"等字符："[^%&',;=?$\x22]+"。

19、只能输入汉字："^[\u4e00-\u9fa5]{0,}$"

20、验证Email地址："^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"。

21、验证InternetURL："^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$"。

22、验证电话号码："^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$"正确格式为："XXX-XXXXXXX"、

      "XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"

      和"XXXXXXXX"。

23、验证身份证号（15位或18位数字）："^\d{15}|\d{18}$"。

24、验证一年的12个月："^(0?[1-9]|1[0-2])$"正确格式为："01"～"09"和"1"～"12"。

25、验证一个月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为；"01"～"09"和"1"～

      "31"。 

26、匹配中文字符的正则表达式：
[\u4e00-\u9fa5]

27、匹配双字节字符(包括汉字在内)：[^\x00-\xff]

28、应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

      String.prototype.len=function(){returnthis.replace(/[^\x00-\xff]/g,"aa").length;}

29、匹配空行的正则表达式：\n[\s|
]*\r

30、匹配html标签的正则表达式：<(.*)>(.*)<\/(.*)>|<(.*)\/>

31、匹配首尾空格的正则表达式：(^\s*)|(\s*$)

----------------------Android培训、Java培训、期待与您交流！ ----------------------