java正则表达式稍微高级一点的用法

2023-11-20 16:50
文章标签 java 用法 高级 正则表达式 一点 稍微

本文主要是介绍java正则表达式稍微高级一点的用法，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1、基础语法回顾

符号含义示例示例描述其他示例
\\b匹配目标字符串的边界，边界指的是串的最后或者空格之前wang\\b匹配边界的wang
\\B匹配目标字符串的非边界wang\\B匹配非边界的wang
\\d和\\D,\\w和\\W\\d和\\D表示[0-9]和[^0-9]，\\w和\\W表示[0-9a-zA-Z]和[^0-9a-zA-Z]
``匹配｜前或者后面的表达式ab|cd匹配ab或者cd
？？只是作用于离它最近的字符生效。
(?!)a(?i)bc匹配abc字符,abc不区分大小写，只有b不区分大小写
``
``
``
``

基本语法测试：

public static void main(String[] args) {String content = "a1_2\n1c_8挖";
//        String regStr = "[a-z]";//匹配a-z之间任意一个字符
//        String regStr = "[^a-z]";//匹配不在a-z之间任意一个字符
//        String regStr = "//D";//匹配不是数字的任意一个字符
//        String regStr = "\\w";//匹配数字、字母（大小写）、下划线的任意一个字符;等价于[a-zA-z0-9_]
//         String regStr = "[a-zA-z0-9.]";
//        String regStr = ".";//匹配除\n之外的所有任意一个字符//        String regStr = "\\s";//匹配空白字符（包括空格、制表、回车）
//        String regStr = "[abcd]";//匹配在abcd中的任意一个字符
//        String regStr = "";//匹配abc字符,abc不区分大小写，只有b不区分大小写："a((?i)b)c"//String regStr = "\\d|挖"; //选择匹配符//String regStr = "_(?!.*_)"; //选择匹配符String regStr = "(_)(\\d)"; //选择匹配符 //创建pattern是制定大小写不敏感Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/);Matcher matcher = pattern.matcher(content);while (matcher.find()){System.out.println("找到字符串【"+matcher.group(0)+"】符合条件");//输出匹配到的整个字符串System.out.println("找到字符串【"+matcher.group(1)+"】符合条件");//输出匹配到的第一个分组System.out.println("找到字符串【"+matcher.group(2)+"】符合条件");//输出匹配到的第二个分组System.out.println("起始位置："+matcher.start());System.out.println("结束位置："+matcher.end());}}//输出
找到字符串【_2】符合条件
找到字符串【_】符合条件
找到字符串【2】符合条件
起始位置：2
结束位置：4
找到字符串【_8】符合条件
找到字符串【_】符合条件
找到字符串【8】符合条件
起始位置：7
结束位置：9

2、分组

分组分为捕获分组和非捕获分组，不捕获的话会更经济些，所以如果不需要捕获就不用捕获

image-20221004175246633

image-20221004175305365

（1）捕获分组示例

    public static void main(String[] args) {String content = "industry1551jkh4546askindustriesldsk4444";String regStr = "(?<thisaname>\\d\\d)\\d\\d";//创建pattern是制定大小写不敏感Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/);Matcher matcher = pattern.matcher(content);while (matcher.find()){System.out.println("找到："+matcher.group(0));System.out.println("找到[通过索引]："+matcher.group(1));System.out.println("找到[通过组名]："+matcher.group("thisaname"));}}
//输出
找到：1551
找到[通过索引]：15
找到[通过组名]：15
找到：4546
找到[通过索引]：45
找到[通过组名]：45
找到：4444
找到[通过索引]：44
找到[通过组名]：44

（2）非捕获分组

    public static void main(String[] args) {String content = "industry1551jkh4546askindustriesldsk4444wwq你好，wwqhello，wwqisagunis";//（1）String regStr = "industr(y|ies)";//分组会被捕获//（2）//String regStr = "industr(?:y|ies)";//分组不被捕获,效果和「industr(y|ies)」一样只是不捕获//（3）//String regStr = "wwq(?=hello|is)";//分组不被捕获。只匹配包含分组条件的前面的匹配字符，此处为匹配后面为hello或者is的wwq//（4）//String regStr = "wwq(?!hello|is)";//分组不被捕获。只匹配包含分组条件的前面的匹配字符，此处为匹配后面不为hello或者is的wwq//创建pattern是制定大小写不敏感Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/);Matcher matcher = pattern.matcher(content);while (matcher.find()){System.out.println("找到："+matcher.group(0));}}
//输出
（1）对应输出：matcher.group(1)输出y或ies找到：industry找到：industries
（2）对应输出：matcher.group(1)异常找到：industry找到：industries
（3）对应输出：matcher.group(1)异常找到：wwq找到：wwq
（4）对应输出：matcher.group(1)异常找到：wwq

3、贪婪匹配

String str="abcaxc";
Patter p="ab.*c";默认是贪婪匹配，匹配到的字符是abcaxc若p改为ab.*c?
则改为非贪婪匹配，匹配到的字符是abc

4、反向引用

括号中的内容被捕获后，在括号的后面可以使用，称为反向引用。这种引用既可以在表达式的内部，也可以在表达式的外部，内部的反向引用使用\\分组号，外部的反向引用使用$分组号

	public static void main(String[] args) {				String content = "我..........我要要....要....学学学....编程!";String regStr = "\\.";//创建pattern是制定大小写不敏感Pattern pattern = Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/);//将...去掉//Matcher matcher = pattern.matcher(content);//content = matcher.replaceAll("");content = content.replaceAll(regStr, "");System.out.println(content);/*1. "(.)\\1+"，首先匹配出重复的字：(我)我，(要)要要，(学)学学2. 将其替换为分组中的字，即 我我-->我，要要要-->要，学学学-->学*/String res = Pattern.compile("(.)\\1+"/*内部反向引用*/).matcher(content).replaceAll("$1"/*外部反向引用*/);System.out.println(res);}//输出
我我要要要学学学编程!
我要学编程!

5、0宽断言

零宽断言是用来判断是否符合继续匹配的条件，本身并不会匹配字符串

符号说明示例示例描述
?=exp匹配到exp就停止
?!exp匹配不到exp才停止
?<=exp匹配到exp则继续
?<!exp匹配不到exp则继续

（1）?=exp

例如，要匹配 cooking ，singing ，doing中除了ing之外的内容，只取cook, sing, do的内容，这时候的增则表达式可以用 [a-z]*(?=ing) 来匹配

注意：先行断言的执行步骤是这样的先从要匹配的字符串中的最右端找到第一个 ing (也就是先行断言中的表达式)然后 再匹配其前面的表达式，若无法匹配则继续查找第二个 ing 再匹配第二个 ing 前面的字符串，若能匹配则匹配，符合正则的贪婪性。

public static void main(String[] args) {String str = "755iwat888iwat";String regexp = "\\d*(?=iwat)";//匹配到exp就停止Matcher matcher = Pattern.compile(regexp).matcher(str);while (matcher.find()){System.out.println(matcher.group(0));}}
//输出
755
//解析，遇到第一个iwat就不再继续往下匹配了

（2）?<=exp

例如 (?<=abc).* 可以匹配 abcdefg 中的 defg

注意：后发断言跟先行断言恰恰相反 它的执行步骤是这样的：先从要匹配的字符串中的最左端找到第一个abc(也就是先行断言中的表达式)然后 再匹配其后面的表达式，若无法匹配则继续查找第二个 abc 再匹配第二个 abc 后面的字符串，若能匹配则匹配。

public static void main(String[] args) {String str = "755iwat888iwat999";String regexp = "(?<=iwat)\\d*".trim();//只匹配iwat后面的连续数字Matcher matcher = Pattern.compile(regexp).matcher(str);while (matcher.find()){System.out.println(matcher.group(0).trim());}}
//输出
888
999

（3）?!exp（和?=exp相反）

例如 (?!exp) 表示 “exp” 前面的位置，如果 “exp” 不成立 ，匹配这个位置；如果 “exp” 成立，则不匹配。

例1：

		public static void main(String[] args) {String str = "755iwat888iwat888999";String regexp = "888(?!.*888)".trim();//最后一次出现的888Matcher matcher = Pattern.compile(regexp).matcher(str);while (matcher.find()){System.out.println(matcher.group(0));System.out.println(matcher.start());}}
//输出
888
14

例2：

public static void main(String[] args) {String str = "755iwat888iwat888999";String regexp = "[0-9]*(?!iwat)".trim();//匹配后面不是iwat的连续数字Matcher matcher = Pattern.compile(regexp).matcher(str);while (matcher.find()){System.out.println(matcher.group(0));//System.out.println(matcher.start());}}
//输出
75
88
888999

（4）?<!exp

和?<=exp相反，放在前面使用

public static void main(String[] args) {String str = "755iwat888iwat888999";String regexp = "(?<!iwat)[0-9]*".trim();//匹配前面不是iwat的连续数字，应是755，88，88999Matcher matcher = Pattern.compile(regexp).matcher(str);while (matcher.find()){System.out.println(matcher.group(0));//System.out.println(matcher.start());}}
//输出
755
88
88999

6、常用API

//  Pattern类的方法
0. Pattern.compile(regStr/*,Pattern.CASE_INSENSITIVE*/)//返回一个Pattern
1. Pattern.matches(regStr,str)//判断模式能否将字符串整体匹配出来，返回一个booleanSystem.out.println(Pattern.matches(regStr,content));
2. Pattern.matcher(content)//返回一个Matcher//  Matcher类的方法
3. Matcher.group(0)//返回匹配到的第0个分组
4. matcher.start()//返回匹配到字符串的开始位置
5. matcher.end()
6. matcher.find()//是否有匹配到的字符串的部分序列
7. matcher.matches()//字符串是否从头到尾完全匹配了(matches方法会吞掉一个matcher匹配的分组)
8. matcher.replaceAll(str)//将匹配到的字符串全部替换为str，返回替换后的字符串//String
9. str.replaceAll(regex,replacement)//使用replacement替换str中匹配的regex部分，返回替换后的字符串
10. str.matches(regex)//等价于Pattern.matches(regex, str)，返回boolean
11. str.split(regex)//按照匹配的regex部分对str进行分割，返回一个字符数组，返回的数组中不包括匹配到的部分

这篇关于java正则表达式稍微高级一点的用法的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/396038。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...
在cscode中通过maven创建java项目

在cscode中通过maven创建java项目

在cscode中创建java项目 可以通过博客完成maven的导入 建立maven项目 使用快捷键 Ctrl + Shift + P 建立一个 Maven 项目 1 Ctrl + Shift + P 打开输入框2 输入 "> java create"3 选择 maven4 选择 No Archetype5 输入 域名6 输入项目名称7 建立一个文件目录存放项目，文件名一般为项目名8 确定
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2