17.正则表达式

正则表达式

  • 正则表达式
    • 1.字符类
    • 2. 逻辑运算符
    • 3. 预定义字符
    • 4. 数量词
    • 5. 数据爬取
    • 6. 按要求爬取
      • 6.1 贪婪爬取
      • 6.2 非贪婪爬取
    • 7. 字符串中使用正则表达式的方法
    • 8. 分组括号
      • 8.1 匹配和捕获分组
      • 8.2 引用和后向引用
      • 8.3 零宽断言
      • 8.4 分组嵌套与递归
      • 8.5 忽略大小写
      • 8.6 代码示例

正则表达式

正则表达式是一种用来匹配和操作字符串的强大工具。它是一种描述字符模式的方式，能够帮助你在文本中查找、替换和提取特定的字符序列。

常用的正则表达式元字符和操作符：

  1. 字符串匹配：

    • 普通字符：字符直接匹配，例如 abc 匹配字符串中的 “abc”。

    • 点号：. 匹配除换行符以外的任意单个字符。

    • 转义字符：使用反斜杠 \ 来转义特殊字符，例如 \. 匹配句号。

  2. 字符类：

    • 方括号：[] 用来匹配方括号内的任意一个字符，例如 [aeiou] 匹配任意一个元音字母。

    • 脱字符：^ 在方括号内使用，用来否定字符类，例如 [^0-9] 匹配非数字字符。

  3. 重复匹配：

    • 星号：* 匹配前面的字符零次或多次，例如 a*b 匹配 “b”、“ab”、“aab” 等。

    • 加号：+ 匹配前面的字符一次或多次，例如 a+b 匹配 “ab”、“aab” 等。

    • 问号：? 匹配前面的字符零次或一次，例如 colou?r 匹配 “color” 和 “colour”。

    • 大括号：{n} 匹配前面的字符恰好 n 次，例如 a{3} 匹配 “aaa”。

    • 连字符：{m,n} 匹配前面的字符至少 m 次、最多 n 次，例如 a{2,4} 匹配 “aa”、“aaa” 和 “aaaa”。

  4. 边界匹配：

    • 插入符号：^ 用于匹配字符串的开头，例如 ^hello 匹配以 “hello” 开头的字符串。

    • 美元符号：$ 用于匹配字符串的结尾，例如 world$ 匹配以 “world” 结尾的字符串。

  5. 特殊字符：

    • 反斜杠：\ 用于转义特殊字符。

    • 竖线：| 用于分隔多个模式，例如 foo|bar 匹配 “foo” 或 “bar”。

    • 圆括号：() 用于分组字符，例如 (abc)+ 匹配 “abc”、“abcabc” 等。

1.字符类

  • 语法示例：

  1. [abc]：代表a或者b，或者c字符中的一个。

  2. [^abc]：代表除a,b,c以外的任何字符。

  3. [a-z]：代表a-z的所有小写字符中的一个。

  4. [A-Z]：代表A-Z的所有大写字符中的一个。

  5. [0-9]：代表0-9之间的某一个数字字符。

  6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。

  7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符。

  • 代码示例：
package com.itheima.a08regexdemo;public class RegexDemo2 {public static void main(String[] args) {//public boolean matches(String regex):判断是否与正则表达式匹配，匹配返回true// 只能是a b cSystem.out.println("-----------1-------------");System.out.println("a".matches("[abc]")); // trueSystem.out.println("z".matches("[abc]")); // false// 不能出现a b cSystem.out.println("-----------2-------------");System.out.println("a".matches("[^abc]")); // falseSystem.out.println("z".matches("[^abc]")); // trueSystem.out.println("zz".matches("[^abc]")); //falseSystem.out.println("zz".matches("[^abc][^abc]")); //true// a到zA到Z(包括头尾的范围)System.out.println("-----------3-------------");System.out.println("a".matches("[a-zA-z]")); // trueSystem.out.println("z".matches("[a-zA-z]")); // trueSystem.out.println("aa".matches("[a-zA-z]"));//falseSystem.out.println("zz".matches("[a-zA-Z]")); //falseSystem.out.println("zz".matches("[a-zA-Z][a-zA-Z]")); //trueSystem.out.println("0".matches("[a-zA-Z]"));//falseSystem.out.println("0".matches("[a-zA-Z0-9]"));//true// [a-d[m-p]] a到d，或m到pSystem.out.println("-----------4-------------");System.out.println("a".matches("[a-d[m-p]]"));//trueSystem.out.println("d".matches("[a-d[m-p]]")); //trueSystem.out.println("m".matches("[a-d[m-p]]")); //trueSystem.out.println("p".matches("[a-d[m-p]]")); //trueSystem.out.println("e".matches("[a-d[m-p]]")); //falseSystem.out.println("0".matches("[a-d[m-p]]")); //false// [a-z&&[def]] a-z和def的交集。为:d，e，fSystem.out.println("----------5------------");System.out.println("a".matches("[a-z&[def]]")); //falseSystem.out.println("d".matches("[a-z&&[def]]")); //trueSystem.out.println("0".matches("[a-z&&[def]]")); //false// [a-z&&[^bc]] a-z和非bc的交集。(等同于[ad-z])System.out.println("-----------6------------_");System.out.println("a".matches("[a-z&&[^bc]]"));//trueSystem.out.println("b".matches("[a-z&&[^bc]]")); //falseSystem.out.println("0".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]]")); //trueSystem.out.println("m".matches("[a-z&&[^m-p]]")); //falseSystem.out.println("0".matches("[a-z&&[^m-p]]")); //false}
}

2. 逻辑运算符

  • 语法示例：

    1. &&：并且

    2. | ：或者

    3. \ ：转义字符

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

3. 预定义字符

  • 语法示例：

    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("..")); //falseSystem.out.println("你".matches(".")); //trueSystem.out.println("你a".matches(".."));//true// \\d 表示任意的一个数字// \\d只能是任意的一位数字// 简单来记:两个\表示一个\System.out.println("a".matches("\\d")); // falseSystem.out.println("3".matches("\\d")); // trueSystem.out.println("333".matches("\\d")); // false//\\w只能是一位单词字符[a-zA-Z_0-9]System.out.println("z".matches("\\w")); // trueSystem.out.println("2".matches("\\w")); // trueSystem.out.println("21".matches("\\w")); // falseSystem.out.println("你".matches("\\w"));//false// 非单词字符System.out.println("你".matches("\\W")); // trueSystem.out.println("---------------------------------------------");// 以上正则匹配只能校验单个字符。// 必须是数字 字母 下划线 至少 6位System.out.println("2442fsfsf".matches("\\w{6,}"));//trueSystem.out.println("244f".matches("\\w{6,}"));//false// 必须是数字和字符 必须是4位System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//trueSystem.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//falseSystem.out.println("23dF".matches("[\\w&&[^_]]{4}"));//trueSystem.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false}
}

4. 数量词

  • 语法示例：

    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都是包含的)

  • 代码示例：
public class Demo {public static void main(String[] args) {// 必须是数字 字母 下划线 至少 6位System.out.println("2442fsfsf".matches("\\w{6,}"));//trueSystem.out.println("244f".matches("\\w{6,}"));//false// 必须是数字和字符 必须是4位System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//trueSystem.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//falseSystem.out.println("23dF".matches("[\\w&&[^_]]{4}"));//trueSystem.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false}
}

5. 数据爬取

请注意，爬取网站的数据时需要谨慎并遵守相关法律法规和网站的规定。在进行爬取操作前，请确保获得了合法的授权，并遵守使用条款和隐私政策。

在Java中，可以使用内置的 java.util.regex 包中的类来处理正则表达式和数据爬取。以下是使用Java正则表达式进行数据爬取的步骤及其讲解：

  1. 导入相关类和包：
    在Java文件的顶部，导入 java.util.regex 包。

  2. 获取文本数据：
    从目标文本源（可能是网页、文档或其他数据源）中获取要进行数据爬取的文本数据。

  3. 构建正则表达式模式：
    基于你想要提取的数据模式，构建相应的正则表达式模式。例如，如果你想要提取文本中的所有URL链接，可以使用 String pattern = "((http|https)://[\\w\\d\\-.]+(\\.[\\w\\d\\-.]+)+(:\\d+)?(/\\S*)?)"。

  4. 创建正则表达式对象：
    使用 Pattern 类的 compile() 方法来创建正则表达式对象。例如：Pattern regexPattern = Pattern.compile(pattern);。

  5. 获取匹配结果：
    使用正则表达式对象 regexPattern 的 matcher() 方法创建匹配器对象，并将目标文本作为参数传递。然后，使用匹配器对象的方法（如 find()、group() 等）来获取匹配结果。

  6. 处理提取的数据：
    根据需要，你可以对提取的数据进行进一步的处理，如整理、清洗、存储等。

下面是一个具体的示例代码，用于从文本中提取URL链接：

import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegexDemo {public static void main(String[] args) {String text = "这是一个示例文本，其中包含一些URL链接：http://www.example.com 和 https://www.example.org";String pattern = "((http|https)://[\\w\\d\\-.]+(\\.[\\w\\d\\-.]+)+(:\\d+)?(/\\S*)?)";Pattern regexPattern = Pattern.compile(pattern);Matcher matcher = regexPattern.matcher(text);while (matcher.find()) {String url = matcher.group();System.out.println(url);}}
}

以上示例将输出两个匹配到的URL链接：http://www.example.com 和 https://www.example.org。

需要注意的是，在Java中，正则表达式中的反斜杠 \ 通常需要进行转义，因此需要使用 \\ 表示一个单独的反斜杠。

6. 按要求爬取

  • 只写+和*表示贪婪匹配，

  • 如果在+和后面加问号表示非贪婪爬取

    • +? 非贪婪匹配

    • *? 非贪婪匹配

  • 贪婪爬取:在爬取数据的时候尽可能的多获取数据

  • 非贪婪爬取:在爬取数据的时候尽可能的少获取数据

举例：

如果获取数据：ab`+贪婪爬取获取结果:abbbbbbbbbbbb非贪婪爬取获取结果:ab

6.1 贪婪爬取

在Java中，贪婪爬取（Greedy Crawling）是指使用爬虫程序从互联网上持续不断地抓取尽可能多的网页数据。贪婪爬取的目标是尽可能地收集更多的数据，以便进行进一步的分析和处理。

贪婪爬取主要涉及以下几个步骤：

  1. 确定起始点：选择一个或多个起始URL作为初始爬取点，可以是单个网页或一个网站的主页。

  2. 下载网页：使用Java中提供的网络库（如HttpURLConnection或HttpClient）进行网页的下载，并将下载的网页保存为HTML文档或文本，以供后续处理使用。

  3. 解析网页：使用HTML解析库（例如Jsoup）解析下载的网页，提取出所需的信息。可以使用选择器来选择特定HTML元素（如链接、文本、图像等），并获取它们的属性或内容。

  4. 提取链接：从解析后的网页中提取所有的链接，以便进一步扩展爬取的范围。可以使用正则表达式、字符串处理或HTML解析库来提取链接。

  5. 遍历链接：根据需求，可以使用广度优先搜索（BFS）或深度优先搜索（DFS）等遍历算法，在已有的链接中选择下一个要爬取的页面。对于每个链接，重复步骤2-4，下载、解析并提取链接。

  6. 重复操作：不断迭代地重复步骤2-5，直到达到预定的爬取深度、爬取时间或其他终止条件。在每个迭代中，将爬取得到的数据保存到文件或数据库中，供后续使用。

需要注意以下几个方面：

  • 爬虫的行为需要遵守网站的爬取规则，避免对服务器造成过多的压力，以及遵守相关法律法规。

  • 在爬取数据之前，要对目标网站的robots.txt文件进行检查，了解网站对爬虫的访问限制，确保按照网站的要求进行爬取。

  • 贪婪爬取可能会导致大量的网络请求，因此需要进行适度的请求速率控制，以免对网络带宽和服务器资源造成过大负载。

6.2 非贪婪爬取

在Java中，非贪婪爬取（Non-Greedy Crawling）是指使用爬虫程序从互联网上抓取特定的网页数据，而不是尽可能多的数据。非贪婪爬取的目标是有目的地选择特定的网页，并只收集所需的数据，以便进行进一步的处理和分析。

非贪婪爬取通常涉及以下几个步骤：

  1. 确定起始点：选择一个或多个起始URL作为初始爬取点，这些URL可以是单个网页或特定网站的页面。

  2. 下载网页：使用Java中提供的网络库（如HttpURLConnection或HttpClient）进行网页的下载，并保存为HTML文档或文本文件，以供后续处理使用。

  3. 解析网页：使用HTML解析库（例如Jsoup）解析下载的网页，提取出所需的信息。可以使用选择器来选择特定的HTML元素（如链接、文本、图像等），并获取它们的属性或内容。

  4. 提取链接：从解析后的网页中提取特定的链接，以便进一步选择需要爬取的页面。可以使用正则表达式、字符串处理或HTML解析库来提取链接。

  5. 判断条件：根据需求设定特定的条件，例如只爬取特定类型的网页（如新闻、论坛帖子等），或根据关键词来筛选。

  6. 过滤数据：根据条件进行数据的筛选和过滤，只保留所需的数据，其他数据可以忽略。

  7. 重复操作：迭代地重复步骤2-6，根据设定的条件和需求，选择特定的网页进行爬取和数据提取。

需要注意以下几个方面：

  • 爬取行为需要遵守网站的爬取规则，避免对服务器造成不必要的负荷，以及遵守相关法律法规。

  • 在爬取数据之前，要遵守网站的robots.txt文件和使用条款，确保按照网站的要求进行爬取。

  • 非贪婪爬取的目的是有目的地选择特定的网页和数据，因此需要根据需求设定特定条件和过滤规则。

7. 字符串中使用正则表达式的方法

在Java中，可以使用正则表达式来匹配和操作字符串。

方法说明
matches(String regex)判断字符串是否与正则表达式匹配，返回布尔值。
replaceAll(String regex, String replacement)将符合正则表达式的字符串替换为指定的字符串。
replaceFirst(String regex, String replacement)将第一个符合正则表达式的子字符串替换为指定的字符串。
split(String regex)根据正则表达式拆分字符串，并返回分隔后的字符串数组。
find()在字符串中查找下一个与正则表达式匹配的字串，返回布尔值。
group()返回上一次匹配操作的匹配结果。若结合find()方法使用，可以获取所有匹配的字串。
replaceAll(String regex, Function<MatchResult, String> replacer)使用自定义逻辑替换符合正则表达式的字符串。

  • split()方法细节:

    • 方法在底层跟之前一样也会创建文本解析器的对象

    • 然后从头开始去读取字符串中的内容，只要有满足的，那么就切割。

  • replaceAll方法细节:

    • 方法在底层跟之前一样也会创建文本解析器的对象

    • 然后从头开始去读取字符串中的内容，只要有满足的，那么就用第一个参数去替换。

下面是使用正则表达式方法的示例：

import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegexExample {public static void main(String[] args) {String text = "Hello, my email address is example@email.com";// 使用matches()方法判断字符串是否匹配正则表达式boolean isMatch = text.matches(".*@.*\\.com");System.out.println("Matches: " + isMatch);// 使用replaceAll()方法替换符合正则表达式的字符串String replacedText = text.replaceAll("email", "mailbox");System.out.println("Replaced text: " + replacedText);// 使用split()方法根据正则表达式拆分字符串String[] splitText = text.split("\\s+|\\p{Punct}");System.out.println("Split text: " + Arrays.toString(splitText));// 使用find()方法查找字符串中匹配正则表达式的子串Pattern pattern = Pattern.compile("\\w+@\\w+\\.\\w+");Matcher matcher = pattern.matcher(text);while (matcher.find()) {String match = matcher.group();System.out.println("Match: " + match);}// 使用自定义逻辑替换符合正则表达式的字符串String customizedReplace = matcher.replaceAll((MatchResult result) -> "REPLACED");System.out.println("Customized replace: " + customizedReplace);}
}

8. 分组括号

在Java的正则表达式中，分组括号 () 用于将一部分正则表达式作为一个整体进行匹配、捕获或分组操作。以下是关于分组括号的详细说明：

8.1 匹配和捕获分组

  • (pattern)：将 pattern 组合成一个子表达式，并将其作为一个整体进行匹配。同时，被括号包围的部分也会被捕获到一个组内，供后续处理使用。捕获的组从左到右以 1 开始编号。

  • (?:pattern)：类似于普通的分组，但不会捕获匹配的文本。适用于只需要进行分组但不需要对结果进行处理的情况。

在正则表达式中，匹配和捕获分组是常用的功能：

  1. 匹配分组：

    • 使用圆括号 ( ) 将模式组合在一起形成一个分组。这样，整个分组将被视为一个整体，与输入文本进行匹配。
    • 匹配分组允许对模式的一部分进行重复操作。例如，正则表达式 (abc)+ 可以匹配一个或多个连续的 “abc”。

    示例：

    • 正则表达式 (\d{3})-\d{3}-\d{4}，用于匹配电话号码的格式为 “XXX-XXX-XXXX”，其中 (\d{3}) 是一个匹配分组，用于匹配三个连续的数字。
    • 输入文本 “123-456-7890” 将匹配这个正则表达式，并且匹配分组 (\d{3}) 将捕获 “123”。

  2. 捕获分组：

    • 除了用于匹配，分组还可以用于捕获匹配的内容。当匹配成功时，捕获分组中的内容将被捕获并作为结果的一部分返回。
    • 使用圆括号 ( ) 将要捕获的内容包裹起来即可创建一个捕获分组。

    示例：

    • 正则表达式 (Hello), (world)!，用于匹配 “Hello, world!” 并将 “Hello” 和 “world” 作为两个捕获分组。
    • 输入文本 “Hello, world!” 将匹配这个正则表达式，并且第一个捕获分组 (Hello) 将捕获 “Hello”，第二个捕获分组 (world) 将捕获 “world”。

  3. 访问捕获分组：

    • 可以使用索引或名称来访问捕获分组中的内容。
    • 在大多数正则表达式引擎中，索引从1开始，依次递增。可以通过 group(index) 获取相应索引的捕获分组内容。
    • 正则表达式引擎还支持为分组指定名称，使其更容易理解和访问。可以通过 group("name") 或 group(name) 来获取指定名称的捕获分组内容。

    示例：

    • 正则表达式 (\d{2})-(\d{2})-(\d{4})，用于匹配日期格式为 “MM-DD-YYYY” 的字符串，并将月、日和年分别作为捕获分组。
    • 输入文本 “01-19-2024” 将匹配这个正则表达式。可以使用 matcher.group(1) 获取月份 “01”，使用 matcher.group(2) 获取日期 “19”，使用 matcher.group(3) 获取年份 “2024”。

8.2 引用和后向引用

  • \n：引用第 n 个捕获组的内容，其中 n 为组的编号。这可用于在正则表达式中引用之前已经匹配的内容。
  • \k<name>：引用命名捕获组 <name> 的内容。

在正则表达式中，引用和后向引用是用于引用和重用已捕获分组的功能。

  1. 引用：

    • 引用允许在正则表达式中引用前面的捕获分组。
    • 引用使用反斜线 \ 加上分组的索引或名称来表示。
    • 引用将使得模式要求匹配与引用的分组完全相同的内容。

    示例：

    • 正则表达式 (\w+)@\1.com，用于匹配重复的电子邮件地址。\1 是对第一个捕获分组的引用。
    • 输入文本 “abc@abc.com” 将匹配这个正则表达式，因为 \1 引用了第一个捕获分组的内容 “abc”。

  2. 后向引用：

    • 后向引用是一种引用前面捕获分组的内容的方法。
    • 后向引用通过在正则表达式中使用 \ 加上分组的索引或名称来表示，类似于引用。
    • 后向引用将使得模式要求与引用的分组中的内容相同的内容。

    示例：

    • 正则表达式 <([a-zA-Z]+)>.*<\/\1>，用于匹配简单的HTML标签，并确保起始标签和结束标签的名称相同。 <\/\1> 是对第一个捕获分组的后向引用。
    • 输入文本 “

      This is a paragraph.

      ” 将匹配这个正则表达式，因为后向引用 <\/\1> 要求结束标签与起始标签的名称相同。

8.3 零宽断言

  • (?=pattern)：正向预查。在匹配 pattern 之前检查字符串中是否有匹配项，但不消费输入字符串。
  • (?!pattern)：负向预查。在匹配 pattern 之前检查字符串中是否没有匹配项，但不消费输入字符串。
  • (?<=pattern)：正向后查。在匹配 pattern 之后检查字符串中是否有匹配项，但不消费输入字符串。
  • (?<!pattern)：负向后查。在匹配 pattern 之后检查字符串中是否没有匹配项，但不消费输入字符串。

零宽断言（Zero-width assertions）是正则表达式中的一种特殊语法，用于在匹配模式中指定一个位置但不消耗字符。它们提供了一种条件匹配的方式，但不会使匹配结果包括在最终的匹配文本中。下面详解零宽断言的概念并给出示例：

零宽断言由以下几种类型：

  1. 正向肯定先行断言（Positive lookahead）：

    • (?=pattern)：匹配一个位置，其后紧跟的内容满足 pattern 才返回匹配结果。
    • 也称为零宽正预测先行断言。

    示例：

    • 正则表达式 \w+(?=\.)，用于匹配一个单词后紧跟着一个句点的情况。 (?=\.) 是一个正向肯定先行断言。
    • 输入文本 “apple.” 中的 “apple” 将匹配这个正则表达式，因为 (?=\.) 要求 “apple” 后面必须是一个句点。

  2. 正向否定先行断言（Negative lookahead）：

    • (?!pattern)：匹配一个位置，其后紧跟的内容不满足 pattern 才返回匹配结果。
    • 也称为零宽负预测先行断言。

    示例：

    • 正则表达式 \d+(?!\.)，用于匹配一个数字，但不能后跟一个句点的情况。 (?!\.)) 是一个正向否定先行断言。
    • 输入文本 “123” 将匹配这个正则表达式，因为它不后跟一个句点，而输入文本 “123.” 不会匹配。

  3. 反向肯定后发断言（Positive lookbehind）：

    • (?<=pattern)：匹配一个位置，其前面紧邻的内容满足 pattern 才返回匹配结果。
    • 也称为零宽正回顾后发断言。

    示例：

    • 正则表达式 (?<=https://)\w+，用于匹配以 “https://” 开头的域名。 (?<=https://) 是一个反向肯定后发断言。
    • 输入文本 “https://example.com” 中的 “example” 将匹配这个正则表达式，因为 (?<=https://) 要求前面是 “https://”。

  4. 反向否定后发断言（Negative lookbehind）：

    • (?<!pattern)：匹配一个位置，其前面紧邻的内容不满足 pattern 才返回匹配结果。
    • 也称为零宽负回顾后发断言。

    示例：

    • 正则表达式 (?<!\d)\.\d+，用于匹配一个小数点前面不是数字的情况。 (?<!\d) 是一个反向否定后发断言。
    • 输入文本 “.456” 将匹配这个正则表达式，因为它前面不是数字，而输入文本 “1.456” 不会匹配。

8.4 分组嵌套与递归

  • 分组可以嵌套使用，以构建复杂的匹配模式。

  • 通过使用递归匹配模式，可以让正则表达式重复自身。

分组嵌套和递归是正则表达式中一种高级的功能，用于处理复杂的模式匹配情况。

  1. 分组嵌套：

    • 分组嵌套允许将一个捕获分组放在另一个捕获分组中。

    • 分组嵌套使用小括号 ( ) 来表示，可以在括号内嵌套其他分组。

    • 分组嵌套可以用于更复杂的模式匹配并在捕获结果中获取多层的分组内容。

    示例：

    • 正则表达式 ((\w+)\s?)+，用于匹配多个由单词和可选空格组成的字符串。在这个表达式中，外层分组 ((\w+)\s?) 嵌套了内层分组 (\w+)。
    • 输入文本 “Hello World” 将匹配这个正则表达式，并且可以通过捕获分组来获取 “Hello” 和 “World” 两个单词。

  2. 递归：

    • 递归正则表达式允许一个模式在自身中重复出现。

    • 递归表达式使用条件语句 (?(condition)yes-pattern|no-pattern) 来表示，其中 condition 是一个子模式，以判断是否执行 yes-pattern 或 no-pattern。

    • 递归模式通过在 yes-pattern 中引用整个正则表达式本身实现。

    示例：

    • 正则表达式 (\d+(?R)?)+，用于匹配多个连续的数字。其中 (?R) 是对整个正则表达式的递归引用。
    • 输入文本 “123456789” 将匹配这个正则表达式，因为它匹配了连续的数字。通过递归引用，这个表达式可以匹配含有多个连续数字的情况，例如 “123456789123”。

使用分组嵌套和递归，可以更灵活地构建复杂的模式匹配逻辑。它们为正则表达式提供了更强大的能力，用于解决一些需要多层嵌套或重复出现的匹配问题。然而，需要注意的是，复杂的递归表达式可能会导致性能问题，因此在使用时需要谨慎。

8.5 忽略大小写

在Java正则表达式中，可以通过在正则表达式的开头添加(?i)标记来实现忽略大小写匹配。这个标记使得整个正则表达式都不区分大小写。

下面是示例代码：

		import java.util.regex.Matcher;import java.util.regex.Pattern;public class IgnoreCaseExample {public static void main(String[] args) {String text = "Hello, World!";Pattern pattern = Pattern.compile("(?i)hello");Matcher matcher = pattern.matcher(text);if (matcher.find()) {System.out.println("Match found");} else {System.out.println("Match not found");}}}

在上面的例子中，(?i)标记使得正则表达式中的 “hello” 不区分大小写，所以它可以匹配 “Hello”。输出将会是 “Match found”。

8.6 代码示例

示例1：

import java.util.regex.Matcher;
import java.util.regex.Pattern;public class GroupingExample {public static void main(String[] args) {String text = "Hello, my email address is example@email.com";// 使用捕获分组Pattern pattern1 = Pattern.compile("(\\w+)@(\\w+\\.\\w+)");Matcher matcher1 = pattern1.matcher(text);while (matcher1.find()) {String fullMatch = matcher1.group(0); // 整个匹配的文本String username = matcher1.group(1); // 第1个捕获组，匹配邮箱前面的内容String domain = matcher1.group(2); // 第2个捕获组，匹配邮箱后面的域名部分System.out.println("Full match: " + fullMatch);System.out.println("Username: " + username);System.out.println("Domain: " + domain);}// 使用零宽断言Pattern pattern2 = Pattern.compile("(?=\\bhello\\b)hello, (world)");Matcher matcher2 = pattern2.matcher("hello, world");while (matcher2.find()) {String hello = matcher2.group(0); // 整个匹配的文本String world = matcher2.group(1); // 第1个捕获组，匹配worldSystem.out.println("Hello: " + hello);System.out.println("World: " + world);}// 使用递归匹配模式String nestedText = "{{{{{{text}}}}}}";Pattern pattern3 = Pattern.compile("(\\{\\g<1>*\\})text");Matcher matcher3 = pattern3.matcher(nestedText);while (matcher3.find()) {String match = matcher3.group(0); // 整个匹配的文本System.out.println("Match: " + match);}}
}

示例2：如何识别组号？

只看左括号，不看有括号，按照左括号的顺序，从左往右，依次为第一组，第二组，第三组等等

//需求1:判断一个字符串的开始字符和结束字符是否一致?只考虑一个字符
//举例: a123a b456b 17891 &abc& a123b(false)
// \\组号:表示把第X组的内容再出来用一次
String regex1 = "(.).+\\1";
System.out.println("a123a".matches(regex1));
System.out.println("b456b".matches(regex1));
System.out.println("17891".matches(regex1));
System.out.println("&abc&".matches(regex1));
System.out.println("a123b".matches(regex1));
System.out.println("--------------------------");//需求2:判断一个字符串的开始部分和结束部分是否一致?可以有多个字符
//举例: abc123abc b456b 123789123 &!@abc&!@ abc123abd(false)
String regex2 = "(.+).+\\1";
System.out.println("abc123abc".matches(regex2));
System.out.println("b456b".matches(regex2));
System.out.println("123789123".matches(regex2));
System.out.println("&!@abc&!@".matches(regex2));
System.out.println("abc123abd".matches(regex2));
System.out.println("---------------------");//需求3:判断一个字符串的开始部分和结束部分是否一致?开始部分内部每个字符也需要一致
//举例: aaa123aaa bbb456bbb 111789111 &&abc&&
//(.):把首字母看做一组
// \\2:把首字母拿出来再次使用
// *:作用于\\2,表示后面重复的内容出现日次或多次
String regex3 = "((.)\\2*).+\\1";
System.out.println("aaa123aaa".matches(regex3));
System.out.println("bbb456bbb".matches(regex3));
System.out.println("111789111".matches(regex3));
System.out.println("&&abc&&".matches(regex3));
System.out.println("aaa123aab".matches(regex3));

示例3：

需求:

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

​ 替换为：我要学编程

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

示例4：

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

示例5 ：

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

//身份证号码的简易正则表达式
//非捕获分组:仅仅是把数据括起来
//特点:不占用组号
//这里\\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));

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/635749.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

用Go plan9汇编实现斐波那契数列计算

用Go plan9汇编实现斐波那契数列计算

斐波那契数列是一个满足递推关系的数列&#xff0c;如&#xff1a;1 1 2 3 5 8 ... 其前两项为1&#xff0c;第3项开始&#xff0c;每一项都是其前两项之和。 用Go实现一个简单的斐波那契计算逻辑 func fib(n int) int {if n 1 || n 2 {return 1}return fib(n-1) fib(n-2) …
阅读更多...
MySQL---视图索引

MySQL---视图索引

表定义&#xff1a; 学生表&#xff1a;Student (Sno, Sname, Ssex , Sage, Sdept) 学号&#xff0c;姓名&#xff0c;性别&#xff0c;年龄&#xff0c;所在系 Sno为主键 课程表&#xff1a;Course (Cno, Cname,) 课程号&#xff0c;课程名 Cno为主键 学生选课表&#xff1a;S…
阅读更多...
Redis设置开机自启动

Redis设置开机自启动

1.新建一个系统服务文件 首先输入命令&#xff1a;vi /etc/systemd/system/redis.service 进入vim后粘贴下方代码&#xff0c;注意查看地址是否一致。 ExecStart后面接的是你的redis-server的安装位置和redis配置文件的目录 [Unit] Descriptionredis-server Afternetwork.ta…
阅读更多...
Pycharm无法刷新远程解释器的框架: Can‘t get remote credentials for deployment server

Pycharm无法刷新远程解释器的框架: Can‘t get remote credentials for deployment server

在Pycharm上部署项目到远程服务器&#xff0c;有时候需要启动SSH会话&#xff0c;启动的时候发现没反应&#xff0c;且事件日志显示&#xff1a;无法刷新远程解释器的框架: Can’t get remote credentials for deployment server 观察pycharm界面最下边&#xff0c;发现“无默…
阅读更多...
怎样陪孩子度过一个充实的假期?

怎样陪孩子度过一个充实的假期?

你好&#xff0c;我是白丽丽。之前我作为得到图书的负责人&#xff0c;为你介绍过李希贵校长的《家庭教育指南》这本书的使用方法&#xff0c;今天我和你聊聊&#xff0c;怎么用这本书来迎接假期里的一个个挑战&#xff0c;帮助你和孩子度过一个充实的假期。 作为家长&#xf…
阅读更多...
2024最新最全：【CISP系列考试大纲】零基础入门到精通

2024最新最全：【CISP系列考试大纲】零基础入门到精通

CISP&#xff08;Certified Information Security Professional&#xff09;中文全称注册信息安全专业人员认证&#xff0c;是经中国信息安全测评中心依据中编办批准开展“信息安全人员培训与资质认证”的职能&#xff0c;推出的代表国家对信息安全专业人员能力认可的证书。 C…
阅读更多...
数据结构——排序

数据结构——排序

前言&#xff1a;哈喽小伙伴们好久不见&#xff0c;也是顺利的考完试迎来了寒假。众所周知&#xff0c;不怕同学是学霸&#xff0c;就怕学霸放寒假&#xff0c;假期身为弯道超车的最佳时间&#xff0c;我们定然是不能懒散的度过。 今天我们就一起来学习数据结构初阶的终章——…
阅读更多...
不要让努力变成一种自虐

不要让努力变成一种自虐

当我们为了工作而连续熬夜&#xff0c;不顾身体健康&#xff0c;可能只是在自虐。举个例子&#xff0c;长时间的工作压力和过度努力可能导致身体和心理的疲惫&#xff0c;反而影响到工作效率和生活质量。正确的努力包括合理的工作时间、科学的工作方式&#xff0c;以及关注自己…
阅读更多...
嵌入式软件工程师面试题——2025校招社招通用(Linux篇)（二十六）

嵌入式软件工程师面试题——2025校招社招通用(Linux篇)（二十六）

说明&#xff1a; 面试群&#xff0c;群号&#xff1a; 228447240面试题来源于网络书籍&#xff0c;公司题目以及博主原创或修改&#xff08;题目大部分来源于各种公司&#xff09;&#xff1b;文中很多题目&#xff0c;或许大家直接编译器写完&#xff0c;1分钟就出结果了。但…
阅读更多...
仰暮计划|“学校四周无围墙，教室通风望天窗”

仰暮计划|“学校四周无围墙，教室通风望天窗”

一九七二年高中毕业&#xff0c;我成了回乡青年。玉米地里抡过锄&#xff0c;当阳峪村烧白干&#xff0c;化肥厂内装卸车&#xff0c;深山修渠扛石块。一九七四年十月&#xff0c;村革委会主任找我谈话&#xff0c;“回乡二年来&#xff0c;你无论是政治思想改造&#xff0c;还…
阅读更多...
spring security oauth2login 默认配置分析

spring security oauth2login 默认配置分析

版本 spring-security:6.2.1 源码 org.springframework.security.config.annotation.web.configurers.oauth2.client.OAuth2LoginConfigurer public void init(B http) throws Exception {...if (this.loginPage ! null) {// 使用自定义登录页面super.loginPage(this.loginP…
阅读更多...
Webpack5入门到原理9：处理字体图标资源

Webpack5入门到原理9：处理字体图标资源

1. 下载字体图标文件 打开阿里巴巴矢量图标库选择想要的图标添加到购物车&#xff0c;统一下载到本地 2. 添加字体图标资源 src/fonts/iconfont.ttfsrc/fonts/iconfont.woffsrc/fonts/iconfont.woff2src/css/iconfont.css/注意字体文件路径需要修改 src/main.js import { …
阅读更多...
Python爬虫从入门到入狱系列合集

Python爬虫从入门到入狱系列合集

我 的 个 人 主 页&#xff1a;&#x1f449;&#x1f449; 失心疯的个人主页 &#x1f448;&#x1f448; 入 门 教 程 推 荐 &#xff1a;&#x1f449;&#x1f449; Python零基础入门教程合集 &#x1f448;&#x1f448; 虚 拟 环 境 搭 建 &#xff1a;&#x1f449;&…
阅读更多...
ES框架详解

ES框架详解

ES框架详解 1、全文检索的介绍 ​ 那么对于一般的公司&#xff0c;初期是没有那么多数据的&#xff0c;所以很多公司更倾向于使用传统的数据库&#xff1a;mysql&#xff1b;比如我们要查找关键字”传智播客“&#xff0c;那么查询的方式大概就是:select * from table where …
阅读更多...
公平与公正对团队的好处

公平与公正对团队的好处

公平与公正对团队的好处 如何联系我 作者&#xff1a;鲁伟林 邮箱&#xff1a;thinking_fioa163.com或vlinyes163.com 版权声明&#xff1a;文章和记录为个人所有&#xff0c;如果转载或个人学习&#xff0c;需注明出处&#xff0c;不得用于商业盈利行为。 一、什么是公平…
阅读更多...
米贸搜|Facebook我的广告系列投放量不足、减慢或停了，怎么排查问题？

米贸搜|Facebook我的广告系列投放量不足、减慢或停了，怎么排查问题？

如果你在使用Meta Advantage广告系列预算&#xff0c;并且对目前得到的投放量不是很满意&#xff0c;可以重点关注下这篇内容。 正文开始之前再重申几个概念&#xff1a; 每日预算是一周内的平均每日支出&#xff0c;在一定的日子里可能会比我们的预算高出25%左右&#xff0c…
阅读更多...
网络文件共享ftp

网络文件共享ftp

一&#xff0c;存储类型 &#xff08;一&#xff09;三种存储类型介绍 直连式存储&#xff1a;Direct-Attached Storage&#xff0c;简称DAS 直连&#xff1a;硬盘加服务器 存储区域网络&#xff1a;Storage Area Network&#xff0c;简称SAN&#xff08;可以使用空间&#…
阅读更多...
解决Spring Boot应用打包后文件访问问题

解决Spring Boot应用打包后文件访问问题

在Spring Boot项目的开发过程中&#xff0c;一个常见的挑战是如何有效地访问和操作资源文件。这一挑战尤其显著当应用从IDE环境&#xff08;如IntelliJ IDEA&#xff09;迁移到被打包成JAR文件后的生产环境。开发者经常遇到的问题是&#xff0c;在IDE中运行正常的代码&#xff…
阅读更多...
Android-三方框架的源码

Android-三方框架的源码

ARouter Arouter的整体思路是moduelA通过中间人ARouter把路由信息的存到仓库WareHouse&#xff1b;moduleB发起路由时&#xff0c;再通过中间人ARouter从仓库WareHouse取出路由信息&#xff0c;这要就实现了没有依赖的两者之间的跳转与通信。其中涉及Activity的跳转、服务prov…
阅读更多...
tomcat与servlet

tomcat与servlet

目录 一、Http服务器 二、tomcat 1、概念 2、tomcat解压缩文件 &#xff08;1&#xff09;bin文件夹 &#xff08;2&#xff09;conf文件夹 &#xff08;3&#xff09;logs &#xff08;4&#xff09;webapps 3、借助tomcat服务器访问网页 三、servlet 1、概念 2、s…
阅读更多...
最新文章

Copyright @ 2022~2023