一、正则表达式概述
1、 概念:符合一定规则的表达式。
2、 作用:用于专门操作字符串。
3、 特点:用于一些特定的符号来表示一些代码操作,这样可以简化书写。所以学习正则表达式,就是在学习一些特殊符号的使用。
4、 好处:可以简化对字符串的复杂操作。
5、 弊端:符合定义越多,正则越长,阅读性越差。
构造 | 匹配 |
---|---|
字符 | |
x | 字符 x |
\\ | 反斜线字符 |
\0n | 带有八进制值 0 的字符 n (0<= n <= 7) |
\0nn | 带有八进制值 0 的字符 nn (0<= n <= 7) |
\0mnn | 带有八进制值 0 的字符 mnn(0<= m <= 3、0 <= n <= 7) |
\xhh | 带有十六进制值 0x 的字符 hh |
\uhhhh | 带有十六进制值 0x 的字符 hhhh |
\t | 制表符 ('\u0009') |
\n | 新行(换行)符 ('\u000A') |
\r | 回车符 ('\u000D') |
\f | 换页符 ('\u000C') |
\a | 报警 (bell) 符 ('\u0007') |
\e | 转义符 ('\u001B') |
\cx | 对应于 x 的控制符 |
字符类 | |
[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] |
\D | 非数字: [^0-9] |
\s | 空白字符:[ \t\n\x0B\f\r] |
\S | 非空白字符:[^\s] |
\w | 单词字符:[a-zA-Z_0-9] |
\W | 非单词字符:[^\w] |
POSIX 字符类(仅 US-ASCII) | |
\p{Lower} | 小写字母字符:[a-z] |
\p{Upper} | 大写字母字符:[A-Z] |
\p{ASCII} | 所有 ASCII:[\x00-\x7F] |
\p{Alpha} | 字母字符:[\p{Lower}\p{Upper}] |
\p{Digit} | 十进制数字:[0-9] |
\p{Alnum} | 字母数字字符:[\p{Alpha}\p{Digit}] |
\p{Punct} | 标点符号:!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ |
java.lang.Character 类(简单的 java 字符类型) | |
---|---|
\p{javaLowerCase} | 等效于 java.lang.Character.isLowerCase() |
\p{javaUpperCase} | 等效于 java.lang.Character.isUpperCase() |
\p{javaWhitespace} | 等效于 java.lang.Character.isWhitespace() |
\p{javaMirrored} | 等效于 java.lang.Character.isMirrored() |
Unicode 块和类别的类 | |
\p{InGreek} | Greek 块(简单块)中的字符 |
\p{Lu} | 大写字母(简单类别) |
\p{Sc} | 货币符号 |
\P{InGreek} | 所有字符,Greek 块中的除外(否定) |
[\p{L}&&[^\p{Lu}]] | 所有字母,大写字母除外(减去) |
边界匹配器 | |
^ | 行的开头 |
$ | 行的结尾 |
\b | 单词边界 |
\B | 非单词边界 |
\A | 输入的开头 |
\G | 上一个匹配的结尾 |
\Z | 输入的结尾,仅用于最后的结束符(如果有的话) |
\z | 输入的结尾 |
Greedy 数量词 | |
X? | X,一次或一次也没有 |
X* | X,零次或多次 |
X+ | X,一次或多次 |
X{n} | X,恰好 n 次 |
X{n,} | X,至少 n 次 |
X{n,m} | X,至少 n 次,但是不超过m 次 |
Reluctant 数量词 | |
X?? | X,一次或一次也没有 |
X*? | X,零次或多次 |
X+? | X,一次或多次 |
X{n}? | X,恰好 n 次 |
X{n,}? | X,至少 n 次 |
X{n,m}? | X,至少 n 次,但是不超过m 次 |
Possessive 数量词 | |
X?+ | X,一次或一次也没有 |
X*+ | X,零次或多次 |
X++ | X,一次或多次 |
X{n}+ | X,恰好 n 次 |
X{n,}+ | X,至少 n 次 |
X{n,m}+ | X,至少 n 次,但是不超过m 次 |
Logical 运算符 | |
XY | X 后跟 Y |
X|Y | X 或 Y |
(X) | X,作为捕获组 |
Back 引用 | |
\n | 任何匹配的 nth捕获组 |
引用 | |
\ | Nothing,但是引用以下字符 |
\Q | Nothing,但是引用所有字符,直到 \E |
\E | Nothing,但是结束从 \Q 开始的引用 |
三、正则表达式的功能说明已经代码演示
1、四大功能说明
◆匹配:String类中的boolean matches(String regex)方法。用规则匹配整个字符串,只要有一处不符合规则,就匹配结束,返回false。
◆切割:String类中的String[]split(String regex)方法。
◆替换: String replaceAll(String regex,String replacement)方法。
◆获取:将字符串中的符合规则的子串取出。
操作步骤:
1)将正则表达式封装成对象。(用Pattern中的静态方法compile()封装成对象)
2)让正则对象和要操作的字符串相关联。(用Pattern中matcher()匹配,并且返回匹配引擎)
3)关联后,获取正则匹配引擎。(获得匹配引擎)
4)通过引擎对符合规则的子串进行操作,比如取出。(利用匹配引擎的find(),和group进行查找和获得结果)
◆根据规则匹配邮箱:
package regular;
public class RegularText3 {
public static void main(String[] args) {
// 给你一个邮箱
String emai = "wujian562687313@qq.com";
// 创建规则并且传入匹配再打印。规则解析:
// 任意4到16字母数字或者下划线,必须还有@,一位或者多位字母一组或者多组:(。字母一组或者多组任意字母)
System.out.println(emai.matches("\\w{4,16}@[a-zA-Z]+(\\.[a-zA-Z]+)+"));
}
}
打印结果:
◆去除叠词的操作:
package regular;
/*
需求:去掉叠词和.
*/
public class Regulartext {
public static void main(String[] args)
{
// 给定一个字符串
String str = "我我。。。我。。。我好。。。想。。。想想。。好想。。。。。陈。。颖颖。。。颖异。。啊啊啊";
test_1(str);
}
public static void test_1(String str)
{
// 创建规则
String reg = "。+";
// 把所有的.去掉
str=str.replaceAll(reg, "");
// 打印去掉后的结果
System.out.println(str);
// 将叠词替换成不是叠词
str=str.replaceAll("(.)\\1+","$1");
// 打印结果
System.out.println(str);
}
}
打印结果:
◆给定一段杂乱IP对其进行处理,这里将用到正则表达式的替换功能:
package regular;
import java.util.Arrays;
/*
需求:将ip地址进行地址段顺序的排序。
思路:还按照字符串自然顺序,只要让它们每一段都是3位即可。
1,按照每一段需要的最多的0进行补齐,那么每一段就会至少保证有3位。
2,将每一段只保留3位。这样,所有的ip地址都是每一段3位。
*/
public class Regulartext2 {
public static void main(String[] args) {
// 给出几段杂乱的IP
String ip= "192.068.0.101 18.5.40.1 15.88.205.10";
// 要进行排序就要进行比较,但是位数不想等,所以先为小段数字前面加两个0
ip = ip.replaceAll("(\\d+)", "00$1");
// 打印加0后的结果
System.out.println(ip);
// 然后让没小段保留三位数
ip = ip.replaceAll("0*(\\d{3})", "$1");
// 打印保留三位的结果
System.out.println(ip);
// 按照一个或者多个空格切割
String s[]=ip.split(" +");
// 数组的自然排序
Arrays.sort(s);
// 打印排序后的结果
System.out.println(s[0]+" "+s[1]+" "+s[2]);
// 去掉前面多余的0
System.out.println(s[0].replaceAll("0*(\\d+)", "$1")+" "+s[1].replaceAll("0*(\\d+)", "$1")
+" "+s[2].replaceAll("0*(\\d+)", "$1"));
}
}
打印结果:
◆获取功能演示:
package regular;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegularText4 {
public static void main(String[] args) {
// 给定一个字符串
String str ="wu jian chen aa ying yi qqq bbb a";
// 建立规则,当为:边界、4个字母、边界,就符合规则
String reg ="\\b[a-zA-Z]{4}\\b";
// 封装成对象
Pattern par = Pattern.compile(reg);
// 关联字符串,获得匹配引擎
Matcher ma = par.matcher(str);
// 开始查找符合规则的数据
while(ma.find())
{
// 获得查找结果并且打印
System.out.println(ma.group());
}
}
}
打印结果:
四、综合例题(网络爬虫)演示
这里以爬人人网的某些数据为例子
package regular;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
需求:自己写连接去网络上找相应规则的数据,这里以人人网的网页为例
*/
public class Crawler {
public static void main(String[] args) throws Exception {
// 解析地址,封装对象,建立连接所需要的资源
URL url =new URL("http://tw.people.com.cn/n/2015/0801/c104510-27396313.html");
// 开始连接,并且获取连接对象
URLConnection uc=url.openConnection();
// 对过连接的对象可以获取输入流
BufferedReader bf = new BufferedReader(new InputStreamReader(uc.getInputStream()));
// 封装规则为对象,
Pattern pat = Pattern.compile("0\\d{3}.\\d+");
String line =null;
// 读取网页信息
while((line=bf.readLine())!=null)
{
// 获取匹配引擎,关联字符串
Matcher mat =pat.matcher(line);
// 开始寻找
while(mat.find())
{
// 显示查找结果
System.out.println(mat.group());
}
}
}
}
结果为:
正则表达式介绍完毕,感谢浏览!