深造java正则表达式

简介

本文介绍的是在Java中的使用。

百度百科中对正则表达式进行了解释:

正则表达式,又称为规则表达式。(Regular Expression),计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。

正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。

正则表达式是对字符串(包括普通字符(例如,a 到 z 之间的字母)和特殊字符(称为“元字符”))操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。正则表达式是一种文本模式,该模式描述在搜索文本时要匹配的一个或多个字符串。

案例

. + * ?

正则表达式符号意义.
.任何字符
+一个或者多个字符
*零个或者多个
零个或一个
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package regex;

/**
* @Descriptions: 正则表达式 . * + ?
* @Author: wsylp
* @Date: created in 下午3:43 19-9-16
*/
public class Demo1 {

public static void main(String[] args) {

String englishName = "john";

System.out.println("-------------正则表达式[.]任何字符-------------------");
//其中正则表达式".",每一个点代表一个字符.
System.out.println(englishName.matches("...."));
System.out.println(englishName.matches("..."));


String chineseName = "张三";

System.out.println(chineseName.matches(".."));
System.out.println(chineseName.matches("..."));


System.out.println("-------------正则表达式[+]一个或者多个字符-------------------");
System.out.println(englishName.matches("j+"));

englishName="jjjj";
System.out.println(englishName.matches("[a-z]+"));
System.out.println(englishName.matches("j+"));

System.out.println("-------------正则表达式[*]零个或者多个-------------------");

englishName="john";
System.out.println(englishName.matches("joh*"));
System.out.println(englishName.matches("(joh)*"));
englishName="zoo";
System.out.println(englishName.matches("j*"));
System.out.println(englishName.matches("z*"));
System.out.println(englishName.matches("[a-z]*"));

System.out.println("-------------正则表达式[?]零个或者一个-------------------");
System.out.println("j".matches("j?"));
System.out.println("john".matches("(jo)*"));
System.out.println("john".matches("(john)*"));
System.out.println("johnjohnjohn".matches("(john)*"));

//结果为
//-------------正则表达式[.]任何字符-------------------
//true
//false
//true
//false
//-------------正则表达式[+]一个或者多个字符-------------------
//false
//true
//true
//-------------正则表达式[*]零个或者多个-------------------
//false
//false
//false
//false
//true
//-------------正则表达式[?]零个或者一个-------------------
//true
//false
//true
//true
}
}

[] 、{}

正则表达式符号意义
[]范围
{}出现的次数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
package regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 下午3:59 19-9-16
*/
public class Demo2 {
public static void main(String[] args) {
String englishName = "john";

Pattern pattern = Pattern.compile("[a-z]{4}");

Matcher matcher = pattern.matcher(englishName);

System.out.println(matcher.matches());



englishName = "j";

System.out.println(Pattern.compile("[a-z]").matcher(englishName).matches());


englishName = "jo";
System.out.println(Pattern.compile("[a-z]").matcher(englishName).matches());


//简单写法
System.out.println("\"jo\".matches(\"[a-z]\")->"+"jo".matches("[a-z]"));

//[]中括号里面代表的是范围
System.out.println("\"jo\".matches(\"[joh]{2}\")->"+"jo".matches("[joh]{2}"));

//&&代表并的意思
System.out.println("\"jo\".matches(\"[a-z&&[joh]]{2}\")->"+"jo".matches("[a-z&&[joh]]{2}"));

//||代表或的意思
System.out.println("\"jo\".matches(\"[jm||[ao]]{2}\")->"+"jo".matches("[jm||[ao]]{2}"));


//{n}代表为出现的次数
System.out.println("\"jo\".matches(\"[a-z]{2}\")->"+"jo".matches("[a-z]{2}"));


System.out.println("\"johnmm\".matches(\"johnm{2}\")->"+"johnmm".matches("johnm{2}"));

System.out.println("\"johnmmm\".matches(\"johnm{2}\")->"+"johnmmm".matches("johnm{2}"));

//{n,}代表出现的次数至少为n次
System.out.println("\"johnmmm\".matches(\"johnm{2,}\")->"+"johnmmm".matches("johnm{2,}"));

//{n,m}代表为出现的次数为n~m
System.out.println("\"johnmmm\".matches(\"johnm{2,4}\")->"+"johnmmm".matches("johnm{2,4}"));
System.out.println("\"johnmmm\".matches(\"johnm{2,3}\")->"+"johnmmm".matches("johnm{2,3}"));
//结果为
//true
//true
//false
//"jo".matches("[a-z]")->false
//"jo".matches("[joh]{2}")->true
//"jo".matches("[a-z&&[joh]]{2}")->true
//"jo".matches("[jm||[ao]]{2}")->true
//"jo".matches("[a-z]{2}")->true
//"johnmm".matches("johnm{2}")->true
//"johnmmm".matches("johnm{2}")->false
//"johnmmm".matches("johnm{2,}")->true
//"johnmmm".matches("johnm{2,4}")->true
//"johnmmm".matches("johnm{2,3}")->true

}
}

\、\d、\D、\s、\S、\w、\W

字符含义
\转义字符,如果在正则表达式中表示\,需要四个\,也就是\\\\
\d数字,等价于[0-9]
\D非数字,等价于[^0-9]
\s空格等价于\t\n\f\r
\S非空格等价于^\s
\w数字字母与下划线等价于a-zA-Z_0-9
\W非数字字母和下划线等价于^\w
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package regex;

/**
* @Descriptions: 正则表达式 \ \d \s \w
* @Author: wsylp
* @Date: created in 下午2:09 19-9-22
*/
public class Demo3 {
public static void main(String[] args) {


// '\'代表转义字符,如果在正则表达式中表示\,需要四个\,也就是\\\\
System.out.println("\"\\\"Good morning.\\\"\".matches(\"\\\"Good morning.\\\"\")->" + "\"Good morning.\"".matches("\"Good morning.\""));
System.out.println("\"a\\\\b\".matches(\"a\\\\\\\\b\")->" + "a\\b".matches("a\\\\b"));


//\d代表数字,等价于[0-9]
System.out.println("\"7\".matches(\"\\\\d\")->" + "7".matches("\\d"));
System.out.println("\"7\".matches(\"[0-9]\")->" + "7".matches("[0-9]"));

//\D非数字,等价于"[^0-9]"
System.out.println("\"m\".matches(\"\\\\D\")->" + "m".matches("\\D"));
System.out.println("\"m\".matches(\"[^0-9]\")->" + "m".matches("[^0-9]"));

//\s代表空格等价于[\t\n\f\r]
System.out.println("\" \".matches(\"\\s\")->" + " ".matches("\\s"));

System.out.println("\"\\t\\n\\f\\r\".matches(\"\\\\s{4}\")->" + "\t\n\f\r".matches("\\s{4}"));

//\S代表非空格等价于[^\s]
System.out.println("\"m\".matches(\"\\\\S\")->" + "m".matches("\\S"));

//\w代表数字字母与下划线等价于[a-zA-Z_0-9]
System.out.println("\"a2_M\".matches(\"\\\\w{4}\")->" + "a2_M".matches("\\w{4}"));

//\W非数字字母和下划线等价于[^\w]
System.out.println("\"#\".matches(\"\\\\W\")->" + "#".matches("\\W"));


//结果如下

//"\"Good morning.\"".matches("\"Good morning.\"")->true
//"a\\b".matches("a\\\\b")->true
//"7".matches("\\d")->true
//"7".matches("[0-9]")->true
//"m".matches("\\D")->true
//"m".matches("[^0-9]")->true
//" ".matches("\s")->true
//"\t\n\f\r".matches("\\s{4}")->true
//"m".matches("\\S")->true
//"a2_M".matches("\\w{4}")->true
//"#".matches("\\W")->true
}
}

^ 、$ 、\b

字符含义
^在[]里面代表非的意思,否则代表字符串的开头
$代表字符串的结尾
\b匹配一个单词边界,也就是指单词和空格间的位置。例如, ‘er\b’ 可以匹配”never” 中的 ‘er’,但不能匹配 “verb” 中的 ‘er’。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package regex;

/**
* @Descriptions:^ $ \b
* @Author: wsylp
* @Date: created in 下午10:49 19-9-23
*/
public class Demo4 {
public static void main(String[] args) {
//^在[]里面代表非的意思,否则代表字符串的开头
System.out.println("\"a\".matches(\"[^bc]\")->" + "a".matches("[^bc]"));
System.out.println("\"adddd\".matches(\"^a[a-d]{4}\")->" + "adddd".matches("^a[a-d]{4}"));

//$代表结尾
System.out.println("\"hello\".matches(\"[a-z]{4}o$\")->"+"hello".matches("[a-z]{4}o$"));

//\b一个单词的边界, 可以是空格, 换行符等
System.out.println("\"hello sir\".matches(\"^h[a-z]{1,3}o\\\\b.*\")->"+"hello sir".matches("^h[a-z]{1,3}o\\b.*"));
System.out.println("\"hellosir\".matches(\"^h[a-z]{1,3}o\\\\b.*\")"+"hellosir".matches("^h[a-z]{1,3}o\\b.*"));
System.out.println("\"never\".matches(\"[a-z]{3}er\\\\b\")->"+"never".matches("[a-z]{3}er\\b"));
System.out.println("\"very\".matches(\"[a-z]{1}er\\\\b.\")->"+"very".matches("[a-z]{1}er\\b."));

//"a".matches("[^bc]")->true
//"adddd".matches("^a[a-d]{4}")->true
//"hello".matches("[a-z]{4}o$")->true
//"hello sir".matches("^h[a-z]{1,3}o\\b.*")->true
//"hellosir".matches("^h[a-z]{1,3}o\\b.*")false
//"never".matches("[a-z]{3}er\\b")->true
//"very".matches("[a-z]{1}er\\b.")->false
}
}

exercises

要求:email邮箱验证,以数字或者字母开头,以.com结尾

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package regex;

/**
* @Descriptions:
* @Author: wsylp
* @Date: created in 下午11:02 19-9-23
*/
public class Demo5 {
public static void main(String[] args) {

//120@qq.com
//_12011@.com
//aaa@163.com
//[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+

System.out.println("120@qq.com".matches("^[\\d||[a-zA-Z]]\\w{0,9}@[\\w&&[^_]]{1,}(.com)$"));
System.out.println("_12011@.com".matches("^[\\d||[a-zA-Z]]\\w{0,9}@[\\w&&[^_]]{1,}(.com)$"));
System.out.println("aaa@163.com".matches("^[\\d||[a-zA-Z]]\\w{0,9}@[\\w&&[^_]]{1,}(.com)$"));

//true
//false
//true
}
}

本文标题:深造java正则表达式

文章作者:wsylp

发布时间:2019年09月16日 - 15:09

最后更新:2019年09月23日 - 23:09

原始链接:http://wsylp.top/2019/09/16/深造java正则表达式/

许可协议: 本文为 wsylp 版权所有 转载请保留原文链接及作者。

-------------本文结束感谢阅读-------------