标签：正则表达式
1.什么叫做正则表达式?
作用：用于专门操作字符串
特点：用一些特定的符号来表示一些代码操作
好处：可以简化对字符串的复杂操作
弊端:符号定义的越多，正则越长，阅读性越差
[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]
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，作为捕获组
如果要对一段字符进行重复,就需要有用到分组,分组在正则中用”()“表示.然后后面可以对这个组进行重复
引用.例如(123) 123就是一个组.
分组有两种概念,非捕获组和捕获组
捕获组 ( )
每一个捕获组都会有编号,这个编号是从左至右通过括号来计算的.例如
(A(B)(CD))
第1组:(A(B)(CD))
第2组:(B)
第3组:(CD)
在正则表达式中可以对捕获组进行引用。
下面写一个对捕获组进行引用的例子
选取靓号 数字全部相同的号码(AAAAAA)
(\d)\1{6,}
首先会获取第一位为0-9的数字,然后\1引用第一组里面内容然后重复6次或者6次以上.
说明
每一对括号会分配一个编号，使用 () 的捕获根据左括号的顺序从 1 开始自动编号。捕获元素编号为零的第一个捕获是由整个正则表达式模式匹配的文本。
非捕获组(?:xxx)
以 (?) 开头的组是纯的非捕获 组，它不捕获文本 ，也不针对组合计进行计数。就是说，如果小括号中以?号开头，那么这个分组就不会捕获文本，当然也不会有组的编号，因此后面也不能引用。
表达式 方向 说明
(?=xxx) 正向预搜索（向右） 正向预搜索，判断当前位置右侧是否能匹配指定表达式
(?!xxx) 正向预搜索（向右） 正向预搜索否定，判断当前位置右侧是否不能够匹配指定表达式
(?<=xxx) 反向预搜索（向左） 反向预搜索，判断当前位置左侧是否能够匹配指定表达式
(?
与普通分组不同的是，非捕获组不记录所匹配的内容，比普通分组更节约内存资源。
例子:
(?<=2)88(?88前面是2后面不能是3
2884 匹配
3882 不匹配
String s = "aaaabbbbbbxcxxxxxcccc";//组：这个字符串本身就是第0组
s = s.replaceAll("(.)\\1+","$1");//$可以获取组，$1获取到的就是第1组
package 正则表达式;
/**
* 1.匹配功能：String matches方法，用一个正则表达式匹配 整个字符串。匹配成功返回true，否则返回false
*
* 2.字符串切割：String split方法，
*
* 3.替换功能：String replaceAll方法
*
* 4.获取功能：将字符串中的符合规则的子串取出
*
* @author Administrator
*
*/
public class RegexDemo {
public static void main(String[] args) {
checkQQ("01234");
checkQQ("123456");
splitStr("zhangsan lisi wangwu"," ");
splitStr("zhangsan lisi wangwu"," +");
splitStr("c:\\a\\b.txt","\\\\");
splitStr("asdhgasjdhgahhasdadoassoeporqpdc","(.)\\1");//叠词切割,
splitStr("asdhgasjdhgahhaaaassdadoassssssoeporqpdc","(.)\\1+");//叠词切割,
replaceAll("adasd3254234523445fgdd12131234fdgder344sdf3","#","\\d{5,}");//把数字在5位以上的替换成#号
//将叠词替换成当前组内的元素,$符号可以换取组
replaceAll("aaaabbbbbbxcxxxxxcccc","$1","(.)\\1+");
}
//替换字符串
public static void replaceAll(String s ,String newStr, String regex){
s = s.replaceAll(regex, newStr);
System.out.println(s);
}
//切割字符串
public static void splitStr(String s , String regex){
String[] strr = s.split(regex);
System.out.println(strr.length);
for(String s1 : strr){
System.out.println(s1);
}
}
//匹配字符串
public static void checkQQ(String checkStr){
final String regex = "[1-9]\\d{4,14}";
boolean flag = checkStr.matches(regex);
if(flag){
System.out.println("通过验证:"+checkStr);
}else{
System.out.println("验证失败");
}
}
}
package 正则表达式;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 4.获取功能：将字符串中的符合规则的子串取出
* @author Administrator
*
*/
public class RegexDemo2 {
public static void main(String[] args){
//getStr("12343234","[1-9][0-9]{4,14}");
getStr("ming tian shi xing qi si , wo men qu kan dian ying ba ","\\b[a-zA-Z]{3}\\b");//每个单词匹配一次正则取出
}
public static void getStr(String str , String regex){
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(str);
//System.out.println(m.matches());//判断是否匹配，这个方法是最原始的正则匹配方法，String类中使用方法就是该
//这两个对象封装的方法
//获取与正则匹配的字符串
while(m.find()){//判断是否存在下一个与正则匹配的字符子串
System.out.println(m.group());//获取与正则匹配的子串
}
}
}
package 正则表达式;
import java.util.Arrays;
public class RegexIPSort {
//采用正则表达式对以上网络地址进行排序
public static void main(String[] args){
String ip = "192.168.1.152 192.168.1.135 10.59.15.5 36.25.69.3 2.2.2.2 6.6.6.6 125.12.35.35";
ip = ip.replaceAll("(\\d+)", "00$1");
ip = ip.replaceAll("0*(\\d{3})", "$1");
String[] ips = ip.split(" +");
Arrays.sort(ips);
for(String ip1 : ips){
System.out.println(ip1.replaceAll("0*(\\d+)", "$1"));
}
}
}
package 正则表达式;
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;
/**
* 网页爬虫
*
* @author Administrator
*
*/
public class 网页爬虫 {
public static void main(String[] args) throws Exception {
//BufferedReader br = new BufferedReader(new FileReader(
// "C:\\Users\\Administrator\\Desktop\\email.txt"));
URL url = new URL("http://www.baidu.com");
URLConnection conn = url.openConnection();
BufferedReader bin = new BufferedReader(new InputStreamReader(conn.getInputStream()));
//String regex = "\\w+@\\w+(\\.\\w+)+";
String regex = "(http(s)://)?(\\w+)?\\.\\w+(\\.\\w+)+([:\\w&?!\\()%$#@])+";
Pattern p = Pattern.compile(regex);
String line;
while ((line = bin.readLine()) != null) {
// System.out.println(line);
Matcher m = p.matcher(line);
while (m.find()) {
System.out.println(m.group());
}
}
}
}
标签：正则表达式
原文地址：http://blog.csdn.net/u010218226/article/details/45226985
