正则表达式—正则表达式补充知识

最新推荐文章于 2024-11-15 20:34:02 发布
最新推荐文章于 2024-11-15 20:34:02 发布
阅读量184 收藏
点赞数
文章标签： 正则表达式 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42814000/article/details/104950619
版权

正则表达式—正则表达式补充知识

在这里插入图片描述

non-capturing groups

non-capturing groups 知识点铺垫1

//non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
//写在前面就算,写在后面就不算（例如：前面的 (?=a).{3}、后面的.{3}(?!a)）

public class Test10_1 {

	public static void main(String[] args) {
		// .{3}：出现3次,说明就是三个字母
		Pattern p = Pattern.compile(".{3}");
		String s = "44a66b";
		Matcher m = p.matcher(s);
		while (m.find()) {
			p(m.group());
		}
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

non-capturing groups 知识点铺垫2

// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
// 写在前面就算,写在后面就不算（例如：前面的 (?=a).{3}、后面的.{3}(?!a)）
public class Test10_2 {

	public static void main(String[] args) {
		
		// 找子串必须以 a 结尾的
		Pattern p = Pattern.compile(".{2}a");
		String s = "44a66b";
		Matcher m = p.matcher(s);
		while (m.find()) {
			p(m.group());
		}
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

non-capturing groups 知识点铺垫3

// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
// 写在前面就算,写在后面就不算（例如：前面的 (?=a).{3}、后面的.{3}(?!a)）
public class Test10_3 {

	public static void main(String[] args) {
		
		// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
		// non-capturing groups(不捕获、不抓获)
		// 使用 non-capturing groups 找子串必须以 a 结尾的
		// (?=a)：()小括号在正常情况下是一个组,这个组是用来匹配字符串的,
		// (?=a)可是如果小括号里面是以 ？ 号打头的,那么它不是用来匹配字符串的
		// ?=a：表示前面这个正则表达式 .{3},3个字母最后结束的是 a
		
		// .{3}(?=a)：3个字母后面马上跟上 一个 a,但是不会把 a 给打印出来
		// (?=a)：不捕获 a,所以不打印 a
		// 所以打印为 444
		Pattern p = Pattern.compile(".{3}(?=a)");
		String s = "444a66b";
		Matcher m = p.matcher(s);
		while (m.find()) {
			p(m.group());
		}
		
		
		// 如果这么写会把 444a 给打印出来
		System.out.println();
		Pattern pp = Pattern.compile(".{3}a");
		String ss = "444a66b";
		Matcher mm = pp.matcher(ss);
		while (mm.find()) {
			p(mm.group());
		}
		
		
		// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
		// 以 a 打头并且捕捉 3 个
		// 输出结果为：a66
		System.out.println();
		Pattern ppp = Pattern.compile("(?=a).{3}");
		String sss = "444a66b";
		Matcher mmm = ppp.matcher(sss);
		while (mmm.find()) {
			p(mmm.group());
		}
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

non-capturing groups 知识点铺垫4

// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
// 写在前面就算,写在后面就不算（例如：前面的 (?=a).{3}、后面的.{3}(?!a)）

public class Test10_4 {

	public static void main(String[] args) {

		// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
		// 以 a 打头并且捕捉 3 个
		// 输出结果为：a66
		Pattern p = Pattern.compile("(?=a).{3}");
		String s = "444a66b";
		Matcher m = p.matcher(s);
		while (m.find()) {
			p(m.group());
		}
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

non-capturing groups 知识点铺垫5

// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
// 写在前面就算,写在后面就不算（例如：前面的 (?=a).{3}、后面的.{3}(?!a)）

public class Test10_5 {

	public static void main(String[] args) {
	
		// 前面不能是 a 的
		// 输出结果 444、66b
		Pattern p = Pattern.compile("(?!a).{3}");
		String s = "444a66b";
		Matcher m = p.matcher(s);
		while (m.find()) {
			p(m.group());
		}
		
		
		// 输出结果 44a、66b
		// 首先找到 444 
		// (?!a)指的是后面跟着的不是 a,444后面跟着的是 a,
		// 所以它继续往后找 44a 后面跟着的不是 a,所以打印 44a
		// 66b 后面跟着的不是 a 所以打印 66b
		System.out.println();
		Pattern pp = Pattern.compile(".{3}(?!a)");
		String ss = "444a66b";
		Matcher mm = pp.matcher(ss);
		while (mm.find()) {
			p(mm.group());
		}
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

non-capturing groups 知识点铺垫6

// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
// 写在前面就算,写在后面就不算（例如：前面的 (?=a).{3}、后面的.{3}(?!a)）

public class Test10_6 {

	public static void main(String[] args) {
		
		// 输出结果 444、a66
		// .{3}(?<!a)：从后往前数不能是 a 的
		// 444 从后往前数不是 a
		// a66 从后往前数不是 a
		Pattern p = Pattern.compile(".{3}(?<!a)");
		String s = "444a66b";
		Matcher m = p.matcher(s);
		while (m.find()) {
			p(m.group());
		}
		
		
		// 输出结果44a
		// .{3}(?<=a)：从后往前数是 a 的,而且包含 a 的,只有 44a 一个
		System.out.println();
		Pattern pp = Pattern.compile(".{3}(?<=a)");
		String ss = "444a66b";
		Matcher mm = pp.matcher(ss);
		while (mm.find()) {
			p(mm.group());
		}
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

non-capturing groups 完整版

// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
// 写在前面就算,写在后面就不算（例如：前面的 (?=a).{3}、后面的.{3}(?!a)）
public class Test10 {

	public static void main(String[] args) {
		// .{3}：出现3次,说明就是三个字母
		Pattern p = Pattern.compile(".{3}");
		String s = "44a66b";
		Matcher m = p.matcher(s);
		while (m.find()) {
			p(m.group());
		}
		
		
		// 找子串必须以 a 结尾的
		System.out.println();
		Pattern pp = Pattern.compile(".{2}a");
		String ss = "44a66b";
		Matcher mm = pp.matcher(ss);
		while (mm.find()) {
			p(mm.group());
		}
		
		// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
		// non-capturing groups(不捕获、不抓获)
		// 使用 non-capturing groups 找子串必须以 a 结尾的
		// (?=a)：()小括号在正常情况下是一个组,这个组是用来匹配字符串的,
		// (?=a)可是如果小括号里面是以 ？ 号打头的,那么它不是用来匹配字符串的
		// ?=a：表示前面这个正则表达式 .{3},3个字母最后结束的是 a
		
		// .{3}(?=a)：3个字母后面马上跟上 一个 a,但是不会把 a 给打印出来
		// (?=a)：不捕获 a,所以不打印 a
		// 所以打印为 444
		System.out.println();
		Pattern ppp = Pattern.compile(".{3}(?=a)");
		String sss = "444a66b";
		Matcher mmm = ppp.matcher(sss);
		while (mmm.find()) {
			p(mmm.group());
		}
		
		
		// 如果这么写会把 444a 给打印出来
		System.out.println();
		Pattern pppp = Pattern.compile(".{3}a");
		String ssss = "444a66b";
		Matcher mmmm = pppp.matcher(ssss);
		while (mmmm.find()) {
			p(mmmm.group());
		}
		
		
		// non-capturing groups(非捕获组)：如果符合这个条件就捕获,如果不符合这个条件就不捕获
		// 以 a 打头并且捕捉 3 个
		// 输出结果为：a66
		System.out.println();
		Pattern ppppp = Pattern.compile("(?=a).{3}");
		String sssss = "444a66b";
		Matcher mmmmm = ppppp.matcher(sssss);
		while (mmmmm.find()) {
			p(mmmmm.group());
		}
		
		// 前面不能是 a 的
		// 输出结果 444、66b
		System.out.println();
		Pattern pppppp = Pattern.compile("(?!a).{3}");
		String ssssss = "444a66b";
		Matcher mmmmmm = pppppp.matcher(ssssss);
		while (mmmmmm.find()) {
			p(mmmmmm.group());
		}
		
		
		// 输出结果 44a、66b
		// 首先找到 444 
		// (?!a)指的是后面跟着的不是 a,444后面跟着的是 a,
		// 所以它继续往后找 44a 后面跟着的不是 a,所以打印 44a
		// 66b 后面跟着的不是 a 所以打印 66b
		System.out.println();
		Pattern ppppppp = Pattern.compile(".{3}(?!a)");
		String sssssss = "444a66b";
		Matcher mmmmmmm = ppppppp.matcher(ssssss);
		while (mmmmmmm.find()) {
			p(mmmmmmm.group());
		}
		

		// 输出结果 444、a66
		// .{3}(?<!a)：从后往前数不能是 a 的
		// 444 从后往前数不是 a
		// a66 从后往前数不是 a
		System.out.println();
		Pattern pppppppp = Pattern.compile(".{3}(?<!a)");
		String ssssssss = "444a66b";
		Matcher mmmmmmmm = pppppppp.matcher(ssssssss);
		while (mmmmmmmm.find()) {
			p(mmmmmmmm.group());
		}
		
		
		// 输出结果44a
		// .{3}(?<=a)：从后往前数是 a 的,而且包含 a 的,只有 44a 一个
		System.out.println();
		Pattern ppppppppp = Pattern.compile(".{3}(?<=a)");
		String sssssssss = "444a66b";
		Matcher mmmmmmmmm = ppppppppp.matcher(sssssssss);
		while (mmmmmmmmm.find()) {
			p(mmmmmmmmm.group());
		}
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

back refenrences(向前引用)

// back refenrences(向前引用)

public class Test11 {

	public static void main(String[] args) {
		// back refenrences
		// 向前引用
		// (\\d\\d):匹配两个数字,找到 12 ,12作为一个结果
		// \\1：代表向前引用,已经找到 12 这个结果了,第一个找到的结果就是 12 
		// \\1：代表的意思是后面找到的结果必须和我第一次找到的结果要一样
		// \\1：代表第一个组捕捉之后的那个字符串
		Pattern p = Pattern.compile("(\\d\\d)\\1");
		String s = "1212";
		Matcher m = p.matcher(s);
		p(m.matches());
		
		
		// (\\d(\\d))：代表两个组,看到一个左括号就是一个组
		System.out.println();
		Pattern pp = Pattern.compile("(\\d(\\d))\\2");
		String ss = "1212";
		Matcher mm = pp.matcher(ss);
		p(mm.matches());
		
		// 与第二个组抓到的要一致
		System.out.println();
		Pattern ppp = Pattern.compile("(\\d(\\d))\\2");
		String sss = "122";
		Matcher mmm = ppp.matcher(sss);
		p(mmm.matches());
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

flags的简写

//flags的简写

public class Test12 {

	public static void main(String[] args) {
		// flags的简写
		// Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
		// non-capturing groups 非捕获组   ((?i))
		// (?i dmsux-i dmsux)：Nothing,but turns match flags on - off
		p("Java".matches("(?i)(java)"));	// 和上面的那种写法一样(上面的简写)
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}
LiniLLLLL.
关注
专栏目录
正则表达式入门要点知识总结
Yydsaoligei的博客
07-19 449
正则表达式
python正则表达式的懒惰匹配和贪婪匹配说明
09-16
5. **补充知识** 在Python正则表达式中，为了提高性能，如果可能的话，应该尽量避免使用懒惰匹配，特别是在处理大文件或大量数据时。如果必须使用，考虑将长正则表达式拆分成多个短表达式，或者使用分组和回调函数...
Javascript捕捉(capturing)与冒泡(bubbling)的区别
12-10 301
　　今天，当我在做nodejs的时候刚巧碰到了javascript的冒泡机制。曾经，我是有看过这方面的知识。但是，已经好久没有碰触javascript的内部原理了。所以，有些淡忘了。我又重新做了下研究并记录于此。 　　我们知道一个网页是由DOM(文档对象模型)控制着结构的。在HTML中很多地方都是一个标签套着另一个标签。这样的结构渲染在页面上的时候你是发现不出层级关系的。当你在页面上操作一...
Python爬虫系列——正则表达式
w04171018的博客
06-10 2820
各位猿媛大家好，我是萌新小农，目前大二在读，正在努力学习Py，希望大家能多多关照和支持。也可以私下交流学习。同时也期望我的文章能够为大家带来帮助和解决大家的一些困惑。努力学习，拿下Py~正则表达式是由一些具有特殊含义的字符组成的字符串，用于描述要匹配的文本模式。正则表达式可以在文本中查找、替换、提取和验证特定的模式。python中，re库拥有全部正则表达式的功能。
【模式串匹配】正则表达式与正则表达式匹配
vector的博客
04-25 569
正则表达式是理论计算机科学和形式语言理论中的一个基本概念，由美国数学家Stephen Cole Kleene提出。
Java知识点：正则表达式
sulia1234567890的博客
03-10 627
目录 1. 概念 2. 用途 3. 元字符 4. 预定义字符类 5. 量词 6. 常用类：Pattern，Matcher 7. 捕获组group() 8. 非捕获组 9. 贪婪匹配与非贪婪匹配 10. 补充 1. 概念 正则表达式是一种可以用于模式匹配和替换的规范。 一个正则表达式就是由普通字符，以及特殊字符（12个元字符）组成的文字模式。 用以描述在查找文字主体时待匹配的一个或多个字符串。 正则表达式作为一个模版，将某个字符模式与所搜索的字符串进行匹配。 2.
javascript 正则表达式补充
2401_84438488的博客
06-17 1024
字符含义\t水平制表符\r回车符\n换行符\f换页符\cX与X对应的控制字符(Ctrl+X)\v垂直制表符\0空字符刚才使用正则我们创建了几个类，来表示数字，字母等，但这样写也很是麻烦，正则表达式为我们提供了几个常用的预定义类来匹配常见的字符字符等价类含义[^\n\r]除了回车符和换行符之外的所有字符\d[0-9]数字字符\D[^0-9]非数字字符\s空白符\S非空白符\w单词字符（字母、数字、下划线）\W非单词字符。
python正则表达式代码_Python 正则表达式
weixin_29952601的博客
02-21 800
任何一种编程语言中，虽然并不总会遇到使用正则表达式的情况，但是，如果一旦到了需要用的场合却不会用，着实会陷入一个困境，所以，正则表达式是一个必要掌握的知识模块。正则表达式(regular expression)描述了一种字符串匹配的模式(pattern)，可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。本文主要是根据最下面 参考资料 1 来整理的，如果后...
JavaScript之正则表达式的使用方法详细介绍
热门推荐
跳探戈的小龙虾的博客
03-22 2万+
首先必须说明的是，这类文章(js正则表达式)在c站或者整个it类论坛是很多人写过的，而我认为我这篇的不同之处在于更加“小白”化，这也与我一贯的风格有关吧。 关于JavaScript正则表达式，其他的文章大多一上来就太过激进，不利于初学者学习(我当粗就是这么被劝退的)，这也是我为什么要坚持写这篇文章，希望小白在看了这篇文章后，不管能不能完全掌握JavaScript正则表达式，但至少对JavaScript正则表达式能有一个比较深刻的印象吧。
java/kotlin正则表达式
杜壁奇的博客
06-23 1813
java正则表达式简单用法
java 正则表达式 and_Java正则表达式
weixin_29250573的博客
02-22 496
作为开发人员，正则是一定会接触到的内容，刚学习编程那时就开始用正则，提取爬虫爬取的页面内容。后面写Linux脚本，用正则过滤一些自己想要的内容。后续还是经常用到这块的知识点，还是需要整理下相关内容。介绍正则表达式(regex)即一种搜索字符串中模式(pattern)。模式可以是任意的字符串，或者是一个复杂的表达式。正则主要应用在字符串的搜索，编辑等操作上。语法1 如下egrep使用的是正则的语法，...
[小小明]Python正则表达式全套笔记v0.3（1.8万字干货）
03-29
Python正则表达式全套笔记v0.3 本文档是小小明个人笔记，涵盖了正则表达式的各个方面，包括各种模式、分组、断言、匹配、查找、替换和切割等。文档中提供了详细的正则匹配规则表，涵盖了基本字符规则、预定义字符集...
24. 正则表达式
flurry_heart的博客
11-13 824
正则表达式（regular expression）又称，是一种文本模式（pattern）。正则表达式使用一个字符串来描述、匹配具有相同规格的字符串，通常被用来检索、替换那些符合某个模式（规则）的文本。正则表达式的核心功能就是处理文本。正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。C++ 标准库从 C++ 11 开始提供了正则表达式（Regular Expressions）的支持，通过<regex>头文件来实现。
第一章Shell编程之正则表达式与文本处理器
2401_86349554的博客
11-14 881
Shell编程之正则表达式与文本处理器
正则表达式那些事儿
Desmend__的博客
11-13 273
当处理文本需要匹配特定的字符串的时候，我们需要使用正则表达式。
学习日志011--模块，迭代器与生成器，正则表达式
最新发布
Z211613347的博客
11-15 645
在之前学习c语言时，我们学了分文件编辑，那么在python中是否存在类似的编写方式？答案是肯定的。python中同样可以实现分文件编辑。甚至还有更多的好处：‌‌：当代码被分成多个文件时，每个文件可以专注于实现特定的功能或模块。这使得查找和修复错误变得更加容易。可以更方便地对代码进行局部修改，而不需要浏览整个项目的代码。‌‌：分文件编程允许开发者使用描述性的文件名，这些文件名能够清晰地传达文件内容或功能。每个文件的内容更加专注和精简，减少了代码的复杂性，使得其他开发者更容易理解代码的逻辑。‌。
如何使用 Python 语言的正则表达式进行网页数据的爬取？
2401_87966921的博客
11-08 531
中查找所有符合该模式的字符串，并返回一个列表。你可以根据实际需求定义不同的正则表达式模式来提取特定的数据，例如提取网址、电话号码、特定格式的文本等。用于模拟浏览器请求头，避免被网站识别为爬虫而被封禁。是一个正则表达式模式，用于匹配邮箱地址。返回的是网页的文本内容。是要爬取的网页地址，
python学习_3.正则表达式
2301_80284843的博客
11-15 400
几乎任何一门通用编程语言都有专门的正则表达式的模块，正则表达式英文是regular expressesion，所以编程语言中的模块名字一般叫。这不再是一个固定的字符串匹配问题，而是一个模式，一种规则的匹配。这里barbar和carcar会匹配上，但harhel不会被匹配，因为它不是3个字符重复的。，把一个正则表达式分成几个部分，这样可以重复某个分组，或者指定两个分组必须相同等额外的要求。下面我们通过8个例子，来熟悉正则表达式，后面再讲写正则表达式的套路和正则表达式的语法。符号用来匹配字符串的开头。
Python 正则表达式进阶用法：字符集与字符范围详解
chusheng1840的博客
11-15 262
通过本文的讲解，我们深入了解了 Python 正则表达式中的字符集和字符范围。这些进阶用法为我们提供了强大的匹配能力，可以应对各种复杂的文本处理任务。通过合理使用字符集和字符范围，我们能够高效地提取文本中的信息，进行数据清洗和转换。在实际应用中，正则表达式的强大功能不仅限于这两个概念，还可以与其他高级特性如分组、反向引用等结合使用，从而实现更为复杂的文本匹配任务。掌握字符集和字符范围，将大大提高我们编写正则表达式的效率和准确性。
30分钟学会正则表达式基础
"正则表达式电子书是针对正则表达式基础知识的入门教程，旨在30分钟内帮助读者理解正则表达式的核心概念，并提供一个初步的了解。该教程覆盖了从元字符、字符转义、重复、字符类到分组、后向引用、零宽断言等多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值