Java 使用正则表达式

注意

Java 正则表达式基于 Perl 正则表达式实现的。

• 使用正则表达式，必须导入正则表达式包 import java.util.regex.*
• 不支持嵌入条件
• 不支持使用\E、\l、\L、\u和\U进行大小写转换
• 不支持使用\b匹配退格符
• 不支持\z

 
 

Matcher类

通过java.util.regex.Matcher类

索引方法

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

public class HelloWorld {
	private static final String str = "qw qwjy qw qwjy";
	private static final String rule = "\\bqw\\b";
	
    public static void main(String []args) {
    	Pattern p = Pattern.compile(rule);
    	Matcher m = p.matcher(str); // 获取 matcher 对象
		int cnt = 0;
		
		m.find();
		//while(m.find()){
			System.out.println("编号:" + cnt ++);
        	System.out.println("start(): " + m.start());
        	System.out.println("end(): " + m.end());
			System.out.println("start(cnt): " + m.start(cnt - 1));
        	System.out.println("end(cnt): " + m.end(cnt - 1));
		//}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

查找方法

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

public class HelloWorld {
	private static final String str1 = "qw qwjy qw qwjy";
	private static final String str2 = "qwjy qw qwjy qw";
	private static final String rule = "\\bqw\\b";
	private static Pattern pattern;
    private static Matcher matcher1;
    private static Matcher matcher2;
	
    public static void main(String []args) {
    	pattern = Pattern.compile(rule);
      	matcher1 = pattern.matcher(str1);
      	matcher2 = pattern.matcher(str2);
		
		System.out.println("lookingAt(): " + matcher1.lookingAt());
       	System.out.println("matches(): " + matcher1.matches());
       	System.out.println("lookingAt(): " + matcher2.lookingAt());
		
		matcher1.find(5);
        System.out.println("start(): " + matcher1.start());
        System.out.println("end(): " + matcher1.end());
    }
}
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

替换方法

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

public class HelloWorld {
	private static String str = "qw qwjy qw qwjy";
	private static String rule = "\\bqw\\b";
	private static String replace = "qwcc";
	
    public static void main(String []args) {
    	Pattern p = Pattern.compile(rule);
       	Matcher m = p.matcher(str); 
       	str = m.replaceAll(replace);
       	System.out.println(str);
		
		str = m.replaceFirst(replace);
		System.out.println(str);
		
		m = p.matcher(str); 
		StringBuffer s = new StringBuffer();
      	while(m.find()){
         	m.appendReplacement(s,"qwc");
      	}
      	m.appendTail(s);
      	System.out.println(s.toString());
    }
}
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

 
 

 
 

 
 

JavaScript 使用正则表达式

注意

JavaScript 的正则表达式支持源自于 Perl 语言。

• JavaScript 使用标志来管理区分字母大小写的全局搜索：g 标志启用全局搜索功能，i 标志使匹配操作不区分字母大小写，这两个标志可以合并为 gi。
• 其他修饰符（版本 4 以后的浏览器支持）包括：支持多行字符串的 m；支持单行字符串的 s；忽略正则表达式模式中空白字符的 x。
• 在使用反向引用的时候，$`（反引号）将返回所匹配字符串之前的所有内容，$'（单引号）将返回所有匹配字符串之后的所有内容，$+将返回最后一个匹配的子表达式，$&将返回所匹配到的所有内容。
• JavaScript提供了一个名为 RegExp 的全局对象，在执行完一个正则表达式之后，你可以通过这个对象获得与这次执行有关的信息。
• JavaScript 不支持 POSIX 字符类。
• JavaScript 不支持 \A和\Z。

 
 

使用

RegExp 对象用于将文本与一个模式匹配。

new RegExp(pattern[, flags])
RegExp(pattern[, flags])
1
2

参数

pattern

正则表达式的文本。从 ES5 开始，这也可以是另一个RegExp对象或文字 (仅用于两个 RegExp 构造函数符号)。模式可以包含特殊字符special characters来匹配比字面值字符串更广泛的值范围。

flags

如果指定，flags 是包含要添加的标志的字符串。
或者，如果为模式提供了一个对象，flags 字符串将替换该对象的任何标志 (并且lastIndex将重置为 0)(从 ES2015 开始)。
如果没有指定flags并且提供了一个正则表达式对象，则该对象的 flags(和 lastIndex 值) 将被复制。

1. g （全局匹配）找到所有的匹配，而不是在第一个匹配之后停止。
2. i （忽略大小写）如果u标志也被启用，使用 Unicode 大小写折叠。
3. m （多行匹配）将开始和结束字符 (^ and $) 视为在多行上工作。换句话说，匹配每一行的开头或结尾each line (由\n或者\r 分隔)，而不仅仅是整个输入字符串的开头或结尾。
4. s （点号匹配所有字符）允许. 去匹配新的行。
5. u （统一码）将模式视为一系列 Unicode 代码点。
6. y （sticky，粘性匹配）仅匹配目标字符串中此正则表达式的 lastIndex 属性指示的索引。不尝试从任何以后的索引进行匹配。

const regex1 = RegExp('\\bqw\\b', 'g');
const str1 = 'qw qwjy qw qwjy';
let array1;

while ((array1 = regex1.exec(str1)) !== null) {
  console.log(`Found ${array1[0]}. Next starts at ${regex1.lastIndex}.`);
  // expected output: "Found qw. Next starts at 9."
  // expected output: "Found qw. Next starts at 19."
}

console.log(regex1.test(str1));
// expected output: true
console.log(regex1.test("cc"));
// expected output: false

const found = str1.match(regex1);
console.log(found);
// expected output: ["qw", "qw"]

const array = [...str1.matchAll(/q(w)(jy)/g)];
console.log(array[0]);
// expected output: ["qwjy", "w", "jy"]

console.log(str1.search(regex1));
// expected output: 0
console.log(str1[str1.search(regex1)]);
// expected output: "q"

console.log(str1.replace('qw', 'qwcc'));
// expected output: "qwcc qwjy qw qwjy"

console.log(str1.split(' '));
// expected output: ["qw", "qwjy", "qw", "qwjy"]
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

 
 

 
 

 
 

MySql 使用正则表达式

注意

• 只提供了搜索支持，不支持使用正则表达式进行替换操作。
• 在默认的情况下，正则表达式搜索不区分字母大小写。如果需要执行区分字母大小写的搜索，得使用 BINARY 关键字（放在 REGEXP 和模式之间）。
• 用 [ [:<:] ] 来匹配单词得开头，用 [ [:>:] ] 来匹配单词得结尾。
• 不支持环视。
• 不支持嵌入条件。
• 不支持八进制字符搜索。
• 不支持 \a、\b、\e、\f和\v。
• 不支持反向引用。

 
 

使用

MySql 允许在 WHERE 子句中使用正则表达式匹配：

REGEXP "expression"

SELECT * FROM table WHERE REGEXP "qwjy"
1
2
3

 
 

 
 

 
 

Python 使用正则表达式

注意

Python 通过 re 模块提供了正则表达式。

• 在使用之前，必须用 re.compile 将正则表达式编译成对象。
• re.compiler接受可选得标志，例如 re.IGNORECASE（表示搜索得时候不区分字母大小写）。
• 标志 re.VERBOSE 可协助调试正则表达式。
• 如果没有匹配，match() 和 search() 将返回 None。

 
 

使用

match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None；而 search 匹配整个字符串，直到找到一个匹配。

正则表达式修饰符 - 可选标志

import re
print(re.match('qw', 'qw qwjy qwcc').span())  # 在起始位置匹配
print(re.match('qwcc', 'qw qwjy qwcc'))         # 不在起始位置匹配

print(re.search('qw', 'qw qwjy qwcc').span())  # 在起始位置匹配
print(re.search('qwcc', 'qw qwjy qwcc').span())         # 不在起始位置匹配

num = re.sub(r'qw', "", "qw qwjy qwcc")	# 删除qw
print(num)

pattern = re.compile(r'qw')
m = pattern.match('qw qwjy qwcc')
print(m.span())

result = pattern.findall('qw qwjy qwcc')
print(result)

it = re.finditer(r"qw","qw qwjy qwcc") 
for match in it: 
    print (match.group() )

print(re.split('\s+', 'qw qwjy qwcc'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22