正则表达式

发布时间：2020-12-13 22:01:53 所属栏目：百科来源：网络整理

导读：正则表达式目录： 1、正则表达式简介： 2、split方法： 3、replace方法： 4、Pattern类： 5、常用正则表达式： 6、测试代码及运行结果：参考文献：《Java编程思想Thinking in Java第四版》 Bruce Eckel著机械工业出版社 1、正则表达式简介：答：（1）正

正则表达式

目录：

1、正则表达式简介：

2、split方法：

3、replace方法：

4、Pattern类：

5、常用正则表达式：

6、测试代码及运行结果：

参考文献：《Java编程思想Thinking in Java第四版》 Bruce Eckel著机械工业出版社

1、正则表达式简介：

答：（1）正则表达式用来指定字符串模式。当需要定位匹配某种模式的字符串时就可以使用正则表达式。

（2）正则表达式提供了一种完全通用的方式，能够解决各种字符串处理相关的问题：匹配、选择、编辑以及验证。

2、split方法：

答：split方法功能是将字符串从正则表达式匹配的地方切开。在原始字符串中，与正则表达式匹配的部分，在最终结果中都不存在了。

图2.1 split方法1

一个重载的方法，限制字符串分割的次数。

图2.2 split方法2

3、replace方法：

答：replaceFirst：替换正则表达式第一个匹配的子串；replaceAll：替换所有匹配的地方

图3.1 replaceFirst方法

图3.2 replaceAll方法

4、Pattern类：

（1）字符：

B 指定字符B

反斜线字符

n 带有八进制值 0 的字符n (0 <= n <= 7)

nn 带有八进制值 0 的字符nn (0 <= n <= 7)

mnn 带有八进制值 0 的字符mnn（0 <= m <= 3、0 <= n <= 7）

xhh 带有十六进制值 0x 的字符hh

uhhhh 带有十六进制值 0x 的字符hhhh

t 制表符Tab ('u0009')

n 换行('u000A')

r 回车('u000D')

f 换页('u000C')

a 报警(bell) ('u0007')

e 转义（Escape）('u001B')

cx 对应于 x 的控制符

（2）字符类

[abc] 包含a、b或 c的任何字符（与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&&[hij]] h、i或 j（交集）

[a-z&&[^bc]] a 到 z，除了b 和c：[ad-z]（减去）

[a-z&&[^m-p]] a 到 z，而非m 到p：[a-lq-z]（减去）

（3）预定义字符类

. 任意字符（与行结束符可能匹配也可能不匹配）

d 数字：[0-9]

D 非数字：[^0-9]

s 空白字符：（空格，换页，tab，换行，回车）

S 非空白字符：[^s]

w 单词字符：[a-zA-Z_0-9]

W 非单词字符：[^w]

（4）边界匹配器

^ 行的开头

$ 行的结尾

b 单词边界

B 非单词边界

A 输入的开头

G 上一个匹配的结尾

Z 输入的结尾，仅用于最后的结束符（如果有的话）

z 输入的结尾

（5）量词：

量词描述了一个模式吸收输入文本的方式。

A)Greedy 数量词

贪婪型表达式：会为所有可能的模式发现尽可能多的匹配，导致此问题的一个典型理由就是假定我们的模式仅能匹配第一个可能的字符组，如果它是贪婪的，那么它就会继续往下匹配。一般趋向于最大长度匹配。

X? 一个或零个X

X* 零个或多个X

X+ 一个或多个X

X{n} 恰好n次X

X{n,} 至少n次X

X{n,m} 至少n次X，且不超过m次

B)Reluctant 数量词

勉强型表达式：用问号来指定，这个量词匹配满足模式所需的最少字符数。因此也称作懒惰的、最少匹配的、非贪婪的、不贪婪的。匹配到结果就好，最少的匹配字符。

X?? 一个或零个X

X*? 零个或多个X

X+? 一个或多个X

X{n}? 恰好n次X

X{n,}? 至少n次X

X{n,m}? 至少n次X，且不超过m次

C)Possessive 数量词

占有型表达式：目前只能在Java语言中才可以使用，当正则表达式被应用于字符串时，它会产生相当多的状态，以便在匹配失败时可以回溯，而“占有的”量词并不保存这些中间状态，因此它们可以防止回溯。

X?+ 一个或零个X

X*+ 零个或多个X

X++ 一个或多个X

X{n}+ 恰好n次X

X{n,}+ 至少n次X

X{n,m}+ 至少n次X，且不超过m次

（6）Logical运算符

XY Y跟在X后面

X|Y X 或 Y

(X) X，作为捕获组（capturing group）

5、常用正则表达式：

答：验证手机号码：^1[3|4|5|7|8][0-9]{9}$

验证IP地址：^(1d{2}|2[0-4]d|25[0-5]|[1-9]d|[1-9]).(1d{2}|2[0-4]d|25[0-5]|[1-9]d|d).(1d{2}|2[0-4]d|25[0-5]|[1-9]d|d).(1d{2}|2[0-4]d|25[0-5]|[1-9]d|d)$

验证是否为网页地址：^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$

验证邮箱：^w+([+-.]w+)*@w+([-.]w+)*.w+([-.]w+)*$

验证身份证号（15位或18位数字）：^(d{15})|(d{18})$

整数或者至多两位的小数：^[0-9]+.{0,1}[0-9]{0,2}$

只能输入数字：^[0-9]+$

只能输入n位的数字：^[0-9]{n}$

只能输入至少n位的数字：^[0-9]{n,}$

只能输入m~n位的数字：^[0-9]{m,n}$

只能输入零和非零开头的数字：^(0|{^0}[0-9]+)$

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

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

只能输入非零的正整数：^[1-9]d*$

只能输入非零的负整数：^-[1-9]d*$

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

只能输入由26个英文字母组成的字符串：^[a-zA-Z]+$

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

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

只能输入由数字和26个英文字母组成的字符串：^[a-zA-Z0-9]+$

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

验证用户密码（以字母开头，长度在6~18之间，只能包含字符、数字和下划线）：^[a-zA-Z]w{5,17}$

验证是否含有^%&',;=?$"等字符：[^%&’,;=?$x22]

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

验证电话号码（"XXXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX"）：^([0-9]{3,4}-)?[0,9]{7,8}$

验证一年的12个月（"01"～"09"和"1"～"12"）：^0?[1-9]|1[0-2]$

验证一个月的31天（"01"～"09"和"1"～"31"）：^(0?[1-9])|([12][0-9])|(3[01])$

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

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

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

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

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

6、测试代码及运行结果：

package com.remoa.regularExpression;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test1 {
	public static void main(String[] args) {
		//-----------------测试1:简单运用---------------
		System.out.println("-1234".matches("-?d+"));//表示可能有一个负号，后面跟着一位或多位数字
		System.out.println("567".matches("-?d+"));//表示可能有一个负号，后面跟着一位或多位数字
		System.out.println("+999".matches("-?d+"));//表示可能有一个负号，后面跟着一位或多位数字
		System.out.println("+999".matches("(-|+)?d+"));//表示可能有一个负号或正号，后面跟着一位或多位数字
		/**
		 * 运行结果：
		 * ture
		 * true
		 * false
		 * true
		 */
		//------------------测试2：split方法------------------
		String str = "Remoa's goal is to become a good programmer and find a good internship...... University of the third grade not fail the exam.";
		System.out.println("匹配空格的拆分结果：n " + Arrays.toString(str.split(" ")));//从空格处划分
		System.out.println("匹配非单词字符的拆分结果：n " + Arrays.toString(str.split("W+")));//从跟着一位或多位非单词字符处划分
		System.out.println("匹配d加上非单词字符的划分结果： n" + Arrays.toString(str.split("dW+")));//从字母d跟着一位或多位费单词字符处划分
		System.out.println("匹配d加上非单词字符且限定模式应用次数的划分结果：n" + Arrays.toString(str.split("dW+",3)));//影响数组长度最大为3，该模式最多被应用3 - 1次
		/**
		 * 运行结果：
		 * [Remoa's,goal,is,to,become,a,good,programmer,and,find,internship……,University,of,the,third,grade,not,fail,exam.]
		 * [Remoa,s,internship,exam]
		 * [Remoa's goal is to become a goo,programmer an,fin,a goo,internship…… University of the thir,grade not fail the exam.]
		 * [Remoa's goal is to become a goo,find a good internship...... University of the third grade not fail the exam.]
		 */
		//---------------------测试replace------------------------
		System.out.println(str.replaceFirst("eW+","banana"));
		System.out.println(str.replaceAll("ds+","apple"));
		/**
		 * 运行结果：
		 * Remoa's goal is to becombananaa good programmer and find a good internship…… University of the third grade not fail the exam.
		 * Remoa's goal is to become a gooappleprogrammer anapplefinapplea gooappleinternship…… University of the thirapplegrade not fail the exam.
		 */
		//--------------------测试简单正则表达式-------------------------
		System.out.println("下面正则表达式都能匹配Remoa");
		for(String pattern : new String[]{"[rR]emoa","[rR][aeiou][a-z]o.*","R.*","[rR].*"}){
			System.out.println("Remoa".matches(pattern));
		}
		/**
		 * 运行结果：
		 * true
		 * true
		 * true
		 * true
		 */
		//---对字符串Java now has regular expressions验证下面正则表达式能否发现一个匹配
		String test = "Java now has regular expressions";
		int i = 1;
		List<Pattern> list = new ArrayList<Pattern>();
		Pattern p1 = Pattern.compile("^Java");
		Pattern p2 = Pattern.compile("Breg.*");
		Pattern p3 = Pattern.compile("n.ws+h(a|i)s");
		Pattern p4 = Pattern.compile("s?");
		Pattern p5 = Pattern.compile("s*");
		Pattern p6 = Pattern.compile("s+");
		Pattern p7 = Pattern.compile("s{4}");
		Pattern p8 = Pattern.compile("s{1}");
		Pattern p9 = Pattern.compile("s{1,3}");
		list.add(p1);
		list.add(p2);
		list.add(p3);
		list.add(p4);
		list.add(p5);
		list.add(p6);
		list.add(p7);
		list.add(p8);
		list.add(p9);
		for(Iterator<Pattern> iter = list.iterator(); iter.hasNext();){
			int j = 1;
			Matcher m = iter.next().matcher(test);
			System.out.println("--------------" + (i++) + "-------------------");
			while(m.find()){
				System.out.println("匹配" + (j++) + ": " + m.group(0));
			}
		}
		/**
		 * "^Java":行的开头是Java，匹配Java
		 * "Breg.*"：非单词边界加上reg加上任意字符，匹配失败，若为breg.*,则匹配regular expressions
		 * "n.ws+h(a|i)s"：n开头加上任意字符后接着一个w加上一个或多个空白字符加上h加上a或i加上s，匹配now has
		 * "s?"：贪婪型，一个或零个s，匹配has的s，匹配expressions的三个s,输出：匹配12: s，匹配27: s，匹配28: s，匹配32: s，其他匹配0个s
		 * "s*"：贪婪型，零个或多个s，输出：匹配12: s，匹配27: ss，匹配28: s，匹配31: s，其他匹配0个s
		 * "s+"：贪婪型，1个或多个s，输出：匹配1: s，匹配2: ss，匹配3: s
		 * "s{4}"：贪婪型，恰好四次s，匹配失败
		 * "s{1}"：贪婪型，恰好一次s，输出：匹配1: s，匹配2: s，匹配3: s，匹配4: s
		 * "s{0,3}?"：贪婪型，至少1次s，不超过3次，输出：匹配1: s，匹配2: ss，匹配3: s
		 * 故总体运行结果：匹配成功：模式p1,p3,p4,p5,p6,p8,p9，匹配失败：模式p2,p7
		 */
		//----------------应用正则表达式在一个文件中进行搜索匹配操作------------------
		
		//------------------分组捕获----------------
		Pattern p = Pattern.compile("(a[a-z]b)");
		Matcher m = p.matcher("adbaambcdaebd");
		while(m.find()){
			for (int i2 = 0; i2 < m.groupCount(); i2++) {
				System.out.println( m.group(i2));
			}
		}
		/**
		 * 运行结果：
		 * adb
		 * amb
		 * aeb
		 */
	}
}

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!