Java 学习 day26： 正则表达式

1.正则表达式

1.1        什么是正则表达式

正则表达式是一种定义了字符串应遵循的规则的式子

正则表达式可以用来搜索,编辑或者处理文字

在正则表达式中\表示转义符,在java中\也表示转义符,所以在java中使用正则表达式的转义应该是\\

1.2        常用语法

 1.3        (),[],{}

1>. 小括号()：匹配小括号内的字符串，可以是一个，也可以是多个，常跟“|”（或）符号搭配使用，是多选结构的

　　示例1：string name = "way2014";  regex：(way|zgw)  result：结果是可以匹配出way的，因为是多选结构，小括号是匹配字符串的

　　示例2：string text = "123456789";  regex：(0-9)　result：结果是什么都匹配不到的，它只匹配字符串"0-9"而不是匹配数字, [0-9]这个字符组才是匹配0-9的数字

2>.中括号[]：匹配字符组内的字符，比如咱们常用的[0-9a-zA-Z.*?!]等，在[]内的字符都是字符，不是元字符，比如“0-9”、“a-z”这中间的“-”就是连接符号，表示范围的元字符，如果写成[-!?*(]这样的话，就是普通字符

示例1： string text = "1234567890";  regex：[0-9]  result：结果是可以匹配出字符串text内的任意数字了，像上边的【或符号“|”在字符组内就是一个普通字符】

　　示例2：string text = "a|e|s|v";  regex：[a|e|s]  result：结果就是匹配字符a、e、s三个字符，这个跟(a|e|s)有区别的，区别就是(a|e|s)匹配的是a、e、s三个字符的随意一个，三个 中的任意一个，这里|是元字符

3>.大括号{}：匹配次数，匹配在它之前表达式匹配出来的元素出现的次数，{n}出现n次、{n,}匹配最少出现n次、{n,m}匹配最少出现n次，最多出现m次

1.4        实例

1.  匹配整数和小数

\d 数字

. 任意字符

/ 转义

+ 1次或多次

? 0次或1次

() 把\.和\d+看做整体

\d+(\.\d+)?

1. 电话

\d{11}

^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8}$

1. 匹配正整数

[1-9][0-9]*

1. 非负整数

\\d+

1. 整数

(-?[1-9]\\d*)|0

2.Java中的正则表达式

 2.1        使用

    //校验方法
	public static void test2(){
		String regex = "(-?[1-9]\\d*)|0" ;
		String str = "-123" ;
		//全词匹配,静态方法
		boolean flag = Pattern.matches(regex,str) ;
		System.out.println(flag);
		//String中的方法
		System.out.println(str.matches(regex));
	
	}
	//拆分方法
	public static void test1(){
		String str = "1,2,3,4,5" ;
		//创建正则表达式
		Pattern pattern = Pattern.compile(",") ;
		//拆分方法
		String [] strs = pattern.split(str) ;
		for(String s : strs){
			System.out.print(s);
		}
		System.out.println("========") ;
		strs = str.split(",") ;
		for(String s : strs){
			System.out.println(s);
		}
	}

2.2        Matcher

2.2.1        概述

1. 构造方法也是私有的，不能随意创建，只能通过Pattern.matcher(CharSequence input)方法得到该类的实例 Matcher m = p.matcher("aaaaab");
2. 支持便捷强大的正则匹配操作，包括分组、多次匹配支持

2.2.2        三大方法

Matcher.matches()：对整个字符串进行匹配，只有整个字符串都匹配了才返回true

Matcher.lookingAt()：对前面的字符串进行匹配，只有匹配到的字符串在最前面才返回true

Matcher.find()：对字符串进行匹配,匹配到的字符串可以在任何位置 

	    //整数规则
		String regex = "(-?[1-9]\\d*)|0" ;
		//需要校验的字符串
		String input = "12.12" ;
		//引擎对象
		Pattern pattern = Pattern.compile(regex) ;
		//匹配器对象
		Matcher matcher = pattern.matcher(input) ;
		/*
		 * 三种匹配模式
		 * matches : 全词匹配
		 * find : 任意位置均可
		 * lookingAt : 前面是就可以
		 * 
		 */
		//false
		System.out.println(matcher.matches());
		//不要连着使用,每次使用,都要重新打开一个matcher对象
		//find可以调用多次,因为find结合做一些提取操作
		matcher = pattern.matcher(input) ;
		System.out.println(matcher.find());
		System.out.println(matcher.find());
		System.out.println(matcher.find());
		matcher = pattern.matcher(input) ;
		System.out.println(matcher.lookingAt());

2.2.3        数据提取

        //整数规则
		//[\u4e00-\u9fa5] 汉字范围
		//一个小括号就是一组
		String regex = "([\u4e00-\u9fa5]{2,3})电话号码是(\\d{11})";
		//需要校验的字符串
		String input = "asd小明电话号码是13113113111sass张小黑电话号码是15115115111" ;
		//引擎对象
		Pattern pattern = Pattern.compile(regex) ;
		//匹配器对象
		Matcher matcher = pattern.matcher(input) ;
		/*
		 * find 和 group 结合使用,可以完成数据提取
		 *
		 */
		//想要获取下一个匹配的数据,只需要再次调用find即可
		//如果find为false ,说明后面没有符合条件的数据了
		while(matcher.find()){
			//0或者无参,都是获取匹配到的整个数据
			//1就是第一组,2就是第二组
			System.out.println(matcher.group(0));
			System.out.println(matcher.group(1));
			System.out.println(matcher.group(2));
		}

2.2.4        叠词去重

        String string = "我我......我要..要要...要要...学学学..学学...编编编编....编程..        程....程程程程..程." ;
		//1 先把.去掉
		//string = string.replaceAll("\\.","") ;
		string = string.replaceAll("[^\u4e00-\u9fa5]", "") ;
		//((我)(我我我我))(要)(要要要要)学学学学学编编编编编程程程程程程程
		System.out.println(string);
		//(.) : 任意字符
		//\\1 捕获一次,获取指定组的数据,//1就是第一组的数据,//2就是第二组的数据
		//(\\d\\1) : 连续出现两个字符,11,22,33
		//(\\d)(a)\\1 : 第一个是数字,第二个是a,第三个和第一个相同,1a1,2a2
		//(\\d)(a)\\2 : 第一个是数组,第二个是a,第三个和第二组一样
		String regex = "(.)(\\1+)" ;
		Pattern pattern = Pattern.compile(regex) ;
		Matcher matcher = pattern.matcher(string) ;
		while(matcher.find()){
			
			System.out.println(matcher.group(0));
			System.out.println(matcher.group(1));
			string = string.replaceAll(matcher.group(0), matcher.group(1)) ;
			
		}
		System.out.println(string);
		//$1就等于matcher.group(1);
		//string = string.replaceAll(regex,"$1") ;
		//System.out.println(string) ;
	}