黑马程序员——java之正则表达式
2013-06-12 17:40
260 查看
------------android培训、java培训、期待与您交流！
-------------
正则表达式
1、正则表达式:符合一定规则的表达式。
作用：用于专门操作字符串。
特点：用于一些特定的符号来表示一些代码操作。这样就简化书写。
所以学习正则表达式，就是在学习一些特殊符号的使用。
好处：可以简化对字符串的复杂操作。
弊端：符号定义越多，正则越长，阅读性越差。
具体操作功能：
1，匹配：String matches方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。
2，切割：String split();
3，替换：String replaceAll(regex,str);如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式中的已有的组。
正则表达式的第四个功能。
4，获取:将字符串中的符合规则的子串取出。
操作步骤：
1，将正则表达式封装成对象。
2，让正则对象和要操作的字符串相关联。
3，关联后，获取正则匹配引擎。
4，通过引擎对符合规则的子串进行操作，比如取出。
2、正则表达式的基本符号
字符类
[abc] a、b 或c（简单类）
[^abc] 任何字符，除了a、b 或c（否定）
[a-zA-Z] a 到z 或A 到Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到d 或m 到p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或f（交集）
[a-z&&[^bc]] a 到z，除了b 和c：[ad-z]（减去）
[a-z&&[^m-p]] a 到z，而非m 到p：[a-lq-z]（减去）
预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9] 英文：digit
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
reedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好n 次
X{n,} X，至少n 次
X{n,m} X，至少n 次，但是不超过m 次
边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾
组和捕获
API中的描述
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式((A)(B(C)))中，存在四个这样的组：
组1.((A)(B(C))) 组2.\A 组3.(B(C)) 组4.(C)
组零始终代表整个表达式。
之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器获取。
与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串"aba"与表达式(a(b)?)+相匹配，会将第二组设置为"b"。在每个匹配的开头，所有捕获的输入都会被丢弃。
以(?)开头的组是纯的非捕获组，它不捕获文本，也不针对组合计进行计数。
使用注意事项：
1、 在切割中如果是使用“.”切割，正则表达式为”\\.”。
2、 在替换中，如果正则表达式中的一部分代表的内容还想被使用，可以先把这部分用()括起来，然后用“$组序号”来代表要保留的内容。
[html] view
plaincopyprint?
package Regex.cn.itcast.www;
import until.cn.itcast.Print;
/*正则的基本操作
* 1、匹配
* 2、分割
* 3.替换
* 4.获取
* */
public class RegexDemo {
/**
* @param args
*/
public static void main(String[] args) {
//checkTel("18739980800","1[358]\\d{9}");
//checkQQ("182173929","[1-9]\\d{4,14}");
//splitDemo("asd qwret adsf qewr dfs "," +");
//splitDemo("acssqwjhddddqwteyhhhhgfeee ","(.)\\1+");//去掉叠词
//splitDemo("asd|qwret|adsf|qewr|dfs","\\|");//去掉特殊字符
//splitDemo("asd qwret adsf qewr dfs "," +");
replaceAllDemo("wer1389980000ty1234564uiod234345675f","\\d{5,11}","#");
replaceAllDemo("erkktyqqquizzzzzo","(.)\\1+","$1");
}
/*-----------------------------替换--------------------------------------*/
public static void replaceAllDemo(String str,String reg,String newStr)
{
str = str.replaceAll(reg,newStr);
System.out.println(str);
}
/*------------------------------匹配--------------------------------------*/
/*
需求：手机号段13***，15***，18***
*/
public static void checkTel(String tel,String reg){
Print.sop(tel.matches(reg));
}
/*
需求一：对QQ号码进行校验，要求：5~15位，0不能开头，只能是数字。
*/
//使用正则表达式。
public static void checkQQ(String qq,String reg){
Print.sop(qq.matches(reg));
}
/*-----------------------------切割--------------------------------------*/
public static void splitDemo(String str,String reg){
Print.sop(str);
String [] arr = str.split(reg);
for(String s : arr){
Print.sop(s);
}
}
}
获取
获取：将字符串中符合规则的子串取出。
操作步骤：
1将正则表达式封装成对象。
2.让正则对象和要操作的字符串相关联。
3.关联后，获取正则匹配引擎。
4.通过引擎对符合规则的子串进行操作，比如取出。
[html] view
plaincopyprint?
示例代码：
import java.util.regex.*;
class RegexDemo2
{
public static void main(String[] args)
{
getDemo();
}
//获取只有3个字符组成的单词。
public static void getDemo()
{
String str = "ming tian jiu yao fang jia la ,da jia.";
System.out.println(str);
String reg = "\\b[a-z]{4}\\b";// \b表示单词边界。
//1.将规则封装成对象。
Pattern p =Pattern.compile(reg);
//2.让正则对象和要作用的字符串相关联。获取关联字符串的匹配器对象。
Matcher m = p.matcher(str);
//3.使用匹配引擎进行各种操作，如查找、匹配、获取等。
/*
System.out.println(m.matches());matches是匹配整个字符串。
其实，String类中的mathes方法用的就是Pattern和Matches对象俩完成的。只不过被String的方法封装后，用起来较为简单，但是功能却单一。
boolean b = m.find();//将规则作用到字符串上，并进行符合规则的子串查找。
System.out.println(b);
System.out.println(m.group());//用于获取匹配后的结果，使用前必须先进行匹配操作。
*/
System.out.println(m.matches());
m.reset();//这句注释掉，while循环执行结果会少一个ming
while(m.find())//判断符合规则的子串是否存在，它开始查找的结果是上次匹配后的指针位置
{
System.out.println(m.group());//取出这个符合规则的子串。
System.out.println(m.start()+"...."+m.end());//m.gruop取出的子串在原字符串的开始和结束角标，注意角标包含头不包含尾。
}
/*
*注意：同一个匹配器 ，每匹配一次，角标指针就向后移动一次，下次匹配的开始位置是上次匹配的结束位置。
*如果已经匹配过后，又要从新查找匹配，可以说使用匹配器的reset()方法，将指针归0。
*/
}
}
如何判断选取那种功能
到底用四种功能中的哪一个呢?或者那几个呢？
1.如果只想知道该字符串是对是错，使用匹配。
2.想要将已有的字符串编程另一个字符串，使用替换。
3.想要按照指定的方式将字符串变成多个字符串，使用切割，获取规则以外的子串。
4.想要拿到符合需求的字符串子串，使用获取，符合规则的子串。
[html] view
plaincopyprint?
练习
去叠词、IP地址排序、邮件校验
import java.util.*;
class RegexTest
{
public static void main(String[] args)
{
//test_1();
//ipSort();
checkMail();
}
/*
需求3：对邮件地址进行校验。这个必须掌握
*/
public static void checkMail()
{
String mail ="asdfas12@sina.com.cn";
// mail = "1@1.1";
String reg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";
// reg = "\\w+@\\w+(\\.\\w+)";//相对不太精确的匹配。
//mail.indexOf("@")!=-1;这种方式不要用。
System.out.println(mail.matches(reg));
}
/*
需求2： 将下边的ip地址段进行地址段顺序的排序。
192.168.1.15 23.48.56.109 10.73.91.18 254.253.252.1 1.23.25.26
思路：
还按照字符自然顺序，只要让它们每一段都是3位即可，
1.按照每一段需要的最多的0进行补齐，那么每一段就会至少保证有3位。
2.将每一段只保留三位，这样所有的ip地址都是每一段3位。
*/
public static void ipSort()
{
String ip = "92.168.1.15 23.48.56.109 10.73.91.18 254.253.252.1 1.23.25.26";
ip = ip.replaceAll("(\\d+)","00$1"); //将.分开的数字封装成组，然后在其前边加00
System.out.println(ip);
//针对0出现一次或多次的，讲其后的数字封装成组1，然后替换掉
ip = ip.replaceAll("0+(\\d{3})","$1");
String [] arr = ip.split(" +");
//Arrays.sort(arr);//如果有重复的IP地址并要获取，那么必须用这个
//也可以存入list集合，然后用collections来排序
TreeSet<String> ts = new TreeSet<String>();
for(String str:arr)
{
//System.out.println(str);
ts.add(str);
}
for(String s:ts)
{
//去掉IP地址中多余的零，同样用替换的方式。
System.out.println(s.replaceAll("0+(\\d+)","$1"));
}
/*
Iterator<String> it = ts.iterator();
while(it.hasNext())
{
String str = it.next();
str=str.replaceAll("0+(\\d+)","$1");
System.out.println(str);
}
*/
}
/*
* 需求1：将下列字符串转成：我要学编程。
*/
public static void test_1()
{
String str = "我我.....我我我我我....我要...要要......要学.....学学学...编编编..编程.程.....程程程...程";
System.out.println(str);
/*
将已有字符串变成另一个字符串，使用 替换功能。
1.先将. 去掉。
2.再将多个重复的内容变成单个内容。
*/
str = str.replaceAll("\\.","");
//封装成组进行替换。Back 引用 ：\n 任何匹配的 nth 捕获组
str = str.replaceAll("(.)\\1+","$1");
System.out.println(str);
}
}
网页爬虫
网络爬虫，是搜索引擎的的原理之一，它可以用来检索网络上的信息。
[html] view
plaincopyprint?
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import until.cn.itcast.Print;
public class GetMileFromIE {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//getMilFromIE();
getMailFromFile();
}
//从网页获取邮箱
public static void getMilFromIE() throws IOException{
URL url = new URL("http://127.0.0.1:8080/myweb/mail.html");
URLConnection ucon = url.openConnection();
BufferedReader bf =
new BufferedReader(newInputStreamReader(ucon.getInputStream()));
String line = null;
String regex = "\\w+@\\w+(\\.\\w+)+";
Pattern pa = Pattern.compile(regex);
//让正则对象与所要作用的字符串关联，获取匹配器。
while((line = bf.readLine())!=null){
Matcher ma = pa.matcher(line);
while(ma.find()){
Print.sop(ma.group());
}
}
}
//从文件获取邮箱
public static void getMailFromFile() throws IOException{
BufferedReader br =
new BufferedReader(new FileReader("d:\\java\\day25\\mail.txt"));
String line = null;
String regex = "\\w+@\\w+(\\.\\w+)+";
Pattern pa = Pattern.compile(regex);
//让正则对象与所要作用的字符串关联，获取匹配器。
while((line = br.readLine())!=null){
Matcher ma = pa.matcher(line);
while(ma.find()){
Print.sop(ma.group());
}
}
}
}
-------------
正则表达式
1、正则表达式:符合一定规则的表达式。
作用：用于专门操作字符串。
特点：用于一些特定的符号来表示一些代码操作。这样就简化书写。
所以学习正则表达式，就是在学习一些特殊符号的使用。
好处：可以简化对字符串的复杂操作。
弊端：符号定义越多，正则越长，阅读性越差。
具体操作功能：
1，匹配：String matches方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。
2，切割：String split();
3，替换：String replaceAll(regex,str);如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式中的已有的组。
正则表达式的第四个功能。
4，获取:将字符串中的符合规则的子串取出。
操作步骤：
1，将正则表达式封装成对象。
2，让正则对象和要操作的字符串相关联。
3，关联后，获取正则匹配引擎。
4，通过引擎对符合规则的子串进行操作，比如取出。
2、正则表达式的基本符号
字符类
[abc] a、b 或c（简单类）
[^abc] 任何字符，除了a、b 或c（否定）
[a-zA-Z] a 到z 或A 到Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到d 或m 到p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或f（交集）
[a-z&&[^bc]] a 到z，除了b 和c：[ad-z]（减去）
[a-z&&[^m-p]] a 到z，而非m 到p：[a-lq-z]（减去）
预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9] 英文：digit
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
reedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好n 次
X{n,} X，至少n 次
X{n,m} X，至少n 次，但是不超过m 次
边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾
组和捕获
API中的描述
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式((A)(B(C)))中，存在四个这样的组：
组1.((A)(B(C))) 组2.\A 组3.(B(C)) 组4.(C)
组零始终代表整个表达式。
之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器获取。
与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串"aba"与表达式(a(b)?)+相匹配，会将第二组设置为"b"。在每个匹配的开头，所有捕获的输入都会被丢弃。
以(?)开头的组是纯的非捕获组，它不捕获文本，也不针对组合计进行计数。
使用注意事项：
1、 在切割中如果是使用“.”切割，正则表达式为”\\.”。
2、 在替换中，如果正则表达式中的一部分代表的内容还想被使用，可以先把这部分用()括起来，然后用“$组序号”来代表要保留的内容。
[html] view
plaincopyprint?
package Regex.cn.itcast.www;
import until.cn.itcast.Print;
/*正则的基本操作
* 1、匹配
* 2、分割
* 3.替换
* 4.获取
* */
public class RegexDemo {
/**
* @param args
*/
public static void main(String[] args) {
//checkTel("18739980800","1[358]\\d{9}");
//checkQQ("182173929","[1-9]\\d{4,14}");
//splitDemo("asd qwret adsf qewr dfs "," +");
//splitDemo("acssqwjhddddqwteyhhhhgfeee ","(.)\\1+");//去掉叠词
//splitDemo("asd|qwret|adsf|qewr|dfs","\\|");//去掉特殊字符
//splitDemo("asd qwret adsf qewr dfs "," +");
replaceAllDemo("wer1389980000ty1234564uiod234345675f","\\d{5,11}","#");
replaceAllDemo("erkktyqqquizzzzzo","(.)\\1+","$1");
}
/*-----------------------------替换--------------------------------------*/
public static void replaceAllDemo(String str,String reg,String newStr)
{
str = str.replaceAll(reg,newStr);
System.out.println(str);
}
/*------------------------------匹配--------------------------------------*/
/*
需求：手机号段13***，15***，18***
*/
public static void checkTel(String tel,String reg){
Print.sop(tel.matches(reg));
}
/*
需求一：对QQ号码进行校验，要求：5~15位，0不能开头，只能是数字。
*/
//使用正则表达式。
public static void checkQQ(String qq,String reg){
Print.sop(qq.matches(reg));
}
/*-----------------------------切割--------------------------------------*/
public static void splitDemo(String str,String reg){
Print.sop(str);
String [] arr = str.split(reg);
for(String s : arr){
Print.sop(s);
}
}
}
获取
获取：将字符串中符合规则的子串取出。
操作步骤：
1将正则表达式封装成对象。
2.让正则对象和要操作的字符串相关联。
3.关联后，获取正则匹配引擎。
4.通过引擎对符合规则的子串进行操作，比如取出。
[html] view
plaincopyprint?
示例代码：
import java.util.regex.*;
class RegexDemo2
{
public static void main(String[] args)
{
getDemo();
}
//获取只有3个字符组成的单词。
public static void getDemo()
{
String str = "ming tian jiu yao fang jia la ,da jia.";
System.out.println(str);
String reg = "\\b[a-z]{4}\\b";// \b表示单词边界。
//1.将规则封装成对象。
Pattern p =Pattern.compile(reg);
//2.让正则对象和要作用的字符串相关联。获取关联字符串的匹配器对象。
Matcher m = p.matcher(str);
//3.使用匹配引擎进行各种操作，如查找、匹配、获取等。
/*
System.out.println(m.matches());matches是匹配整个字符串。
其实，String类中的mathes方法用的就是Pattern和Matches对象俩完成的。只不过被String的方法封装后，用起来较为简单，但是功能却单一。
boolean b = m.find();//将规则作用到字符串上，并进行符合规则的子串查找。
System.out.println(b);
System.out.println(m.group());//用于获取匹配后的结果，使用前必须先进行匹配操作。
*/
System.out.println(m.matches());
m.reset();//这句注释掉，while循环执行结果会少一个ming
while(m.find())//判断符合规则的子串是否存在，它开始查找的结果是上次匹配后的指针位置
{
System.out.println(m.group());//取出这个符合规则的子串。
System.out.println(m.start()+"...."+m.end());//m.gruop取出的子串在原字符串的开始和结束角标，注意角标包含头不包含尾。
}
/*
*注意：同一个匹配器 ，每匹配一次，角标指针就向后移动一次，下次匹配的开始位置是上次匹配的结束位置。
*如果已经匹配过后，又要从新查找匹配，可以说使用匹配器的reset()方法，将指针归0。
*/
}
}
如何判断选取那种功能
到底用四种功能中的哪一个呢?或者那几个呢？
1.如果只想知道该字符串是对是错，使用匹配。
2.想要将已有的字符串编程另一个字符串，使用替换。
3.想要按照指定的方式将字符串变成多个字符串，使用切割，获取规则以外的子串。
4.想要拿到符合需求的字符串子串，使用获取，符合规则的子串。
[html] view
plaincopyprint?
练习
去叠词、IP地址排序、邮件校验
import java.util.*;
class RegexTest
{
public static void main(String[] args)
{
//test_1();
//ipSort();
checkMail();
}
/*
需求3：对邮件地址进行校验。这个必须掌握
*/
public static void checkMail()
{
String mail ="asdfas12@sina.com.cn";
// mail = "1@1.1";
String reg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";
// reg = "\\w+@\\w+(\\.\\w+)";//相对不太精确的匹配。
//mail.indexOf("@")!=-1;这种方式不要用。
System.out.println(mail.matches(reg));
}
/*
需求2： 将下边的ip地址段进行地址段顺序的排序。
192.168.1.15 23.48.56.109 10.73.91.18 254.253.252.1 1.23.25.26
思路：
还按照字符自然顺序，只要让它们每一段都是3位即可，
1.按照每一段需要的最多的0进行补齐，那么每一段就会至少保证有3位。
2.将每一段只保留三位，这样所有的ip地址都是每一段3位。
*/
public static void ipSort()
{
String ip = "92.168.1.15 23.48.56.109 10.73.91.18 254.253.252.1 1.23.25.26";
ip = ip.replaceAll("(\\d+)","00$1"); //将.分开的数字封装成组，然后在其前边加00
System.out.println(ip);
//针对0出现一次或多次的，讲其后的数字封装成组1，然后替换掉
ip = ip.replaceAll("0+(\\d{3})","$1");
String [] arr = ip.split(" +");
//Arrays.sort(arr);//如果有重复的IP地址并要获取，那么必须用这个
//也可以存入list集合，然后用collections来排序
TreeSet<String> ts = new TreeSet<String>();
for(String str:arr)
{
//System.out.println(str);
ts.add(str);
}
for(String s:ts)
{
//去掉IP地址中多余的零，同样用替换的方式。
System.out.println(s.replaceAll("0+(\\d+)","$1"));
}
/*
Iterator<String> it = ts.iterator();
while(it.hasNext())
{
String str = it.next();
str=str.replaceAll("0+(\\d+)","$1");
System.out.println(str);
}
*/
}
/*
* 需求1：将下列字符串转成：我要学编程。
*/
public static void test_1()
{
String str = "我我.....我我我我我....我要...要要......要学.....学学学...编编编..编程.程.....程程程...程";
System.out.println(str);
/*
将已有字符串变成另一个字符串，使用 替换功能。
1.先将. 去掉。
2.再将多个重复的内容变成单个内容。
*/
str = str.replaceAll("\\.","");
//封装成组进行替换。Back 引用 ：\n 任何匹配的 nth 捕获组
str = str.replaceAll("(.)\\1+","$1");
System.out.println(str);
}
}
网页爬虫
网络爬虫，是搜索引擎的的原理之一，它可以用来检索网络上的信息。
[html] view
plaincopyprint?
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import until.cn.itcast.Print;
public class GetMileFromIE {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//getMilFromIE();
getMailFromFile();
}
//从网页获取邮箱
public static void getMilFromIE() throws IOException{
URL url = new URL("http://127.0.0.1:8080/myweb/mail.html");
URLConnection ucon = url.openConnection();
BufferedReader bf =
new BufferedReader(newInputStreamReader(ucon.getInputStream()));
String line = null;
String regex = "\\w+@\\w+(\\.\\w+)+";
Pattern pa = Pattern.compile(regex);
//让正则对象与所要作用的字符串关联，获取匹配器。
while((line = bf.readLine())!=null){
Matcher ma = pa.matcher(line);
while(ma.find()){
Print.sop(ma.group());
}
}
}
//从文件获取邮箱
public static void getMailFromFile() throws IOException{
BufferedReader br =
new BufferedReader(new FileReader("d:\\java\\day25\\mail.txt"));
String line = null;
String regex = "\\w+@\\w+(\\.\\w+)+";
Pattern pa = Pattern.compile(regex);
//让正则对象与所要作用的字符串关联，获取匹配器。
while((line = br.readLine())!=null){
Matcher ma = pa.matcher(line);
while(ma.find()){
Print.sop(ma.group());
}
}
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 黑马程序员_java基础笔记(08)...GUI,网络编程，正则表达式
- 黑马程序员——Java笔记——正则表达式笔记
- 黑马程序员——java学习15（毕25）——正则表达式
- 黑马程序员——Java String类 and 正则表达式（第七篇）
- 黑马程序员java笔记之七-----正则表达式
- 黑马程序员 Java面向对象——正则表达式
- 黑马程序员-----java基础（正则表达式和反射）
- 黑马程序员_java正则表达式
- 黑马程序员---从头开始，回忆JAVA基础之正则表达式。
- 黑马程序员-------------------java基础--------------------正则表达式
- 黑马程序员---------------JAVA基础--------正则表达式
- 黑马程序员—【Java基础篇】之正则表达式
- 黑马程序员——【Java基础】——正则表达式
- 黑马程序员 Java正则表达式
- 黑马程序员---java基础之正则表达式
- 黑马程序员Java__正则表达式
- 黑马程序员--JAVA<正则表达式>
- 黑马程序员—(JAVA)正则表达式
- 黑马程序员——Java基础---正则表达式
- 黑马程序员_Java基础_正则表达式,校验QQ号,手机号,邮箱,IP地址排序,网络爬虫