《后端》黑马JavaSE基础（14）-常见对象-字符串之regex正则表达式类-2020年7月14日

最新推荐文章于 2023-04-03 10:53:12 发布

bellediao

最新推荐文章于 2023-04-03 10:53:12 发布

阅读量149

点赞数

分类专栏： JavaSe 后端

本文链接：https://blog.csdn.net/bellediao/article/details/107301944

版权

后端同时被 2 个专栏收录

27 篇文章 0 订阅

订阅专栏

JavaSe

13 篇文章 0 订阅

订阅专栏

正则：是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的。

传统方法和正则方法的比较

public static void main(String[] args) {
		System.out.println(checkQQ("0222222"));
	}
	public static boolean checkQQ(String qq){
		boolean flag=true;
        //5-15位
		if(qq.length()>=5 && qq.length()<=15){
            //非零开头
			if(!qq.startsWith("0")){
                //把QQ号转成字符串数组
				char [] arr=qq.toCharArray();
				for(int i=0;i<arr.length;i++){
					flag=true;
					break;
				}
			}else{
				flag=false;
			}
		}else{
			flag=false;
		}
		
		return flag;
	}

使用正则：

String regex="[1-9]\\d[4,14]";
System.out.println("553868".matches(regex));

一、字符串之正则

1、字符类

* []代表单个字符
* [abc]代表a,b,c
* [^abc]代表除了abc的任何字符
* [a-zA-Z]代表a-zA-Z包含两头字母
* [a-d[m-p]]代表a-d或m-p相当于[a-dm-p] （并集）
* [a-z&&[def]]代表(a-z)与(d或e或f)的交集
* [a-z&&[^def]]代表(a-z)与(非d或e或f)的交集
* [a-z&&[^m-p]]代表(a-z)与(非m-p)的交集

public static void main(String[] args){	
    String regex1="[abc]";
	System.out.println("a".matches(regex1));
	System.out.println("r".matches(regex1));
	String regex2="[^abc]";
	System.out.println("r".matches(regex2));
	System.out.println("a".matches(regex2));
	String regex3="[a-zA-Z]";
	System.out.println("1".matches(regex3));
	System.out.println("f".matches(regex3));
	System.out.println("%".matches(regex3));
	String regex4="[a-z&&[def]]";
	System.out.println("a".matches(regex4));
	System.out.println("d".matches(regex4));
}

2、预定义字符类

. 任何字符
\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) {
	String regex1=".";
	System.out.println("a".matches(regex1));
	String regex2="..";
	System.out.println("ba".matches(regex2));
	String regex3="\\d";//反斜杠是转义字符
	System.out.println("3".matches(regex3));
	String regex4="\\D";
	System.out.println("3".matches(regex4));
	String regex5="\\s";
	System.out.println(" ".matches(regex5));//空格=》true
	System.out.println("	".matches(regex5));//一个tab=》true
	System.out.println("    ".matches(regex5));//四个空格=》false
	String regex6="\\w";
	System.out.println("a".matches(regex6));//=》true
	System.out.println("sdz".matches(regex6));//=》false
	System.out.println("_".matches(regex6));//=》true
	System.out.println("z34".matches(regex6));//=》false
	System.out.println("_8".matches(regex6));//=》false
}

3、数量词

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) {
	String regex1="[abc]?";//一次或零次
	System.out.println("a".matches(regex1));//=》true
	System.out.println("b".matches(regex1));//=》true
	System.out.println("f".matches(regex1));//=》false
	System.out.println("".matches(regex1));//=》true

	String regex2="[abc]*";//零次或多次
	System.out.println("a".matches(regex2));//=》true
	System.out.println("ab".matches(regex2));//=》true
	System.out.println("f".matches(regex2));//=》false
	System.out.println("".matches(regex2));//=》true

	String regex3="[abc]+";//一次或多次 (不包括零次)
	System.out.println("a".matches(regex3));//=》true
	System.out.println("ab".matches(regex3));//=》true
	System.out.println("f".matches(regex3));//=》false
	System.out.println("".matches(regex3));//=》false

	String regex4="[abc]{5}";//恰好 5 次
	System.out.println("acacc".matches(regex4));//=》true
	System.out.println("aaaaaab".matches(regex4));//=》false
	System.out.println("a".matches(regex4));//=》false
	System.out.println("".matches(regex4));//=》false

	String regex5="[abc]{5,}";//至少 5 次
	System.out.println("abaaaaaab".matches(regex5));//=》true

	String regex6="[abc]{5,15}";//5次~15次
	System.out.println("abcab".matches(regex6));//=》true
    System.out.println("abcaaab".matches(regex6));//=》true
	System.out.println("abcabcababcabab".matches(regex6));//=》true	}

正则错题集：

（来自牛客网：检查重复字符串_牛客网 https://www.nowcoder.com/practice/5ef31f11adf64d9fb18d74860e9ab873?tpId=6&rp=1&ru=%2Fta%2Ffront-end&qru=%2Fta%2Ffront-end%2Fquestion-ranking）

题目描述：给定字符串 str，检查其是否包含连续重复的字母（a-zA-Z），包含返回 true，否则返回 false。

我的错误答案：

function containsRepeatingLetter(str) {
    var regex=[a-zA-Z]{2,};
    for(var i=0;i<str.length;i++){
        if(str[i].matches(regex)){
            return true;
        }return false;             
    }
}

正解：

function containsRepeatingLetter(str) {
     return /([a-zA-Z])\1/.test(str);
 }

解析：

/([a-zA-Z])\1/中后面的\1要怎么理解?---\1是子表达式的引用，对正则表达式中前一个子表达式的引用，并不是指对子表达式模式的引用，而指的是与那个模式相匹配的文本的引用。这样，引用可以用于实施一条约束，即一个字符串各个单独部分包含的是完全相同的字符。

为啥把\1换成{2,}不行？--换成{2,}是这样的：查找连续两个a-zA-Z的字母，只要是两个字母挨着都会返回ture

二、应用

1、正则表达式的分割功能-split

知识点：String类的功能：public String[] split(String regex);//通过正则表达式切割字符串

	/*正则表达式的分割功能*/
	public static void main(String[] args) {
		String str="马云.马化腾.李yundi";
		String [] arr=str.split("\\.");
//		System.out.println(arr);//=>[Ljava.lang.String;@7852e922
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
/*		    马云
		    马化腾
		    李yundi*/
		}
     }

2、把给定字符串中的数字排序

思路：先分割(现在是字符串) =》把string转成int字符串 =》把int字符串转成int类型 =》排序 Arrays.sort(arrInt);
最后将排序后的的结果遍历成字符串。

import java.lang.reflect.Array;
import java.util.Arrays;
public class demo5 {
	public static void main(String[] args) {
		String s="91 27 46 38 50";//有这么个字符串s
		String[] arrStr=s.split(" ");//先分割(现在是字符串)
		int[] arrInt=new int[arrStr.length];//把string转成int字符串
		
		for(int i=0;i<arrInt.length;i++){
			arrInt[i]=Integer.parseInt(arrStr[i]);//把int字符串转成int类型
		}
		
//		排序
		Arrays.sort(arrInt);
//		将排序后的的结果遍历成字符串
		String str="";
		for(int i=0;i<arrInt.length;i++){
			if(i==arrInt.length-1){
				str=str+arrInt[i];
			}else{
				str=str+arrInt[i]+" ";
			}
		}
		System.out.println(str);//=>27 38 46 50 91
	}
}

3、正则表达式的替换功能-replaceAll

知识点：

String类的功能：public String replaceAll(String regex,String replacement);

含义：用regex来匹配符合条件的字符，用replacement对其替换。

//需求：把字符串中的数字去掉。
	public static void main(String[] args) {
		String s="woai3bian3cheng";
		String regex="\\d"; // \\d代表任意数
		String s2=s.replaceAll(regex," ");
		System.out.println(s2);
	}

4、正则表达式的分组功能

正则表达式的分组功能。捕获组可以通过从左到右计算其开括号来编号。

例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：

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

	public static void main(String[] args) {
	//先来两个叠词小案例：
		//叠词 快快乐乐,高高兴兴
		String regex="(.)\\1(.)\\2";
		/*正则解析： . 代表任意字符，加个括号代码给他分一个组,\\1代表让第一组再出现一次。
		          后面的\\2代表让那个第二组再出现一次。*/
		System.out.println("夸夸琪琪".matches(regex));//=》true
		
		//叠词 快乐快乐,高兴高兴
		String regex4="(..)\\1";
		System.out.println("高兴高兴".matches(regex4));//=》true
		
	//案例1：切割 需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
		String s1="sdqqfgkkkhjppppkl";	
		//String regex1="(.)\\1+";//+代表第一组出现一次到多次
		String regex1="(.)\\1+";
		String[] arr=s1.split(regex1);
		
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
		/*=》
			sd
			fg
			hj
			kl*/
		
	//案例2：替换 需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
				//将字符串还原成:“我要学编程”。
		String s2="我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
		//先去掉省略号
		String regex2="\\.+";// 这个正则代表：. 出现多次
		//我之前错写成 String regex2="(\\.)\\1+";//=>我我我我.要要要要学学学学.编编编.编.程.程.程程
		String s3=s2.replaceAll(regex2, "");
		System.out.println(s3);//=》我我我我要要要要学学学学编编编编程程程程
		//再去掉叠词
		String regex3="(.)\\1+";
		String s4=s3.replaceAll(regex3,"$1");//$1代表第一组中的内容,这一行代表：去重剩下一个词
		System.out.println(s4);//=》我要学编程
	}

5、Pattern和Matcher的概述（模式和匹配器）

（不太明白）

典型的调用顺序是
Pattern p = Pattern.compile("a*b"); //获取到正则表达式，a出现0 次到多次再跟上一个b
Matcher m = p.matcher("aaaaab");//获取一个匹配器，看嫩能不能跟正则匹配上
boolean b = m.matches();//能匹配上返回true，不能返回false。

应用：正则表达式的获取功能

（Pattern和Matcher的结合使用）

需求：把一个字符串中的手机号码获取出来

package regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class demo_Pattern {
	public static void main(String[] args) {
		String s="我的手机号码是15717754468，以前号码是15717753443";
		String regex="1[89357]\\d{9}";
		Pattern p= Pattern.compile(regex);
		Matcher m=p.matcher(s);
		/*boolean b1=m.find();
		System.out.println(b1);
		String s1=m.group();
		System.out.println(s1);*/
		//或者用循环
		while (m.find()){
			System.out.println(m.group());
		}
	}
}

bellediao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
《后端》黑马JavaSE基础（14）-常见对象-字符串之regex正则表达式类-2020年7月14日

正则表达式是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的。传统方法和正则方法的比较public static void main(String[] args) { System.out.println(checkQQ("0222222")); } public static boolean checkQQ(S...
复制链接

扫一扫