JAVA基础19--- regular expression Matcher Pattern

最新推荐文章于 2021-06-08 20:28:56 发布

龙神~

最新推荐文章于 2021-06-08 20:28:56 发布

阅读量135

点赞数

分类专栏： JAVA基础文章标签： JAVA基础 regular expression Matcher

本文链接：https://blog.csdn.net/weixin_42161333/article/details/101265367

版权

JAVA基础专栏收录该内容

35 篇文章 0 订阅

订阅专栏

package com.guada.regex;

public class Demo1_Regex {

	/**
	 * A:正则表达式
	 * 		是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串，其实就是一种规则，有自己的特殊的应用
	 * 		作用：比如注册邮箱，邮箱有用户名和密码，一般会对其限制长度，这个限制长度的事情就是正则表达式做的
	 * B：如：校验QQ号
	 * 		a.要求必须是5-15位数字
	 * 		b.0不能开头
	 * 		c.必须是数字
	 */
	public static void main(String[] args) {
			String qq = "123a45";
			//System.out.println(check(qq));
			String regex = "[1-9]\\d{4,14}";
			System.out.println(qq.matches(regex));          //matches(String regex) 
																					//告诉这个字符串是否匹配给定的 regular expression 。
	}

	public static boolean check(String qq) { 
		boolean flag =true;
		if(qq.length()>=5&&qq.length()<=15) {
			if(!qq.startsWith("0")) {
				char arr [] = qq.toCharArray();
				for (int i = 0; i < arr.length; i++) {
					if(arr[i]<'0'||arr[i]>'9') {
						flag = false;
						break;
					}
				}
			} else {
				flag = false;
			}
		} else {
			flag = false;
		}
		return flag;
		
	}

}

package com.guada.regex;

public class Demo2_Regex {

	/**
	 * 字符类型的正则表达式表示
	 *   	[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]] de或f(交集)
	 *   	[a-z&&[^bc]]a到z,除了b和c:[ad-z](减去)
	 *   	[a-z&&[^m-p]] a到z ,而非m到p:[a-lq-z](减去)
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
	}

	public static void demo2() {
		String regex = "[^abc]";
		System.out.println("a".matches(regex));
		System.out.println("d".matches(regex));
		System.out.println("*".matches(regex));
	}

	public static void demo1() {
		String regex1 = "[abc]";
		System.out.println("a".matches(regex1));
		System.out.println("1".matches(regex1));
		System.out.println("*".matches(regex1));
	}

}

package com.guada.regex;

public class Demo3_Regex {

	/**
	 * 预定义字符:
	 * 	[]:代表一个字符
	 * 	. 任何字符
	 * 	\d 数字:[0-9]
	 * 	\D 非数字:[^0-9]
	 * 	\s 空白字符: [ \t\n\x0B\f\r]
	 * 	\S 非空白字符:[^\s]
	 * 	\w 单词字符 :[a-zA-Z_0-9]
	 * 	\W 非单词字符:[^\w]
	 */
	public static void main(String[] args) {
	//	demo1();
	//	demo2();
	//	demo3();
	//	demo4();
	}

	public static void demo4() {
		String regex = "\\s";
		System.out.println(" ".matches(regex));
		System.out.println("	".matches(regex));
		System.out.println("a".matches(regex));
		System.out.println("*".matches(regex));
		System.out.println("1".matches(regex));
	}

	public static void demo3() {
		String regex = "\\D";
		System.out.println("*".matches(regex));
		System.out.println("1".matches(regex));
		System.out.println("9".matches(regex));
		System.out.println("a".matches(regex));
	}

	public static void demo2() {
		String regex = "\\d";
		System.out.println("0".matches(regex));
		System.out.println("9".matches(regex));
		System.out.println("a".matches(regex));
		System.out.println("*".matches(regex));
	}

	public static void demo1() {
		String regex = ".";
		System.out.println(".".matches(regex));
		System.out.println("a".matches(regex));
		System.out.println("0".matches(regex));
		System.out.println("*".matches(regex));
	}

}

package com.guada.regex;

public class Demo4_Regex {

/**
 * 正则表达式中的数量词
 * 	X?   X,一次或一次也没有
 * 	X*   X,零次或多次
 * 	X+   X,一次或多次
 * 	X{n}  X,恰好n次
 * 	X{n, }  X,至少n次
 * 	X{n,m}    X,至少n次,但是不超过m次
 */
public static void main(String[] args) {
	//demo1();
	demo2();
	
}

public static void demo2() {
	String regex ="[abc]*";
	System.out.println("".matches(regex));
	System.out.println("a".matches(regex));
	System.out.println("abc".matches(regex));
	System.out.println("abcacb".matches(regex));
}

public static void demo1() {
	String regex = "[abc]?";
	System.out.println("".matches(regex));
	System.out.println("a".matches(regex));
	System.out.println("*".matches(regex));
	System.out.println("aa".matches(regex));
}

}
5.

package com.guada.regex;

public class Demo5_Regex {

	/**
	 * 正则表达式的切割功能 split
	 */
	public static void main(String[] args) {
		String s = "张三.李四.王大眼";                    
		String [] arr = s.split("\\.");                    //使用split切割字符串   使用一个String字符串数组接收
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

}

package com.guada.regex;

public class Demo6_Regex {

	/**
	 * 正则表达式的替换功能
	 * 	String类的功能:public String replaceAll(String regex,String replacement)
	 */
	public static void main(String[] args) {
		String s = "guada";
		
		String regex = "[a]";
		String s1 = s.replaceAll(regex, "");
		System.out.println(s1);
	}

}

package com.guada.regex;

public class Demo7_Regex {

	/**
	 * 正则表达式的分组功能
	 */
	public static void main(String[] args) {
	//	demo1();
	//	demo2();
	//	我我我我我我.......在在在在......瓜瓜瓜......大大大......          还原成我在瓜大
		demo3();
		
	}

	public static void demo3() {
		String s = "我我我我我我.......在在在在......瓜瓜瓜......大大大......";
		
		String s1 = s.replaceAll("\\.+", "").replaceAll("(.)\\1+", "$1") ;           //$1代表第一组中的内容
		System.out.println(s1);
	}

	public static void demo2() {
		String s = "sdqqfgkkklkpppij";
		String regex = "(.)\\1+";                              //按照出现多次进行切割
		String [] s1 = s.split(regex);
		for (int i = 0; i < s1.length; i++) {
			System.out.println(s1[i]);
		}
	}

	public static void demo1() {
		String s ="kkff";
		String s1 ="kfkf";
		String s2 ="kkkk";
		String s3 ="lkjh";
		String regex = "(.)\\1(.)\\2";                            //\\1表示第一组又出现一次   \\2表示第二组也出现一次
		System.out.println(s.matches(regex));             //true
		System.out.println(s1.matches(regex));             //false
		System.out.println(s2.matches(regex));             //true
		System.out.println(s3.matches(regex));             //false
	}

}

  package com.guada.regex;

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

public class Demo8_Pattern {

	/**
				 * 则表达式的编译表示。 
					必须首先将正则表达式（指定为字符串）编译为此类的实例。 然后将所得的图案可以被用来创建一个Matcher对象可以匹配任意character sequences针对正则表达式。 执行匹配的所有状态都驻留在匹配器中，所以许多匹配者可以共享相同的模式。 
			
					因此，典型的调用序列 
			
			 		Pattern p = Pattern.compile("a*b");
			 		Matcher m = p.matcher("aaaaab");
			 		boolean b = m.matches();
	 */
	public static void main(String[] args) {
//		demo1();
		
		//把一个字符串中的手机号码获取出来
		String s = "我的手机号码是18300000000,还用过18200000000";
		String regex = "[1][35789]\\d{9}";                 //手机号码匹配的正则表达式
		/*Pattern p = Pattern.compile(regex);         
		Matcher m = p.matcher(s);
		boolean b = m.matches();
		
		System.out.println(b);*/
		Pattern p = Pattern.compile(regex);                   //获取正则表达式
		Matcher m = p.matcher(s);                                	//获取匹配器
		/*boolean b = m.find();                   
		System.out.println(b);
		System.out.println(m.group());*/
		while (m.find())                                                	//获取到返回true
			System.out.println(m.group());                        //截取匹配的字符串中的符合正则表达式中的字串
	}

	public static void demo1() {
		Pattern p = Pattern.compile("a*b");                  //获取正则表达式
 		Matcher m = p.matcher("aaaaab");					//获取匹配器
 		boolean b = m.matches();
 		
 		System.out.println(b);                                         //true
 		System.out.println("aaaaab".matches("a*b"));   //true
	}

}