正则表达式定义了字符串的模式。可以用来搜索、编辑或处理文本。并不仅限于某一种语言,但是在每种语言中有细微的差别。这里主要讲java中的运用。
正则表达式:符合一定规则的表达式。
作用:用于专门操作字符串。
特点:用于一些特定的符号来表示一些代码操作。这样就简化书写。
所以学习正则表达式,就是在学习一些特殊符号的使用。
好处:可以简化对字符串的复杂操作。
弊端:符号定义越多,正则越长,阅读性越差。
具体操作功能:
1,匹配:String matches方法。用规则匹配整个字符串,只要有一处不符合规则,就匹配结束,返回false。
2,切割:String split();
3,替换:String replaceAll(regex,str);如果regex中有定义组,可以在第二参数中通过$符号获取正则表达式中的已有的组。
4,获取:将字符串中的符合规则的子串取出。
一,元字符的介绍。
* |
匹配前面的子表达式零次或多次。例如,zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。 |
+ |
匹配前面的子表达式一次或多次。例如,'zo+' 能匹配 "zo" 以及 "zoo",但不能匹配 "z"。+ 等价于 {1,}。 |
? |
匹配前面的子表达式零次或一次。例如,"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。 |
{n} |
n 是一个非负整数。匹配确定的 n 次。例如,'o{2}' 不能匹配 "Bob" 中的 'o',但是能匹配 "food" 中的两个 o。 |
{n,} |
n 是一个非负整数。至少匹配n 次。例如,'o{2,}' 不能匹配 "Bob" 中的 'o',但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。 |
{n,m} |
m 和 n 均为非负整数,其中n <= m。最少匹配 n 次且最多匹配 m 次。例如,"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。 |
? |
当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串 "oooo",'o+?' 将匹配单个 "o",而 'o+' 将匹配所有 'o'。 |
. |
匹配除换行符(\n、\r)之外的任何单个字符。要匹配包括 '\n' 在内的任何字符,请使用像"(.|\n)"的模式。 |
x|y |
匹配 x 或 y。例如,'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。 |
[xyz] |
字符集合。匹配所包含的任意一个字符。例如, '[abc]' 可以匹配 "plain" 中的 'a'。 |
[^xyz] |
负值字符集合。匹配未包含的任意字符。例如, '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。 |
[a-z] |
字符范围。匹配指定范围内的任意字符。例如,'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。 |
[^a-z] |
负值字符范围。匹配任何不在指定范围内的任意字符。例如,'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。 |
\b |
匹配一个单词边界,也就是指单词和空格间的位置。例如, 'er\b' 可以匹配"never" 中的 'er',但不能匹配 "verb" 中的 'er'。 |
\B |
匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er',但不能匹配 "never" 中的 'er'。 |
\d |
匹配一个数字字符。等价于 [0-9]。 |
\D |
匹配一个非数字字符。等价于 [^0-9]。 |
\w |
匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。 |
\W |
匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。 |
所有的元字符(有些不是特别常用的上面没有提到)都是特殊字符,使用的时候,都要用转义字符转义,即家 \ ,比如 . 就应该是\. 比如+ 就应该是 \+ 。而在java中,字符串里面 \ 是需要用转义字符在转一次的。所以. 就应该是\\. +就应该是 \\+ 。
二,具体的操作。
1,匹配。
/**
* 匹配
*/
public static void check(String string, String regexp) {
boolean matches = string.matches(regexp);
System.out.println(matches);
}
//----------------------------匹配------------------------------------
check("823654785", "[1-9]\\d{5,11}");//检测qq,要求qq6-12位,第一个数字不为0
/*解释: [1-9]匹配的是一个1-9的数字 \\d{5,11}匹配的是每位都是由0-9组成的数字,这个数字最少5位,最多11位*/
check("13531614727", "1[3578]\\d{9}");//检测手机号码,13**** 15***** 17***** 18*****
/*解释: 1匹配1 [3578]匹配的是一位数字,数字可能是3,5,7,8 \\d{9}匹配的是每位都是由0-9组成的数字,这个数字9位*/
//为了可以让规则的结果被重用,可以将规则封装成一个组。用()完成。
check("[email protected]", "\\w+@\\w+(\\.\\w+)+");//检测邮箱 [email protected] [email protected]
/* 解释:\\w+ 匹配一段[a-zA-Z0-9_]的字符串,字符串的位数至少1个 @匹配@ \\w+ 匹配一段[a-zA-Z0-9_]的字符串,字符串的位数至少1个 \\. 匹配 .
\\w+ 匹配一段[a-zA-Z0-9_]的字符串,字符串的位数至少1个 (\\.\\w+)将\\.和\\w+包装成一个组,里面的内容表示一个点加一个字符串,字符串要求满足[a-zA-Z0-9_],且至少一位
(\\.\\w+)+满足这个组的需求的至少1个 */
2,切割
/**
* 切割
*/
public static void split(String string, String regexp) {
String[] split = string.split(regexp);
for (String s : split) {
System.out.println(" s = " + s);
}
}
//----------------------------切割-----------------------------------
split("zhangsan.lisi.wangwu.zhouliu", "\\.");//将字符串按照 . 切割成几个名字
/* 解释: 因为 . 是元字符,所以需要转义用 \. ,又因为在字符串中\要用\\来转义,所以要用\\.来表示 . */
split("D:\\学习视频\\黑马程序员_毕向东_正则\\day25", "\\\\");//将字符串按照 \\ 切割成几个小字符串
/* 解释: 因为\\在字符串中需要转义,所以是 \\\\ */
//为了可以让规则的结果被重用,可以将规则封装成一个组。用()完成。组的出现都有编号。从1开始。 想要使用已有的组可以通过 \n(n就是组的编号)的形式来获取。
split("erkktyqqquizzzzzofeweweegfrf", "(.)\\1+");//按照叠词完成切割
/* 解释: (.)匹配任意字符,将匹配结果封装成组。 (.)\\1+ 括号内丝组装好的匹配,//1是表示第一组,+ 表示出现至少一次 */
split("ddqw ddqw dwrwre rfrwe fwew wedfs dqede ", " +");//按照空格完成切割,注意其中空格不一定是一个,也可能是多个
/* 解释: " +" 空格出现一次或多次 */
3,替换
/**
* 替换
*/
public static void replaceAll(String string, String regexp, String newstr) {
String s = string.replaceAll(regexp, newstr);
System.out.println("替换之后结果是 = " + s);
}
//----------------------------替换-----------------------------------
replaceAll("wer1389980000ty1234564uiod2334345675f", "\\d+", "#");//将数字中的字符串替换成#
replaceAll("wer1389980000ty1234564uiod2334345675f", "\\d+", "\\+");//将数字中的字符串替换成$ 因为$是特殊字符,所以需要转义
replaceAll("gaoolonggxiaaopenggggyouuu", "(.)\\1+", "$1");//将重叠的字符替换成单个字母。eg:zzzz->z
4,获取
/*
获取:将字符串中的符合规则的子串取出。
操作步骤:
1,将正则表达式封装成对象。
2,让正则对象和要操作的字符串相关联。
3,关联后,获取正则匹配引擎。
4,通过引擎对符合规则的子串进行操作,比如取出。
*/
// "ming tian jiu yao fang jia le ,da jia。" 取出字符串中三个字母组成的单词
public static void main(String[] args) {
String string = "ming tian jiu yao fang jia le ,da jia。";
System.out.println("string = " + string);
// 1,将正则表达式封装成对象。
Pattern pattern = Pattern.compile("\\b[a-z]{3}\\b");
//2,让正则对象和要作用的字符串相关联。获取匹配器对象。
Matcher matcher = pattern.matcher(string);
while (matcher.find()) { //3,关联后,获取正则匹配引擎。移动下标
String group = matcher.group();//获取字符串
System.out.println( group+" "+matcher.start() + " ........ " + matcher.end());//获取得到的字符串的开始和结束的下标
}
}
练习:
/**
* 将下列字符串转成:我要学编程.
*/
public static void test1() {
String str = "我我...我我...我要..要要...要要...学学学....学学...编编编...编程..程.程程...程...程";
String replace = str.replaceAll("\\.", "");
String s = replace.replaceAll("(.)\\1+", "$1");
System.out.println("replace = " + replace);
System.out.println("s = " + s);
}
/**
* 192.68.1.254 102.49.23.13 10.10.10.10 2.2.2.2 8.109.90.30 将ip地址进行地址段顺序的排序。
*/
public static void test2() {
String str = "192.68.1.254 102.49.23.013 10.0.10.10 2.2.2.2 8.109.90.30";
//1,先在每段前面加两个0
String str1 = str.replaceAll("(\\d+)", "00$1");
System.out.println("str1 = "+str1);
//2,将每段改成三位数
String str2 = str1.replaceAll("0+(\\d{3})", "$1");
System.out.println("str2 = "+str2);
String[] split = str2.split(" +");
Arrays.sort(split);
StringBuffer sb = new StringBuffer();
for (String s : split) {
String newstr = s.replaceAll("0*(\\d+)", "$1");
sb.append(newstr+" ");
}
System.out.println(sb.toString());
}