黑马程序员——学习日记之--正则表达式总结

——- android培训、java培训、期待与您交流！ ———-

1—正则表达式介绍

正则表达式的概念：

– 正则表达式就是符合一定规则的字符串表达式。

作用：正则表达式用于处理字符串文本，对匹配、搜索和替换等操作都有意想不到的作用。

好处：简化对字符串的复杂操作。

正则表达式的功能：

字符类：可以直接匹配字符

[abc]　　　　　　简单返回目录　　只能是啊a,b,c中的一个。

[^abc]　　　　　否定返回目录　　除a,b,c以外的任何一个字符，包括数字和符号等。

[a-zA-Z]　　　　范围返回目录　　表示所有字母。也可以写成 [a-z_A-Z] 。

[a-f[n-x]]　　　　并集返回目录　　表示a~f和n~x的并集。

[a-n&&[def]]　　交集返回目录　　表示交集，重合字符的任意一个。

[a-z&&[^bc]]　　差集返回目录　　表示交集，a或者d-z任一个。

　　注意：

　一个方括号”[]”只代表一个字符的正则规则。

　“{}”中的数字以及数字范围代表它前面的那个字符重复多少次。

预定义字符类：可以直接匹配字符类型

. 　　　 任何字符

\d　　　任何数字

\D 　　　任何非数字

\s 　　　任何空白字符

\S 　　　任何非空白字符

\w　　　任何单词字符：字母+数字

\W　　　任何非单词字符

注意：

如果是在字符串中，反斜线要转义。

边界匹配器：用于匹配边界

^ 　　行的开头

$　　 行的结尾

\b　　单词边界

\B 　　非单词边界

Greedy 贪婪量词：字符数量的一种匹配模型

X? 　　　一次或一次也没有

X+　　　一次或多次

X* 　　　零次或多次

X{n} 　　恰好n次

X{n,}　　至少n次

X{n,m} 　n-m次

Reluctant 勉强量词：在Greedy数量词后加”?”.

Possessive 侵占量词：在Greedy数量词后加”+”.

三个量词的区别：

Greedy 贪婪量词会强迫匹配器读取整个字符串去匹配，如果匹配不成功，就从右侧舍弃一个字符再次匹配，

直到舍弃完。

Reluctant勉强量词会从左往右一个一个勉强读取，如果匹配不成功，就继续往右侧再读取一个字符，直到全部读取。

Possessive侵占量词先读取全部字符，匹配不成功也不会舍弃字符。

三者的区别就是对字符串的操作规则不同。

组的概念：

“()”括起来的内容代表被封装成组，封装成组之后可以通过组的标号进行调用。

如：”(\d)\1+” 代表多个重复数字， 111,222222 都是符合这个要求的。

也可以通过”$1”调用第一组的内容。

　例如，以下正则表达式：

String regex1=”[a-z]\d?”; //一个小写字母，一个或零个数字。

String regex2=”[a-z]\d+”; //一个小写字母，一个或多个数字。

String regex3=”[a-z]\d*”; //一个小写字母，零个或多个数字。

String regex4=”1[358]\d{9}”; //第一个数字固定为1，第二个数字只能是3,5,8中的一个，后面九个数字。

2—字符串的匹配

匹配字符串就是用一个正则规则校验指定的字符串是否和这个规则吻合。

如果符合这个规则，就返回true，如果不符合，就返回false。

举例1：匹配字符串

对QQ号码进行校验。要求5~12位，0不开头，全数字。

class Demo
{
public static void main(String [] args)
{
String qq="1234567890";
String regex="[1-9][0-9]{4,11}"; //第一个数字1-9，第2-15个数字是0-9中的任一个。
boolean bool = qq.matches(regex);//matches方法，用规则匹配整个字符串只要有一处不符合规则，就匹配结束。
if (bool)
System.out.println(qq+"正确");
else
System.out.println(qq+"错误！！");
}
}

举例2：对邮箱地址进行校验。

class Demo
{
public static void main(String [] args)
{
String s="za0010@163.com";
checkMail(s);
}
public static void checkMail(String s)
{
String reg="\\w{6,12}@\\w{2,5}(\\.[a-zA-Z]{2,4}){1,3}";
System.out.println(s.matches(reg));
}
}

3—字符串的切割

字符串通过一定的规则切割字符串。

例如，多个空格，叠词。

切割通过字符串的方法:

String []  str.split(regex);

举例1：切割字符串

class SplitString
{
public static void main(String [] args)
{
splitString("nihao hello    haha"," +");//以一个或多个空格为切割点。
splitString("nihao.hello.haha","\\.");  //双反斜杠代表一个反斜杠，然后用一个反斜杠转义点。
splitString("c:\\123\\aaa.txt","\\\\"); //四个反斜线表示两个反斜线，然后切割字符串。
splitString("erkkfdhqqbhzzf","(\\.)1"); //按照叠词完成切割。后一个和前一个相同。
splitString("abbcddghhhn","(.)\\1+");   //按照叠词完成切割。后多个和前一个相同。
}
public static void splitString(String s,String reg)
{
String [] arr=s.split(reg);
for (String a : arr)
{
System.out.println(a);
}
}
}

注意：作为切割点的字符如果代表着特殊含义，就必须要转义。

举例2：切割字符串

将简写IP地址补成三位数字的IP。

class demo
{
String ip="102.49.23.13   10.10.10.10  2.2.2.2  8.109.90.30 27.101.99.11";
ip=ip.replaceAll("(\\d+)","00$1");     //将每段数字前面都加两个零。
ip=ip.replaceAll("0*(\\d{3})","$1");   //将每段数字都只保留后三位。
String [] arr=ip.split(" +");
for (String s : arr)
{
System.out.println(s);
}
}

4—字符串的替换

用一定的规则去替换字符串中的某些子串。

替换也要通过字符串的方法：

String  str.replaceAll(regex,s);    //s指的是要替换成的字符串

举例1：字符串的替换

class Demo
{
public static void main(String [] args)
{
String s1="dhg123isj4657dgk8900sngkfvandfg";
String regex1="(\\d)+";
System.out.println(replace(s1,regex1,"#"));

String s2="wggbiwgggbnfsnffffffijsnGKKKSNJDDDM";
String regex2="(\\w)\\1+";
System.out.println(replace(s2,regex2,"$1"));//$1 是获取第一组的内容。
}
public static String replace(String s,String regex,String str)
{
return s.replaceAll(regex,str);
}
}

注意：正则表达式中出现括号括起来的组之后，可以通过”$n“获取第几组的内容。

整个字符串默认是第0 组，第一个括号出现就是第一组，第几个括号就是第几组。

举例2： 字符串的替换

字符串”哈哈…哈…哈哈喽…喽喽…喽…喽…你你…你你你…好好…好…好…好啊…啊啊啊…啊”

将字符串转成：哈喽你好啊

class Demo
{
public static void main(String [] args)
{
String s="哈哈...哈...哈哈喽...喽喽...喽...喽...你你...你你你...好好...好...好...好啊...啊啊啊...啊";
//s=s.replace("...","");        //将字符串中的标点去掉的简单方法。
s=s.replaceAll("(\\.){3}","");  //将标点去掉的正则方法。
System.out.println(s);          //打印无标点的字符串。
s=s.replaceAll("(.)\\1+","$1"); //将叠词去重复的正则方法。
System.out.println(s);          //打印无叠词的字符串。
}
}

5—字符串的获取

字符串获取的定义：

　　将字符串中符合规则的子串取出。

字符串获取的步骤：

1. 将正则表达式封装成正则对象。

2. 让正则对象和要操作的字符串相关联。

3. 然后获取正则匹配器。

4. 通过引擎对符合规则的子串进行操作。

获取要用util里的regex 包，包含两个类：

Pattern： 正则模式

(1)Pattern是final类。

(2)它表示一个已经编译的正则表达式。

(3)它不可以new对象，需要调用公共的静态compile方法返回一个Pattern对象。

(4)然后可以用得到的模式去创建 Matcher 对象。

常用方法：

String  Pattern()           //返回模式中的正则表达式字符串
static Pattern  compile(reg)//将给定的正则表达式编译到模式中
Matcher  matcher(s)         //创建 Matcher 匹配器

Matcher ：匹配器

(1)通过正则对象，对字符串执行匹配操作的匹配器。

(2)Matcher 也没有构造方法，不可以new对象。

(3)需要调用Pattern对象的matcher方法获得一个Matcher对象。

　注意： Matcher 对象是通过Pattern对象的方法得到的，不是在本对象中得到的。

常用方法：

int start()         //返回以前匹配的初始索引
int end()           //返回最后匹配字符之后的偏移量
boolean find()      //尝试查找与该模式匹配的下一个序列
String group()      //返回匹配到的序列
boolean matches()   //尝试将整个区域与模式匹配, String 用的就是这个模式
Matcher reset()     //重置匹配器

举例说明模式和匹配器的应用规则。

import java.util.regex.*;
class Demo
{
public static void main(String [] args)
{
String s="wo yao nu li xue xi java.";
String reg="\\b(\\w){3}\\b";
Pattern p=Pattern.compile(reg); //返回一个经过编译的正则表达式对象。
Matcher m=p.matcher(s);         //创建字符串的匹配器，，并返回一个匹配器。

while (m.find())                //find 返回是否有能匹配的子串。
{
System.out.println(m.group());  //获取匹配后的结果。
System.out.println(m.start()+"++"+m.end()); //打印此匹配器的开始和结尾。
}
}
}