正则表达式：符合一定规则的表达式，用特定符号来表达一些代码。
特点：用于一些特定的符号来表示一些代码操作，这样可以简化书写
作用:专门用于操作字符串。
优点：可以简化对字符串的复杂操作。
缺点：符号定义越多，正则表达式越长，阅读性越差
正则表达式的构造摘要
1. 字符
\\ 反斜线字符
\t 制表符 (‘\u0009‘)
\n 新行（换行）符 (‘\u000A‘)
\r 回车符 (‘\u000D‘)
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]（减去）
3、预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
4、边界匹配器
\b 单词边界
\B 非单词边界
5、Greedy数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n次
X{n,} X，至少 n次
X{n,m} X，至少 n次，但是不超过 m 次
6、组和捕获
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C)))中，存在四个这样的组：
1 ((A)(B(C)))
2 \A
3 (B(C))
4 (C)
组零始终代表整个表达式。在替换中常用$匹配组的内容。
具体操作功能：匹配、切割、替换和获取
匹配：String matches方法。
用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false。
判断一串数字是否是手机号：手机号段只有 13xxx 15xxx 18xxxx
public static void checkTel()
{
String tel = "16900001111";
String telReg = "1[358]\\d{9}";
System.out.println(tel.matches(telReg));
}
判断字符串是否是以字母开头其余全是数字
public static void demo()
{
String str = "b23a23456789";
String reg = "[a-zA-Z]\\d*";
boolean b= str.matches(reg);
System.out.println(b);
}
判断qq是否正确：qq5-15位，不能以0开头，中间也不能有字母
public static void checkQQ()
{
String qq = "123a454";
String regex = "[1-9]\\d{4,14}";
boolean flag = qq.matches(regex);
if(flag)
System.out.println(qq+"...is ok");
else
System.out.println(qq+"... 不合法");
}
切割：String split();
多空格切割：" _+" _表示空格
.点的切割："\."操作
\\ 切割 ："\\\\"操作
叠词的切割："(.)\\1+"来操作，其中(.)是通配符，\\1代表叠一次，后面的+表示叠了多次。
实例：用 \\ 切割c:\\abc\\234\\a.doc
class RegexDemo
{
public static void main(String[] args)
{
splitDemo("c:\\abc\\234\\a.doc","\\\\");
}
public static void splitDemo(String s,String t)
{
String [] arr= s.split(t);
for(String st:arr)
System.out.println(st);
}
}
替换：String replaceAll(regex,str);如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式中的已有的组。
典型的写法 str.replaceAll("(.)\\1+","$1")
实例：
public static void test_1()
{
String str = "我我...我我...我要..要要...要要...学学学....学学...编编编...编程..程. 程程...程...程";
/*
将已有字符串变成另一个字符串。使用 替换功能。
1,可以先将 . 去掉。
2，在将多个重复的内容变成单个内容。
*/
str = str.replaceAll("\\.+","");
System.out.println(str);
str = str.replaceAll("(.)\\1+","$1");
System.out.println(str);
}
获取:将字符串中的符合规则的子串取出。
操作步骤：
1，将正则表达式封装成对象。 Pattern p = Pattern.compile(reg);
2，让正则对象和要操作的字符串相关联。 Matcher m = p.matcher(str);
3，关联后，获取正则匹配引擎。 while( m.find())
4，通过引擎对符合规则的子串进行操作， { m.group(); } 伪代码
比如取出。
实例：获取ming tian jiu yao fang jia le ,da jia。 中4个字母的单词
import java.util.regex.*;
class RegexDemo2
{
public static void main(String[] args)
{
getDemo();
}
public static void getDemo()
{
String str = "ming tian jiu yao fang jia le ,da jia。";
System.out.println(str);
String reg = "\\b[a-z]{4}\\b";
//将规则封装成对象。
Pattern p = Pattern.compile(reg);
//让正则对象和要作用的字符串相关联。获取匹配器对象。
Matcher m = p.matcher(str);
while(m.find())
{
System.out.println(m.group());
System.out.println(m.start()+"...."+m.end());//返回索引位置
}
}
}
其中group(),start(),end()所带的参数i就是正则表达式中的子表达式索引（第几个子表达式）
用法总结：
1.只想知道字符串对错（判断）用匹配
2.将字符串变为另一个字符串 用替换
3.将字符串按规则获取成多个子串 用分割
4.想获取字符串中的一部分 用获取
网页爬虫实例：
/*
网页爬虫(蜘蛛)
实际上是一个功能，用于搜集网络上的指定信息
需求：可用于收集邮箱等信息。
应用：如通过关键字搜索，实际就是使用“蜘蛛”，通过查找关键字获取相关的信息
*/
import java.io.*;
import java.util.regex.*;
import java.net.*;
import java.util.*;
class RegexTest2
{
public static void main(String[] args) throws Exception
{
getMails_1();
}
public static void getMails_1()throws Exception
{
URL url = new URL("http://192.168.1.254:8080/myweb/mail.html");
URLConnection conn = url.openConnection();
BufferedReader bufIn = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line = null;
String mailreg = "\\w+@\\w+(\\.\\w+)+";
Pattern p = Pattern.compile(mailreg);
while((line=bufIn.readLine())!=null)
{
Matcher m = p.matcher(line);
while(m.find())
{
System.out.println(m.group());
}
}
}
/*
获取指定文档中的邮件地址。
使用获取功能。Pattern Matcher
*/
public static void getMails()throws Exception
{
BufferedReader bufr =
new BufferedReader(new FileReader("mail.txt"));
String line = null;
String mailreg = "\\w+@\\w+(\\.\\w+)+";
Pattern p = Pattern.compile(mailreg);
while((line=bufr.readLine())!=null)
{
Matcher m = p.matcher(line);
while(m.find())
{
System.out.println(m.group());
}
}
}
}