正则表达式定义了字符串的模式。可以用来搜索、编辑或处理文本。并不仅限于某一种语言，但是在每种语言中有细微的差别。这里主要讲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());
}