day19正则表达式

已于 2024-09-24 20:12:00 修改
阅读量644 收藏 21
点赞数 26
分类专栏： java面向对象 文章标签： java
于 2024-09-24 20:11:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_79357053/article/details/142498950
版权

正则表达式小结

1.1 正则表达式的概念及演示

  • 在Java中，我们经常需要验证一些字符串，例如：年龄必须是2位的数字、用户名必须是8位长度而且只能包含大小写字母、数字等。正则表达式就是用来验证各种字符串的规则。它内部描述了一些规则，我们可以验证用户输入的字符串是否匹配这个规则。

  • 下面的程序让用户输入一个QQ号码，我们要验证：

    • QQ号码必须是5--15位长度

    • 而且必须全部是数字

    • 而且首位不能为0

  • 使用正则表达式验证：

 public class Demo {
     public static void main(String[] args) {
         String qq ="1234567890";
         System.out.println(qq.matches("[1-9]\\d{5,19}"));
     }
 }

1.2 正则表达式-字符类

 // 只能是a b c
 System.out.println("-----------1-------------");
 System.out.println("a".matches("[abc]")); // true
 System.out.println("z".matches("[abc]")); //false
 ​
 // 不能出现a b c
 System.out.println("-----------2-------------");
 System.out.println("a".matches("[^abc]"));//false
 System.out.println("zz".matches("[^abc]"))//false
 System.out.println("zz".matches("[^abc][^abc]"));//true
 ​
 // a到zA到Z(包括头尾的范围)
 System.out.println("-----------3-------------");
 System.out.println("a".matches("[a-zA-z]")); //true
 System.out.println("aa".matches("[a-zA-z]"));//false
 System.out.println("zz".matches("[a-zA-Z][a-zA-Z]")); //true
 System.out.println("0".matches("[a-zA-Z0-9]"));//true
 ​
 // [a-d[m-p]] a到d，或m到p
 System.out.println("-----------4-------------");
 System.out.println("a".matches("[a-d[m-p]]"));//true
 System.out.println("e".matches("[a-d[m-p]]")); //false
 System.out.println("0".matches("[a-d[m-p]]")); //false
 ​
 // [a-z&&[def]] a-z和def的交集。为:d，e，f
 System.out.println("----------5------------");
 System.out.println("a".matches("[a-z&[def]]")); //false
 System.out.println("d".matches("[a-z&&[def]]")); //true
 ​
 // [a-z&&[^bc]] a-z和非bc的交集。(等同于[ad-z])
 System.out.println("-----------6------------_");
 System.out.println("a".matches("[a-z&&[^bc]]"));//true
 System.out.println("b".matches("[a-z&&[^bc]]")); //false
 ​
 // [a-z&&[^m-p]] a到z和除了m到p的交集。(等同于[a-1q-z])
 System.out.println("-----------7-------------");
 System.out.println("a".matches("[a-z&&[^m-p]]")); //true
 System.out.println("m".matches("[a-z&&[^m-p]]")); //false

1.3 正则表达式-逻辑运算符

  • 语法示例：

    1. &&：并且

    2. | ：或者

    3. \ ：转义字符

//1.要求字符串是小写辅音字符开头，后跟ad
         String regex = "[a-z&&[^aeiou]]ad";
         System.out.println("1." + str.matches(regex));
         
         //2.要求字符串是aeiou中的某个字符开头，后跟ad
         regex = "[a|e|i|o|u]ad";//这种写法相当于：regex = "[aeiou]ad";
         System.out.println("2." + str.matches(regex));
 // \ 转义字符 改变后面那个字符原本的含义
         //练习:以字符串的形式打印一个双引号
         //"在Java中表示字符串的开头或者结尾
 ​
         //此时\表示转义字符，改变了后面那个双引号原本的含义
         //把他变成了一个普普通通的双引号而已。
         System.out.println("\"");
 ​
         // \表示转义字符
         //两个\的理解方式：前面的\是一个转义字符，改变了后面\原本的含义，把他变成一个普普通通的\而已。
 System.out.println("c:Users\\moon\\IdeaProjects\\basic-code\\myapi\\src\\com\\itheima\\a08regexdemo\\RegexDemo1.java");

1.4 正则表达式-预定义字符

  • 语法示例：

    1. "." ： 匹配任何字符。

    2. "\d"：任何数字[0-9]的简写；

    3. "\D"：任何非数字[^0-9]的简写；

    4. "\s"： 空白字符：[ \t\n\x0B\f\r] 的简写

    5. "\S"： 非空白字符：[^\s] 的简写

    6. "\w"：单词字符：[a-zA-Z_0-9]的简写

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

public class Demo {
     public static void main(String[] args) {
         //.表示任意一个字符
         System.out.println("你".matches("..")); //false
         System.out.println("你".matches(".")); //true
         System.out.println("你a".matches(".."));//true
 ​
         // \\d只能是任意的一位数字
         // 简单来记:两个\表示一个\
         System.out.println("a".matches("\\d")); // false
         System.out.println("3".matches("\\d")); // true
 ​
         //\\w只能是一位单词字符[a-zA-Z_0-9]
         System.out.println("z".matches("\\w")); // true
         System.out.println("2".matches("\\w")); // true
         System.out.println("21".matches("\\w")); // false
         System.out.println("你".matches("\\w"));//false
 ​
         // 非单词字符
         System.out.println("你".matches("\\W")); // true
 ​
         // 必须是数字 字母 下划线 至少 6位
         System.out.println("2442fsfsf".matches("\\w{6,}"));
  //true
         System.out.println("244f".matches("\\w{6,}"));//false
 ​
         // 必须是数字和字符 必须是4位
 System.out.println("23dF".matches("[a-zA-Z0-{4}"));//true
 System.out.println("23 F".matches("[a-zA-Z0{4}"));//false
 System.out.println("23dF".matches("[\\w&&[^_{4}"));//true
 System.out.println("23_F".matches("[\\w&&[^{4}"));//false

1.5 正则表达式-数量词

  • 语法示例：

    1. X? : 0次或1次

    2. X* : 0次到多次

    3. X+ : 1次或多次

    4. X{n} : 恰好n次

    5. X{n,} : 至少n次

    6. X{n,m}: n到m次(n和m都是包含的)

 System.out.println("2442fsfsf".matches("\\w{6,}"));//true
 System.out.println("244f".matches("\\w{6,}"));//false
 ​
 // 必须是数字和字符 必须是4位
 System.out.println("23dF".matches("[a-zA-Z0-{4}"));//true
 System.out.println("23 F".matches("[a-zA-Z0{4}"));//false
 System.out.println("23dF".matches("[\\w&&[^_{4}"));//true
 System.out.println("23_F".matches("[\\w&&[^{4}"));//false

1.8 本地数据爬取

Pattern：表示正则表达式 Matcher：文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。 在大串中去找符合匹配规则的子串。

 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 ​
     private static void method1(String str) {
         //Pattern:表示正则表达式
         //Matcher: 文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。
         //在大串中去找符合匹配规则的子串。
 ​
         //获取正则表达式的对象
         Pattern p = Pattern.compile("Java\\d{0,2}");
         //获取文本匹配器的对象
         //m:文本匹配器的对象
         //str:大串
         //p:规则
         //m要在str中找符合p规则的小串
         Matcher m = p.matcher(str);
 ​
         //拿着文本匹配器从头开始读取，寻找是否有满足规则的子串
         //如果没有，方法返回false
         //如果有，返回true。在底层记录子串的起始索引和结束索引+1
         // 0,4
         boolean b = m.find();
 ​
         //方法底层会根据find方法记录的索引进行字符串的截取
         // substring(起始索引，结束索引);包头不包尾
         // (0,4)但是不包含4索引
         // 会把截取的小串进行返回。
         String s1 = m.group();
         System.out.println(s1);
 ​
         //第二次在调用find的时候，会继续读取后面的内容
         //读取到第二个满足要求的子串，方法会继续返回true
         //并把第二个子串的起始索引和结束索引+1，进行记录
         b = m.find();
 ​
         //第二次调用group方法的时候，会根据find方法记录的索引再次截取子串
         String s2 = m.group();
         System.out.println(s2);
     }
 }

1.9 网络数据爬取（了解）

需求：

把连接:https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i中所有的身份证号码都爬取出来。

代码示例：

 public class RegexDemo7 {
     public static void main(String[] args) throws IOException {
         /* 扩展需求2:
             把连接:https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i
             中所有的身份证号码都爬取出来。
         */
 ​
         //创建一个URL对象
         URL url = new URL("https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i");
         //连接上这个网址
         //细节:保证网络是畅通
         URLConnection conn = url.openConnection();//创建一个对象去读取网络中的数据
         BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
         String line;
         //获取正则表达式的对象pattern
         String regex = "[1-9]\\d{17}";
         Pattern pattern = Pattern.compile(regex);//在读取的时候每次读一整行
         while ((line = br.readLine()) != null) {
             //拿着文本匹配器的对象matcher按照pattern的规则去读取当前的这一行信息
             Matcher matcher = pattern.matcher(line);
             while (matcher.find()) {
                 System.out.println(matcher.group());
             }
         }
         br.close();
     }
 }

1.12 贪婪爬取和非贪婪爬取

 只写+和表示贪婪匹配，如果在+和后面加问号表示非贪婪爬取
 +? 非贪婪匹配
 *? 非贪婪匹配
 贪婪爬取:在爬取数据的时候尽可能的多获取数据
 非贪婪爬取:在爬取数据的时候尽可能的少获取数据
 ​
 举例：
 如果获取数据：ab+
 贪婪爬取获取结果:abbbbbbbbbbbb
 非贪婪爬取获取结果:ab

1.13 String的split方法中使用正则表达式

  • String类的split()方法原型：

     public String[] split(String regex)
 //参数regex表示正则表达式。可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。
 /*
             有一段字符串:小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
             要求1:把字符串中三个姓名之间的字母替换为vs
             要求2:把字符串中的三个姓名切割出来*/
 ​
 String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
 //细节:
 //方法在底层跟之前一样也会创建文本解析器的对象
 //然后从头开始去读取字符串中的内容，只要有满足的，那么就切割。
 String[] arr = s.split("[\\w&&[^_]]+");
 for (int i = 0; i < arr.length; i++) {
     System.out.println(arr[i]);
 }

1.14 String类的replaceAll方法中使用正则表达式

  • String类的replaceAll()方法原型：

 public String replaceAll(String regex,String newStr)
 //参数regex表示一个正则表达式。可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。

 /*
             有一段字符串:小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
             要求1:把字符串中三个姓名之间的字母替换为vs
             要求2:把字符串中的三个姓名切割出来*/
 ​
 String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
 //细节:
 //方法在底层跟之前一样也会创建文本解析器的对象
 //然后从头开始去读取字符串中的内容，只要有满足的，那么就用第一个参数去替换。
 String result1 = s.replaceAll("[\\w&&[^_]]+", "vs");
 System.out.println(result1);

1.16 分组练习

将字符串：我要学学编编编编程程程程程程。

替换为：我要学编程

 String str = "我要学学编编编编程程程程程程";
 ​
 //需求:把重复的内容 替换为 单个的
 //学学                学
 //编编编编            编
 //程程程程程程        程
 //  (.)表示把重复内容的第一个字符看做一组
 //  \\1表示第一字符再次出现
 //  + 至少一次
 //  $1 表示把正则表达式中第一组的内容，再拿出来用
 String result = str.replaceAll("(.)\\1+", "$1");
 System.out.println(result);

1.17 忽略大小写的写法

 //(?i) ：表示忽略后面数据的大小写
 //忽略abc的大小写
 String regex = "(?i)abc";
 //a需要一模一样，忽略bc的大小写
 String regex = "a(?i)bc";
 //ac需要一模一样，忽略b的大小写
 String regex = "a((?i)b)c";

1.18 非捕获分组

非捕获分组：分组之后不需要再用本组数据，仅仅是把数据括起来。

 //身份证号码的简易正则表达式
 //非捕获分组:仅仅是把数据括起来
 //特点:不占用组号
 //这里\\1报错原因:(?:)就是非捕获分组，此时是不占用组号的。
 ​
 ​
 //(?:) (?=) (?!)都是非捕获分组//更多的使用第一个
 //String regex1 ="[1-9]\\d{16}(?:\\d|x|x)\\1";
 String regex2 ="[1-9]\\d{16}(\\d Xx)\\1";
 //^([01]\d|2[0-3]):[0-5]\d:[@-5]\d$
 ​
 System.out.println("41080119930228457x".matches(regex2));

1.19 正则表达式练习

 手机号码:1[3-9]\\d{9}
 座机号码：0\\d{2,3}-?[1-9]\\d{4,9}
 邮箱号码：\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}
 24小时：([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d
        ([01]\\d|2[0-3])(:[0-5]\\d){2}
 用户名:    \\w{4,16}
 身份证号码，简单校验：
         [1-9]\\d{16}(\\d|X|x)
         [1-9]\\d{16}[\\dXx]
         [1-9]\\d{16}(\\d(?i)X)
 身份证号码，严格校验：
         [1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9|[12])\\d|3[01])\\d{3}[\\dXx]
Wanna715
关注
专栏目录
day19正则表达式作业
qq_56664754的博客
12-23 106
利用正则表达式完成下面的操作: 一、不定项选择题 能够完全匹配字符串"(010)-62661617"和字符串"01062661617"的正则表达式包括（ AD） A.r"\(?\d{3}\)?-?\d{8}" B. r"[0-9()-]+" C.r"[0-9(-)]*\d*" D.r"[(]?\d*[)-]*\d*" 能够完全匹配字符串"back"和"back-end"的正则表达式包括（ABC ） A. r'\w{4}-\w{3}|\w{4}' B. r'\w{4}|\w{4}-\w{3}
day19 正则表达式
qq_57535164的博客
12-23 352
day19 正则表达式 一、类的继承 继承：让子类拥有父类所有的属性和方法。 当 子类自己定义了自己的属性，就不能用父类的方法了。 """ class 类名(父类1, 父类2,...): pass """ class A: a = 10 def __init__(self): self.b = 20 self.c = 30 def func1(self): print('对象方法') @classmethod
day 19 正则表达式
VDSVGS的博客
12-23 180
day 19 正则表达式 一、正则表达式 正则表达式是一种让复杂的字符串问题变得简单的工具 匹配符号 1.re模块简介 re模块时python用来支持正则相关操作的系统模块 fullmatch(正则表达式，字符串) - 判断正则表达式和指定的字符串是否完全匹配，不能匹配结果是None from re import fullmatch 2.匹配类符号 正则表达式是由各种各样的正则符号组合而成 2.1普通字符 - 在正则中没有特殊功能和特殊意义的字符 普通字符在正则表达式中表示符号本身，比如
Day19:正则表达式
Ka_neki的博客
12-23 432
1.正则表达式 # 正则表达式是一种让复杂的字符串问题变得简单的一个工具 1)re模块简介 re模块是python用来支持正则相关操作的系统模块 fullmatch(正则表达式,字符串) - 判断正则表达式和指定的字符串是否完全匹配,不能匹配结果是None from re import fullmatch 2)匹配类符号 # 正则表达式是由各种各样的正则符号组合而成 2.1 普通字符 - 在正则中没有特殊功能和特殊意义的字符 #普通字符在正则表达式中表示符号本身,例如:az、AZ、0~9、中文…
day18 正则表达式
XInZgg01的博客
03-09 762
正则表达式 01 . 匹配类符号 正则表达式 正则表达式是一种可以让一些复杂的字符串问题变得简单的工具。 正则语法(通用) re模块： fullmatch(正则表达式，字符串) - 判断整个字符串是否满足正则表达式描述的规则(完全匹配) Python提供正则表达式的方法：提供一个字符串，字符串内容是一个正则表达式，这个字符串的最前面需要加 r 。 Python的正则表达式：r ’ 正则 ’ js的正则表达式：/ 正则 / oc的正则表达式：/ 正则 / 正则语法内容 包括：匹配类符号、控
day18正则表达式
yangmei9550的博客
03-10 600
day18正则表达式 正则表达式是一种可以让一些复杂的字符串问题变得简单的工具。 正则语法是通用的，不光python可以，其他语言都可以 1.re模块 python提供正则表达式的方式；提供一个字符串，字符串内容是一个正则表达式，这个字符串前面要加r python的正则表达式：r" 正则 " js的正则表达式：/正则/ oc的正则表达式：“ 正则” 2.正则语法内容 包括：匹配类符号，控制次数符号、分组合分支、检测类符号、阻止转义 一、匹配类符号 1.普通符号（字符） 在正则表达式中表示字符本身的符号就是普
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 931
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1223
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 364
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 705
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java中的break、continue和return语句
weixin_73230994的博客
10-05 377
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 356
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
11.2 Linux_线程_同步与互斥
Fresh_man111的博客
10-03 195
同一时刻只允许一个任务访问的共享资源。比如写入文件，就是一个临界资源，当写入文件时，不允许两个任务同时往里面写。如果A写入abc，B写入def，同时写的情况下文件中的值不一定为abcdef，这时就需要在某一时刻只允许A写入abc，在另一时刻只允许B写入def。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1371
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
31 类和对象 · 上
最新发布
m0_66277256的博客
10-09 436
类与对象的学习总结
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1069
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
用Java写出可以判断身份证是否正确的正则表达式。要求： ① 身份证号有十八位 ② 身份证号的第一位是不为零的数字 ③ 身份证号的最后一位是数字或x ④ 身份证的中间16位都是0到9的数字 判断50020019990220458、012398200109163123、51123420000509359x三个号码是否匹配正则表达式，如果匹配输出“身份证号正确！”，并输出该身份证上的生日，格式如“1999年6月1日”，如果不匹配输出“身份证号有误！”
05-30
使用Java编写可以判断身份证是否正确的正则表达式的代码如下： ```java import java.util.regex.Matcher; import java.util.regex.Pattern; public class IdCardRegex { public static void main(String[] args)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值