Java基础-知识点总结-Java正则表达式

最新推荐文章于 2024-04-25 23:56:41 发布

谁落兮了岁尘

最新推荐文章于 2024-04-25 23:56:41 发布

阅读量624

点赞数

文章标签： Java基础正则表达式

本文链接：https://blog.csdn.net/u013275973/article/details/17718277

版权

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	任何匹配的nth捕获组

引用
\	Nothing，但是引用以下字符
\Q	Nothing，但是引用所有字符，直到 \E
\E	Nothing，但是结束从 \Q开始的引用

特殊构造（非捕获）
(?:X)	X，作为非捕获组
(?idmsux-idmsux)	Nothing，但是将匹配标志i d m s u xon - off
(?idmsux-idmsux:X)	X，作为带有给定标志i d m s u x 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);
	}

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

思路：
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*$)

谁落兮了岁尘

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础-知识点总结-Java正则表达式

Java正则表达式【正则表达式】正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是由普通的字符（例如字符a到z）以及特殊字符（元字符）组成的文字模式，它用以描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。特点：用一些特定的符号来表示一些代码...
复制链接

扫一扫