Java中的正则表达式

一、正则表达式概述

        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进行查找和获得结果）

2、代码演示

◆根据规则匹配邮箱：

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());
				
			}
		
		}
	}
}

结果为：

正则表达式介绍完毕，感谢浏览！