黑马程序员-基础-正则表达式

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

正则表达式：符合一定规则的表达式。

作用：用于专门操作字符串。

特点：用于一些特定的符号来表示一些代码操作。这样就简化了书写。

所以学习正则表达式，就是在学习一些特殊符号的使用。

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

弊端：符号定义越多，正则越长，阅读性越差。

正则表达式常用符号：

一 字符

 构造 匹配

 x 字符x

 \\ 反斜线字符

 \t 制表符

 \n 新行(换行)符

 \f 换页符

 \r 回车符

二 字符类

[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]（并集）

三）预定义字符类

.                                     任何字符（与行结束符可能匹配也可能不匹配）

\d                                   数字： [0-9]

\D                                  非数字：  |^[0-9]

\s                                  空白字符：[ \t\n\x0B\f\r]

\S                                  非空白字符：[^ \t\n\x0B\f\r]

\w                                  单词字符：[a-zA-Z_0-9]

\W                                  非单词字符：[^\w]

四）边界匹配器

^                                  行的开头

$                                  行的结尾

\b                                  单词边界

\B                                  非单词边界

\A                                  输入的开头

五）Greedy数词量---->匹配整个字符串

X?                                  X，一次或一次也没有

X*                                  X，零次或多次

X+                                  X，一次或多次

X{n}                               X，恰好n次

X{n,}                             X，至少n次

X{n,m}                         X，至少n次，但不超过m次

六）组和捕获

捕获组可通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：

1	((A)(B(C)))
2	\A
3	(B(C))
4	(C)

组零始终代表整个表达式。

正则表达式主要有四种具体功能：匹配、切割、替换和获取。

1.匹配：String matches方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false

代码事例如下

class  RegexDemo
{
	public static void main(String[] args) 
	{
		checKtel();//调用匹配手机号码的方法
		checKqq();//调用匹配QQ号码校验方法
	}
/*
匹配手机号段只有 13xxx 15xxx 18xxx
*/
	public static void checKtel()
	{
		String tel="13000015247";//输入任意号码看是否满足要求
		String telReg="1[358]\\d{9}";//通过正则字符进行匹配
		System.out.println(tel.matches(telReg));//通过matches方法打印

	}
	/*
	对QQ号码进行校验
	要求：5~15  0不能开头，只能是数字
	*/
	
	public static void checKqq()
	{
		String qq="123456";//输入号码看是否满足要求
		//第一个号码1-9范围，第二号码\\d是0-9的范围，{4,14}意思是第一个确定了，最少还需要舒服4个号码，最多输入14个号码了
		String regex="[1-9]\\d{4,14}";

		boolean flag=qq.matches(regex);//判断是否满足regex，是执行if，否执行else
		if(flag)
			System.out.println(qq+"...正确的");
		else
			System.out.println(qq+"...不合格");


	}

2.切割：String split();

代码事例如下

class  RegexDemo1
{
	public static void main(String[] args) 
	{	
		splitDemo_1();//无参数的
		splitDemo("zhangsan.lisi.wangwu","\\.");//通过\\.中的点进行切割
		splitDemo("c:\\abc\\a.txt","\\\\");//通过\\\\进行切割
		splitDemo("erkktyqqquizzzzzo","(.)\\1+");//按照叠词完成切割。为了可以让规则的结果被重用
												//可以将规则封装成一个组。用()完成。组的出现都有编号。
												//从1开始。 想要使用已有的组可以通过  \n(n就是组的编号)的形式来获取。

	
		
	}
	public static void splitDemo(String str,String reg)//有参数
	{
		String[] arr=str.split(reg);//调用split方法
		System.out.println(arr.length);//打印切割个数
		for (String s: arr)//用高级for循环进行切割
		{
			System.out.println("切割"+s);
		}
	}
	public static void splitDemo_1()//无参数
	{
		String str="zhangsan  lisi   wangwu";
		String reg=" +";//按照多个空格切割
		String[] arr=str.split(reg);//调用split方法
		System.out.println(arr.length);//打印切割个数
		for (String s: arr)
		{
			System.out.println("切割1"+s);//用高级for循环进行切割
		}
	}
}

3.替换：String replaceAll(regex,str);如果regex中定义组，可以在第二参数中通过$符号获取正则表达式中已有的组

代码例子如下：

class RegexDemo2 
{
	public static void main(String[] args) 
	{
		String str="asdassada156465465sdfas454sf1";
		//把str中的内容用"\\d{5,}"方法替换成#
		//"\\d{5,}"意思是\d是在0到9内,{5,}意思是五位以上。所以"\\d{5,}"是五位以上0到9的数字都替换成一个#
		replaceAllDemo(str,"\\d{5,}","#");//将字符串中的数字替换成#

		String str1 = "erkktyqqquizzzzzo"; 
		replaceAllDemo(str1,"(.)\\1+","#");//将叠词替换成#. 
		replaceAllDemo(str1,"(.)\\1+","$1");//将重叠的字符替换成单个字母。zzzz->z 用替换符$1


	}


	//str本来的内容。reg规则,就是给定的方法 。newStr替换的内容
	public static void replaceAllDemo(String str,String reg,String newStr)
	{
		str = str.replaceAll(reg,newStr);//用替换方法进行替换
		System.out.println("替换过的str的内容："+str);//打印内容
	}
}

4.获取：将字符串中的符合规则的子串取出。

操作步骤：

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

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

3，关联后，获取正则匹配引擎。

4，通过引擎对符合规则的子串进行操作，比如取出。

代码事例如下：

import java.util.regex.*;
class  RegexDemo3
{
	public static void main(String[] args) 
	{
		getDemo();
	}
	public static void getDemo()
	{
		String str ="ming tian  jiu yao qu shang xue le";//定义字符串
		System.out.println("str");//先打印一次字符串
		String reg ="\\b[a-z]{4}\\b";//定义方法满足要求就获取出来
		
		//Pattern类没有构造方法不能创建对象，只能用方法调用封装成对象.
		Pattern p = Pattern.compile(reg);

		//让正则对象和要作用的字符串相关联。获取匹配器对象
		Matcher m =p.matcher(str);

		//System.out.println(m.matches());//其实String类中的matches方法。用的就是Pattern和Matcher对象来完成的。
										//只不过被String的方法封装后，用起来较为简单。但是功能却单一。
		
			/*
			//第一次查找符合要求的么，符合了进行第二次。以此循环，所以用while如下：
			boolean b = m.find();//将规则作用到字符串上，并进行符合规则的子串查找。
			System.out.println(b);
			System.out.println(m.group());//用于获取匹配后结果。

			//System.out.println("matches:"+m.matches());

			*/
		while(m.find())//循环子串查找
		{
			System.out.println(m.group());//用于获取匹配后结果并打印
			System.out.println(m.start()+"...."+m.end());//打印切割的字符串所在位置顺序，包含头不包含尾
		}


	}
}

到底用四种功能中的哪一个呢？或者哪几个呢？

 思路方式：

 1，如果只想知道该字符是否对是错，使用匹配。

 2，想要将已有的字符串变成另一个字符串，替换。

 3，想要按照自定的方式将字符串变成多个字符串。切割。获取规则以外的子串。

 4，想要拿到符合需求的字符串子串，获取。获取符合规则的子串。

代码事例如下:

练习1

/*
需求1：将下列字符串转成：我要学编程
*/
class RegexTest 
{
	public static void main(String[] args) 
	{
		test_1();//调用方法查看
	}
		/*
		思路：将已有字符串变成另一个字符串。使用 替换功能。
		1,可以先将 . 去掉。
		2，在将多个重复的内容变成单个内容。
		*/

	public static void test_1()
	{
		String str = "我我..我我..我要要...要要....要要学..学学学....学学学编编...编编编程..程程程..程程程";
		str = str.replaceAll("\\.","");//替换掉.符号变成空字符串
		System.out.println("Str="+str);//打印看效果

		str= str.replaceAll("(.)\\1+","$1");//替换掉叠字
		System.out.println("str="+str);//打印看效果
	}
}

练习2

$1意思是拿要替换的那个内容重叠的全部如：00012    替换写成 $1代表就是拿走000。有几个0就拿走几个的意思

/*
	192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30
	将ip地址进行地址段顺序的排序。

	还按照字符串自然顺序，只要让它们每一段都是3位即可。
	1，按照每一段需要的最多的0进行补齐，那么每一段就会至少保证有3位。
	2，将每一段只保留3位。这样，所有的ip地址都是每一段3位。


*/
import java.util.*;
class RegexTest1 
{
	public static void main(String[] args) 
	{
		ipSort();
	}
	public static void ipSort()
	{
		String ip = "192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30";

		ip = ip.replaceAll("(\\d+)","00$1");//给没给元素前面添加两个0
		System.out.println(ip);//打印看效果

		ip = ip.replaceAll("0*(\\d{3})","$1");//去到三个元素前面的0
		System.out.println(ip);//打印看效果

		String[] arr = ip.split(" ");//切割字符串

		TreeSet<String> ts = new TreeSet<String>();//用TreeSet进行排序

		for(String s : arr)//遍历数组
		{
			ts.add(s);//添加到集合中
		}

		for(String s : ts)//遍历集合
		{
			System.out.println(s.replaceAll("0*(\\d+)","$1"));//打印并替换掉开头的0
		}
	}
}

练习3

/*
	需求：对邮件地址进行校验。

	*/
	public static void checkMail()
	{
		String mail = "abc12@sina.com";

		mail = "1@1.1";

		String reg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";//较为精确的匹配。
		reg = "\\w+@\\w+(\\.\\w+)+";//相对不太精确的匹配。

		//mail.indexOf("@")!=-1//只要符合@就可以


		System.out.println(mail.matches(reg));
	}

网页爬虫

/*
网页爬虫(蜘蛛)
*/
import java.io.*;
import java.util.regex.*;
import java.net.*;
import java.util.*;
class RegexTest3 
{
	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());
			}
		}
	}
	*/
}