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

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

【正则表达式】

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

 （例如字符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

任何匹配的n^th捕获组

 

 

引用

\

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，作为独立的非捕获组

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

1. 匹配：

   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 + "是合法的！");elseSystem.out.println(qq + "是不合法的！");

1. 切割：

   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);}}

1. 替换：

   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);}

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

   思路：

   1. 将正则表达式封装成对象

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

   3. 获取正则匹配引擎

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

      【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培训、期待与您交流！ ----------------------