Pattern.split方法详解
/**
* 测试Pattern.split方法
*/
@Test
public void testPatternSplit() {
String str = "{0x40, 0x11, 0x00, 0x00}";
// 分割符为：逗号, {,}, 空白符
String regex = "[,\\{\\}\\s]";
Pattern pattern = Pattern.compile(regex);
/*
* 1. split 方法用于使用正则表达式中的字符分割待匹配的字符串
*
* 注意：
* 1. 如果分割符位于原字符串的起始位置，则分割的时候，会在起始位置上分割出一个""出来
* 2. 如果有连续两个分隔符，则会在这两个分割符之间分割有一个""出来
* */
System.out.println("----------- split test -----------");
String[] results = pattern.split(str);
System.out.println("length :" + results.length);
for (int i = 0; i < results.length; i++) {
System.out.println("element_" +i + " :" + results[i]);
}
System.out.println(Arrays.toString(results));
/*
* 2. split方法的limit参数的意思是使用正则表达式的分割字符将原字符串分为limit个组
* **/
System.out.println("\n----------- split limit test -----------");
String[] resultsLimit = pattern.split(str, 2);
for (int i = 0; i < resultsLimit.length; i++) {
System.out.print(resultsLimit[i]);
}
}
结果：
----------- split test -----------
element_0 :
element_1 :0x40
element_2 :
element_3 :0x11
element_4 :
element_5 :0x00
element_6 :
element_7 :0x00
[, 0x40, , 0x11, , 0x00, , 0x00]
----------- split limit test -----------
0x40, 0x11, 0x00, 0x00}
Matcher的find/find/start/end方法详解
- 测试Matcher的find方法：尝试在目标字符串中查找下一个匹配的字串，需在循环中迭代。
- groupCount ：返回当前查找所获得的匹配组的数量，不包括整个整个正则表达式的匹配。
比如，表达式有两个子分组，则groupCount == 2 - group(i):指的是用()包含的子分组，按照定义的顺序标识下标，当正则表达式中使用 |连接分组，那么有的分组匹配的字串可能为null。
- start(group):返回此子分组匹配的子串在原字符串中的起始位置(包含)
end(group):返回此子分组匹配的子串在原字符串中的结束位置(不包含)
即子分组匹配的字符串在原字符串的位置为 [start(i),end(i)),左闭右开。
@Test
public void testMatcherGroupFindStartEnd() {
String str = "{0x40, 0x31, 0x20, 0x00}";
String regex = "([A-Za-z0-9]+)(,)";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
// 对于在整个原字符串中，找到的下一个匹配的字串
while (matcher.find()) {
// 输出groupCount的数量
System.out.println("groupCount : " + matcher.groupCount());
// 0-输出整个匹配
System.out.println("the substring of contains all group : " + matcher.group(0));
System.out.println("group_0 start index : " + matcher.start(0) + " end :" + matcher.end(0));
// 依次输出子分组的匹配结果
// 如果子分组之间是通过 | 来连接的，则子分组的匹配结果有的为null
for (int i = 1; i <= matcher.groupCount(); i++) {
System.out.println("group_" + i + ":" + matcher.group(i));
System.out.println("group_" + i + " start index : " + matcher.start(i) + " end :" + matcher.end(i));
}
}
}
结果：
groupCount : 2
the substring of contains all group : 0x40,
group_0 start index : 1 end :6
group_1:0x40
group_1 start index : 1 end :5
group_2:,
group_2 start index : 5 end :6
groupCount : 2
the substring of contains all group : 0x31,
group_0 start index : 7 end :12
group_1:0x31
group_1 start index : 7 end :11
group_2:,
group_2 start index : 11 end :12
groupCount : 2
the substring of contains all group : 0x20,
group_0 start index : 13 end :18
group_1:0x20
group_1 start index : 13 end :17
group_2:,
group_2 start index : 17 end :18
Matcher的replace/append方法详解
测试Matcher的匹配替换以及追加的方法：
- matcher.replaceAll方法 ：替换在原字符串中所有被正则表达式匹配的字串，并返回替换之后的结果
- matcher.replaceFirst方法 ：替换在原字符串中第一个被正则表达式匹配的字串，并返回替换之后的结果
- matcher.appendReplacement方法 ： 将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里（需while(matcher.find())进行配合迭代）
- matcher.appendTail(StringBuffer sb) 方法则将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。
3和4的结合能够实现将原字符串中的某些字串替换指定字符，并返回完成替换之后的结果
@Test
public void testMatcherReplaceAppend() {
String str = "{0x40, 0x31, 0x20, 0x00}";
String regex = "([0-9A-Za-z]+)";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
// replaceAll
System.out.println("----------- replace all test ----------");
String replacedAllStr = matcher.replaceAll("replace");
System.out.println("replaced : " + replacedAllStr);
//matcher.reset(str); // 重置被matcher的字符串
matcher.reset(); // 重置matcher，以实现对原字符串重新搜索
// replaceFirst
System.out.println("------------ replace first test ---------");
String replacedFirstStr = matcher.replaceFirst("replace");
System.out.println("replaced first : " + replacedFirstStr);
matcher.reset();
// appendReplacement
System.out.println("------------- appendReplacement test ------------");
StringBuffer appendRepStr = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(appendRepStr,"0xffff");
}
System.out.println(appendRepStr);
// 最后调用appendTail将匹配剩余的字符串添加都StringBuffer的末尾
// 注意这时要实现完整的功能：将所有匹配的内容替换并添加到appendRepStr中，剩余未匹配的继续添加到
// appendRepStr中，相当于对原字符串进行全部的替换
// 此时要保证，在遍历所有匹配的字串后调用appendTail方法
System.out.println("------------ appendTail test ---------------");
matcher.appendTail(appendRepStr);
System.out.println(appendRepStr);
}
结果：
----------- replace all test ----------
replaced : {replace, replace, replace, replace}
------------ replace first test ---------
replaced first : {replace, 0x31, 0x20, 0x00}
------------- appendReplacement test ------------
{0xffff, 0xffff, 0xffff, 0xffff
------------ appendTail test ---------------
{0xffff, 0xffff, 0xffff, 0xffff}
测试文件源码地址
https://github.com/zhanglbjames/exercises/blob/master/src/test/java/huawei_8_16/TestT1.java
1-匹配字符类
方括号一次只能匹配括号内的一个字符
- [abc]
a, b, or c (简单类)
- [^abc]
除了a、b或c之外的任意 字符（求反）
- [a-zA-Z]
a到z或A到Z ，包含（范围)
- [a-zA-Z0-9]
匹配一次所有数字和字母的类型
- [a-b-r]
匹配 a-b ,连接符 -,r
注意如果想要连接符起到范围的作用，应该满足如下格式[a-bc-de-gf-k]
即每个连接符占用的字符不能被其他连接符占用
圆括号一次匹配多个字符
- 比如方括号的正则表达式"t[aeio]n"只匹配"tan"、"Ten"、"tin"和"ton"，只能匹配单个字符,不能匹配"taeion"
- 圆括号可以一次匹配多个字符，比如使用"t(a|e|i|o|oo)n"正则表达式，可以匹配"taen"，"tan"，"taeiooon"等
也可以配合[]使用，如正则为"t([aei]|o|oo)n"，则可以匹配 "taon"，"teoon"，但是不能匹配"taeioon"
2-预定义字符类
- . 匹配除换行符 \n 之外的任何单字符
比如：表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配“t#n”、“tpn”甚至“t n”。
- \d 数字: [0-9]
- \D 非数字: [^0-9]
- \s 空格符: [ \t\n\x0B\f\r]
- \S 非空格符: [^\s]
- \w 单词字符: [a-zA-Z_0-9]
- \W 非单词字符: [^\w]
记忆规则 大写表示取反，小写如下记忆
d:digit(数字)
s:space(空白字符)
w:word(单词字符), 注意包括下划线
3-表达式匹配次数
* 0次或者多次（允许0次的贪婪匹配）
例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}
+ 1次或者多次（贪婪匹配）
例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
? 0次或者1次 （非贪婪匹配，允许0次）
例如，"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。
{n} 恰好n次
{n,m} 从n次到m次
{n,} 至少n次
注意上述n为非负数
4-特殊字符需要转义
特殊字符
