黑马程序员——Java基础——正则

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

package cn.fuxi._03regex;
/**
 * 正则表达式.
 * 
 * 正则表达式用于操作字符串数据.
 * 通过一些特定的符号来体现的.
 * 所以我们为了掌握正确的表达式,必须要学习一些符号.
 * 虽然简化了,但是阅读性差.
 */

public class _01RegexDemo {
	public static void main(String[] args) {
		String qq = "1234567890";
		checkQQ(qq);
		System.out.println("-----------------");
		//正则表达式.
		String regex = "[1-9][0-9]{4,14}";
		boolean b = qq.matches(regex);
		System.out.println(qq+":"+b);
	}
	/*
	 * 需求:定义一个功能对qq好进行校验.
	 * 需求:长度5~15,只能死数字,0不能开头. 
	 */
	public static void checkQQ(String qq){
		int len = qq.length();
		if(len>=5 && len<=15){
			if(!qq.startsWith("0")){
				try{
					long l = Long.parseLong(qq);
					System.out.println(l+":正确");
				}catch(NumberFormatException e){
					System.out.println(qq+":含有非法字符");
				}
			}else{
				System.out.println(qq+":不能以0开头");
			}
		}else {
			System.out.println(qq+":长度错误");
		}
	}
}

输出结果：

1234567890:正确
-----------------
1234567890:true

package cn.fuxi._03regex;
/**
 * 正则表达式常用构造摘要
 * 
 * 字符类
 * [abc]a,b或c(简单类)
 * [^abc]任何字符,除了a,b,c
 * [a-zA-Z]a到z或A到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次
 * 
 * 边界匹配器
 * ^行的开头
 * &行的结尾
 * \b单词边界
 * \B非单词边界
 * \A输入的开头
 * \G上一个匹配的结尾
 * \Z输入的结尾,仅用于最后的结束符(如果有的话)
 * \z输入的结尾
 */

public class _02RegexDemo02 {
	public static void main(String[] args) {
		String str = "aoob";
		String reg = "ao?b";//o出现了0次或一次?否,两次
		boolean b = str.matches(reg);
		System.out.println(str+":"+b);
		
		reg = "ao+b";
		b = str.matches(reg);//o出现了一次以上?是,两次
		System.out.println(str+":"+b);

		str="ab";
		reg = "ao+b";//o出现了一次以上?否,0次
		b=str.matches(reg);
		System.out.println(str+":"+b);
		
		str = "ab";
		reg = "ao*b";//o出现了0次或多次?是,0次
		b = str.matches(reg);
		System.out.println(str+":"+b);
		
		str="aoooooooooob";
		reg = "ao{4,}b";//o出现了4次以上?是,10次
		b = str.matches(reg);
		System.out.println(str+":"+b);

		reg = "ao{4,6}b";//o出现了4次到6次?否,10次
		b = str.matches(reg);
		System.out.println(str+":"+b);		
	}
}

输出结果：

aoob:false
aoob:true
ab:false
ab:true
aoooooooooob:true
aoooooooooob:false

package cn.fuxi._03regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 正则表达式常见功能:匹配,切割,替换,获取
 */

public class _03RegexDemo03 {
	public static void main(String[] args) {
		functionDemo_01();
		System.out.println("------------------");
		functionDemo_02();
		System.out.println("------------------");
		functionDemo_03();
		System.out.println("------------------");
		functionDemo_04();
		System.out.println("------------------");
		functionDemo_05();
		System.out.println("------------------");
		functionDemo_06();
		System.out.println("------------------");
		functionDemo_07();	
	}
	/*
	 * 正则表达式对字符串的常见操作
	 * 1.匹配
	 * 		其实使用的就是String类中的matches方法. 
	 * 2.切割
	 * 		其实使用的就是String类中的split方法.
	 * 3.替换
	 * 
	 * 4.获取
	 */
	//匹配
	public static void functionDemo_01(){
		//匹配手机号码是否正确
		String tel = "15088888088";
		String reg = "1[3578]\\d{9}";//"\\"表示一个\
		boolean b = tel.matches(reg);
		System.out.println(tel+":"+b);
		
	}
	//切割
	public static void functionDemo_02(){
		String str = "zhangsan    xiaoqiang    wangwu   ";
		String[] names = str.split(" +");
		for(String name:names){
			System.out.println(name);
		}
	}
	public static void functionDemo_03(){
		String str = "hangmeimei.wentianxiang.xiaoming";
		String[] names = str.split("\\.");
		for(String name:names){
			System.out.println(name);
		}
	}
	/*
	 *在表达式((A)(B(C)))中,存在四个这样的组:
	 *1	((A)(B(C)))
	 *2	\A
	 *3	(B(C))
	 *4	(C)
	 *组零始终代表整个表达式.
	 */
	public static void functionDemo_04(){
		String str = "zhangsantttxiaoqingmmmmmmzhaoliu";
		//(.)表示一组.\\1+表示与第一组相同的出现1次以上
		String[] names = str.split("(.)\\1+");
		for(String name:names){
			System.out.println(name);
		}
	}
	//演示替换
	public static void functionDemo_05(){
		String str = "zhangsantttxiaoqingmmmmmmzhaoliu";
		//$表示抢一个参数的第一组
		str = str.replaceAll("(.)\\1+", "$1");
		System.out.println(str);
	}
	public static void functionDemo_06(){
		String str="15800001111";
		str = str.replaceAll("(\\d{3})(\\d{4})(\\d{4})", "$1****$2");
		System.out.println(str);
	}
	/*
	 * 演示获取
	 * 将正则规则经行对象的封装.
	 * Pattern p = Pattern.compile("a*b");
	 * 通过正则对象的matches方法字符串相关联.获取要对字符串操作的匹配器对象Matcher.
	 * boolean b = m.matches(); 
	 */
	public static void functionDemo_07(){
		String str = "da jia hao,ming tian bu shang ke";
		//\\b表示单词边界
		String regex = "\\b[a-z]{3,}\\b";//由三个小写字母构成的
		//1.将正则封装成对象
		Pattern p = Pattern.compile(regex);
		//2.通过正则对象获取匹配器对象
		Matcher m = p.matcher(str);
		//使用Matcher对象的方法对字符串经行操作
		//既然要获取三个字母组成的单词.
		//查找:find();
		while(m.find()){
			System.out.println(m.group());//获取匹配的子序列
			System.out.println(m.start()+":"+m.end());
		}
	}
}
/*
 * P.S.
 * 		Pattern类为正则表达式的编译表示形式.指定为字符串的正则表达式必须首先被编译为此类的实例.
 * 然后,可将得到的模式用于创建Matcher对象,依照正则表达式,该对象可以与任意字符序列匹配.执行匹配
 * 所涉及的所有状态都驻留在匹配器中,所以多个匹配器可以共享同一模式.
 */

输出结果：

15088888088:true
------------------
zhangsan
xiaoqiang
wangwu
------------------
hangmeimei
wentianxiang
xiaoming
------------------
zhangsan
xiaoqing
zhaoliu
------------------
zhangsantxiaoqingmzhaoliu
------------------
158****0000
------------------
jia
3:6
hao
7:10
ming
11:15
tian
16:20
shang
24:29

package cn.fuxi._03regex;

import java.util.TreeSet;

/*
 * 1.治疗口吃:我我...我我..我我我哦我..要要要....要要要要..要要..学学学学学...学学学学编编编....编...编...编编.程...程..程程..程程程 
 * 2.对ip地址排序
 * 3.对邮件地址校验
 */
public class _04RegexTest01 {
	public static void main(String[] args) {
		test01();//治疗口吃
		test02();//对ip地址排序
		test03();//对邮箱地址校验
	}
	public static void test01(){
		String str = "我我...我我..我我我我..要要要....要要要要..要要..学学学学学...学学学学编编编....编...编...编编.程...程..程程..程程程";
		//1.将字符串中的点去掉,用替换
		str = str.replaceAll("\\.+", "");
		//2.替换叠词
		str = str.replaceAll("(.)\\1+", "$1");
		System.out.println(str);
	}
	/*
	 * ip地址排序.
	 * 192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55 
	 */
	public static void test02(){
		String ip = "192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55";
		System.out.println(ip);
		//1.为了让ip可以按照字符串顺次比较,只要让ip的每一段的位数相同.
		//所以,补零,按照每一位所需最多0进行补充,每一段都加两个0.
		
		ip = ip.replaceAll("(\\d+)", "00$1");
		//然后每一段保留数字后三位
		ip = ip.replaceAll("0*(\\d{3})", "$1");
		//2.将ip地址切割出来
		String[] ips = ip.split(" +");
		//3.用TreeSet装入,并自然排序
		TreeSet<String> ts = new TreeSet<String>();
		for(String ip1 : ips){
			ts.add(ip1);
		}
		for(String ip1:ts){
			System.out.println(ip1.replaceAll("0*(\\d+)", "$1"));
		}
	}
	//对邮箱地址校验
	public static void test03(){
		String mail = "abc@sina.com";
		String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+([\\.[a-zA-Z]{1,3}])+";
		boolean b = mail.matches(regex);
		System.out.println(mail+":"+b);
	}
}

输出结果：

我要学编程
192.168.10.34 127.0.0.1 3.3.3.3 105.70.11.55
3.3.3.3
105.70.11.55
127.0.0.1
192.168.10.34
abc@sina.com:true

package cn.fuxi._03regex;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 爬虫
 * 网页爬虫:其实就是一个应用程序用于在互联网中获取符号指定规则的数据.
 * 爬取邮箱地址.
 */
public class _05RegexTest02 {
	public static void main(String[] args) throws IOException {
		List<String> list = getMails();
		for(String mail:list){
			System.out.println(mail);
		}
	}
	public static List<String> getMails() throws IOException{
		//1.读取源文件.
		BufferedReader br = new BufferedReader(new FileReader("C:\\mail.html"));
		//2.对读取的数据经行匹配,从中获取符号规则的数据.
		List<String> list = new ArrayList<String>();
		String mail_regex = "\\w+@\\w+(\\.\\w+)+";
		Pattern p = Pattern.compile(mail_regex);//将指定的正则表达式编译到模式中
		String line = null;
		while((line = br.readLine())!=null){
			Matcher m = p.matcher(line);//创建指定序列的匹配器
			//将符合规则的数据存储到集合中.
			while(m.find()){//查找到符合规则的元素
				list.add(m.group());//返回匹配的字符串序列
			}
		}
		return list;
	}
	
}

package cn.fuxi._03regex;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 从互联网上爬邮箱
 */

public class _06RegexTest03 {
	public static void main(String[] args) throws Exception {
		List<String>list = getMailByWeb();
		for(String mail:list){
			System.out.println(mail);
		}
	}
	public static List<String> getMailByWeb() throws Exception{
		URL url = new URL("http://www.itheima.com/aboutt/1376.html");
		BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()));
		String mail_regex = "\\w+@\\w+(\\.\\w+)+";
		List<String> list = new ArrayList<String>();
		Pattern p = Pattern.compile(mail_regex);
		String line = null;
		while((line = br.readLine())!=null){
			Matcher m = p.matcher(line);
			while(m.find()){
				list.add(m.group());
			}
		}
		return list;
	}
}

输出结果：

eima@itcast.cn
heima@csdn.net