Java SE 正则表达式

admin管理员组

文章数量:1579084

Java SE 正则表达式

目录

• Java SE 正则表达式
• • 1、定义
  • • 1.1、 工具 RegexBuddy
  • 2、字符集
  • • 2.1、 普通字符
    • 2.2、 元字符与转义
  • 3、字符类
  • • 3.1、 自定义
    • 3.2、默认|标准字符类
    • 3.3、量词
    • 3.4、贪婪模式
  • 4、边界
  • 5、选择符与分组
  • • 5.1、选择符 |
    • 5.2、分组 ( )
    • 5.3、模式修改符
  • 6、零宽断言
  • 7、常用类
  • • 7.1、 Pattern
    • 7.2、Matcher
    • 7.3、字符串与正则

1、定义

正则表达式(了解):

​ 正则表达式是用来描述具有一定特征的字符串的特殊字符串。Regular Expression。

作用: 可以用来对字符串进行验证、查找、替换、分割 。

1.1、 工具 RegexBuddy

2、字符集

默认情况下区分大小写。

2.1、 普通字符

 写什么，匹配什么 非特殊含义以外的字符，如 a b 中国 上海 。

普通字符精确匹配

2.2、 元字符与转义

元字符： " ( ) [ ] { } \ ^ . $ * + ? | " 14个特殊字符

转义字符：\ + 字母

1. \d -> [0-9] 0~9之间一个数字

2. **\ \ --> \ **

3. \s --> 空格|制表符|换行符

4. **\ w --> word [A-Za-z0-9] ** AZ和a和0~9之间任何一个

3、字符类

3.1、 自定义

由 [ ] 组，只匹配一个， 需要注意以下四个:

• ^ : 如果在第一个位置，表示取反的含义。
• -：表示一个区间即范围
• ] : 最近一个位置为:*结束 ，如果要表示普通的]请加 *
• **\ ** : 转义
• . ：在字符类中代表任意的字符。 如果需要表示原有的含义，挪动位置 或者加 \ 。

  多行模式（缺省）：除了换行符\r\n以外的任意一个字符， [ ^\n\r ] ；单行模式：可以匹配包含换行符在内的任意一个字符

3.2、默认|标准字符类

字符	含义
\d	digit[0-9] , [0123456789]
\w	word [A-Za-z0-9]
\s	space 空格，制表符，换行符
.	多行模式（缺省）：除了换行符\r\n以外的任意一个字符， [ ^\n\r ] ； 单行模式：可以匹配包含换行符在内的任意一个字符
\D	[ ^\d ] [ ^0123456789 ] [ ^0-9 ]
\W	[ ^\w ] 非字母， 数字， _, 即空白，标点符号及中文
\S	[ ^\s ]

3.3、量词

匹配的过程中，需要指定次数。

• ***** ：0个及以上
• + ：1个及以上
• ？ ：0个或1个
• { n } : n次，非负数
• { n, } :大于或等于n次
• { n,m } :大于或等于n次，小于或等于m次

co*ke –> 不限个数的O  									：coke cooke coooke
co+ke –>至少一个 O co?ke ->1 个或零个 O  ：coke cke
co{0}ke ->0 个 co{5,}ke –>5 次及以上 	 ：cke
co{5,8}ke –> 至少 5 次，最多 8 次 			 ：cooke coooke  coooke coooooke
[1-9]\d{3} –>大于等于 1000 小于等于 9999 的数  :1000 1002 9999
[1-9]\d{2,4} –>大于等于 100 小于等于 99999 的数  : 100  23433 9999

3.4、贪婪模式

在匹配次数不定时如 *, {n,}, + 匹配字符越多越好，默认模式即”贪婪模 ”

贪婪模式 greedy(匹配字符越多越好，可回溯)

? 懒惰模式 lazy reluctant (匹配字符越少越好，可回溯)

+ 独占模式 possessive(匹配字符越多越好,不可回溯)用的较少 cokecolacoooooooooooooke

.*o –>贪婪模式 
.{2,}o–>贪婪模式 
.{2,}?o –>懒惰模式 
.{2,}+o –>独占模式，不可回溯 没有匹配到内容。 
<.+?> ->找出标签 不要标签内的内容。不是<.+> 
<[^>]+>->找出标签 不要标签内的内容。不是<.+>

阻止贪婪有两种方式：

1、 量词后面使用 ?

2、 使用取反

4、边界

1)、边界不占用宽度，只是一个界限

2)、

• ^ ：开始

• \b ：单词边界

• \B ：非单词边界

• $ ：结束

• ^ ：多行代表每行头 单行代表整个字符串的开始

• $ : 多行代表每行尾 单行代表字符串的结尾

• \b : 匹配前面或后面的不是\w

• \B : 匹配前面或后面的是\w

^\bwrold\b$ :"    wrold    "
^\Bwrold\B$ :"00ddwrold00dd"

5、选择符与分组

5.1、选择符 |

| ->优先级低 ,满足匹配则停止，不会查找更优的方案

he|hello –>只匹配 he,不匹配 hello

hello|he->匹配 he 与 hello

5.2、分组 ( )

ab|c 					->  匹配 ab c 
a(b|c) 				 -> 匹配 ab ac
\bget\b 			 -> 只匹配 get  “  哈哈get  无语”
getvalue|get 		-> 匹配 get 和 getValue
get(value)? 		-> get getvalue
\band\b|\bor\b \b(and|or)\b -> 获取 and or

反向引用： \ 内部默认缓存,从第一个左括号计算，编号为 1 开始。

非捕获组: (?:xxx) ： 不缓存组

(["'])(?:[^"']+)\1 ->不缓存第二组，不能引用第二组 
(?:["'])(?:[^"']+)\1 –>所有的组都没有缓存，不能再引 用了。

5.3、模式修改符

( ?ism )*****( ?-ism )

• i ： insensitive 使正则表达式对大小写不敏感；(重点)
• s ： singleline 开启“单行模式”，即点号“.”匹配新行符；
• m ： multiline 开启“多行模式”，即**“^”和“$”匹配新行符的前面和后面的位置**
• (?i)select(?-i) -> 不区分大小写。

(?i)she(?i)  --》she SHE
(?s)she(?-s) --》she
s(?m)she(?-m)k --> she

6、零宽断言

前瞻（Lookahead） 后顾（Lookbehind）

（？=试试） 先行断言	先行断言 :断言自身出现的位置的后面能匹配表达式exp
（？<=shishi ）后发断言	后发断言: 断言自身出现的位置的前面能匹配表达式exp
（？！shishi）	断言此位置的后面不能匹配表达式exp
(?<!shishi)	断言此位置的前面不能匹配表达式exp

Java支持?、{m}、{n,m}等符号，但同样不支持*、+字符。Javascript干脆不支持后行断言

(?<=ing)(\w) -->"tings" s   -前面（匹配前面）
(\w)(?<=ing) -->"tings" g   --前面没有（即我们说的后面）

(\w)(?=ing) --> "sing" s    --------后面（匹配后面）
(?=ing)(\w) --》“sing” i  --后面没有（即我们说的前面）

7、常用类

java.util.regex Pattern Matcher String

一般在查找、替换、分割、组的使用

String str = "jflkajl1sjlkfj kl1slkdfjlk1jdldksj";
String str1 = "jflkajl1sjlkfj kl3slkdfjlk5jdldk8sj";
//分隔 1
String[] arr = str.split("1");
System.out.println(Arrays.toString(arr));

arr = str1.split("\\d");
System.out.println(Arrays.toString(arr));

//String
String msg = "abc123qwe456";
String regex = "[a-z]{3}\\d+";
//matches(regex)判断当前字符串是否满足参数正则语法规则 -->完全匹配,子串匹配不可以
System.out.println(msg.matches(regex));

7.1、 Pattern

//Pattern 正则表达式表示类型  模式器
Pattern p = Pattern.compile("(ac*)(b+)");
Matcher m = p.matcher("aaaaacccbbaaab");
boolean b = m.matches(); //完全匹配

7.2、Matcher

//查找是否存在满足条件的字串，每次可以继续找到
//是否匹配
while(m.find()){
    //组
    //group() 获取查找的字串
    //group(int index) 获取当前匹配到的字串中指定索引分组的缓存内容

    System.out.println(m.groupCount()+"-->"+m.group()+"-->"+m.group(0));
    //0-->整个表达式
    //分组索引从 1 开始获取
    System.out.println(m.group(1)+"-->"+m.group(2));
}

				/String
        String msg = "abc123qwe456";
        String regex = "[a-z]{3}\\d+";
        //matches(regex)判断当前字符串是否满足参数正则语法规则 -->完全匹配,子串匹配不可以
        System.out.println(msg.matches(regex));

7.3、字符串与正则

String str ="and"; 
//完全匹配 
boolean flag =str.matches("\\b(and|or)\\b"); 
System.out.println(flag); 
str="\"happy\" and \"regex\" \"baidu\" or \"google\""; 
//替换所有
str =str.replaceAll("\\b(and|or)\\b", "-->"); 
System.out.println(str); 
//分割 
str="\"happy\" and \"regex\" \"baidu\" or \"google\""; 
//切割 
String[] arr=str.split("\\b(and|or)\\b");
for(String temp:arr){ 
  System.out.println(temp); 
}
arr=str.split("m"); 
//没有对应的，返回本身
for(String temp:arr){ 
  System.out.println(temp); 
}
//. -->任意字符 
str ="192.168.1.234";arr=str.split("\\."); 
//注意转义
for(String temp:arr){ System.out.println(temp); }

本文标签： 正则表达式JavaSE