网站开发用什么技术可行性,网址你懂我意思正能量免费,做动物网站的原因是,推广网站弄哪家好Java正则表达式 七、正则表达式7.1 格式7.1.1 字符类注意字符类示例代码1例2 7.1.2 预定义字符预定义字符示例代码例2 7.1.3 区别总结 7.2 使用Pattern和Matcher类与直接使用String类的matches方法的区别。#xff08;1#xff09; 使用Pattern和Matcher类示例代码 #xff… Java正则表达式 七、正则表达式7.1 格式7.1.1 字符类注意字符类示例代码1例2 7.1.2 预定义字符预定义字符示例代码例2 7.1.3 区别总结 7.2 使用Pattern和Matcher类与直接使用String类的matches方法的区别。1 使用Pattern和Matcher类示例代码 2直接使用String类的matches方法示例代码 3区别总结4示例对比使用Pattern和Matcher类 直接使用String类的matches方法 7.3 数量词7.4这是一个正则表达式符号的总结表。7.4.1 各个符号解释 7.4.2 量词总结表。解释 八、爬虫8.1 条件爬取8.1.1 正向预查8.1.2 其他的 8.2贪婪爬取8.3 正则表达式中的方法8.4 分组8.4.1 首尾相同单字符 abc123cba8.4.2 首尾相同多字符abc123abc8.4.3 开始的样式和结束的样式一样aaa12aaa 七、正则表达式
正则表达式是一种强大的文本匹配工具用于在字符串中搜索和匹配特定模式的文本。 在Java中正则表达式由java.util.regex包提供支持。它可以用于验证输入的格式、提取文本中的特定部分、替换文本等操作。
7.1 格式
7.1.1 字符类
字符类用于匹配一组字符中的任意一个字符。字符类用方括号[]括起来表示在这些字符中匹配一个字符。
[abc]匹配字符a、b或c。[^abc]匹配除a、b、c之外的任何字符。[a-zA-Z]匹配从a到z或从A到Z的任意一个字符。[a-d[m-p]]匹配a到d或m到p的任意一个字符。[a-z[def]]匹配a到z和def的交集即d、e、f。[a-z[^bc]]匹配a到z并且不包括b和c的字符(即[ad-z])。[a-z[^m-p]]匹配a到z并且不包括m到p的字符即[a-lq-z]。
注意
[a-z[def]]匹配a到z和def的交集即d、e、f。像这样的必须是两个如果是一个就只是说明其是一个‘’字符符号
字符类示例代码1
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class CharClassExample {public static void main(String[] args) {// 匹配a、b或c中的任意一个字符String regex1 [abc];String input1 apple;System.out.println(matchesPattern(regex1, input1)); // true// 匹配除a、b、c之外的任何字符String regex2 [^abc];String input2 def;System.out.println(matchesPattern(regex2, input2)); // true// 匹配从a到z或从A到Z的任意一个字符String regex3 [a-zA-Z];String input3 Hello;System.out.println(matchesPattern(regex3, input3)); // true// 匹配a到d或m到p的任意一个字符String regex4 [a-d[m-p]];String input4 cat;System.out.println(matchesPattern(regex4, input4)); // true// 匹配a到z和def的交集即d、e、fString regex5 [a-z[def]];String input5 dog;System.out.println(matchesPattern(regex5, input5)); // true// 匹配a到z并且不包括b和c的字符String regex6 [a-z[^bc]];String input6 apple;System.out.println(matchesPattern(regex6, input6)); // true// 匹配a到z并且不包括m到p的字符String regex7 [a-z[^m-p]];String input7 hello;System.out.println(matchesPattern(regex7, input7)); // true}private static boolean matchesPattern(String regex, String input) {Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(input);return matcher.find();}
}例2
public class CharClassExample {public static void main(String[] args) {// 只能是 a b cSystem.out.println(----------1----------);System.out.println(a.matches([abc])); // trueSystem.out.println(k.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到z A到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(0.matches([a-zA-Z])); // false}
}7.1.2 预定义字符
匹配一组字符中的任意一个字符其用于简化正则表达式的书写。
.匹配任意字符。\d匹配一个数字字符相当于[0-9]。\D匹配一个非数字字符相当于[^0-9]。\s匹配一个空白字符包括空格、制表符、换行符等相当于[\t\n\x0B\f\r]。\S匹配一个非空白字符相当于[^\s]。\w匹配一个单词字符包括字母、数字和下划线相当于[a-zA-Z_0-9]。\W匹配一个非单词字符相当于[^\w]。
通过使用这些字符类和预定义字符可以构建出复杂的正则表达式来匹配特定的文本模式。
预定义字符示例代码
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class PredefinedCharExample {public static void main(String[] args) {// 匹配任意字符String regex1 .;String input1 a;System.out.println(matchesPattern(regex1, input1)); // true// 匹配一个数字字符String regex2 \\d;String input2 5;System.out.println(matchesPattern(regex2, input2)); // true// 匹配一个非数字字符String regex3 \\D;String input3 a;System.out.println(matchesPattern(regex3, input3)); // true// 匹配一个空白字符String regex4 \\s;String input4 ;System.out.println(matchesPattern(regex4, input4)); // true// 匹配一个非空白字符String regex5 \\S;String input5 a;System.out.println(matchesPattern(regex5, input5)); // true// 匹配一个单词字符String regex6 \\w;String input6 a;System.out.println(matchesPattern(regex6, input6)); // true// 匹配一个非单词字符String regex7 \\W;String input7 !;System.out.println(matchesPattern(regex7, input7)); // true}private static boolean matchesPattern(String regex, String input) {Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(input);return matcher.find();}
}例2
public class PredefinedCharExample {public static void main(String[] args) {// 匹配任意字符System.out.println(----------1----------);System.out.println(a.matches(.)); // trueSystem.out.println(1.matches(.)); // trueSystem.out.println( .matches(.)); // trueSystem.out.println(\n.matches(.)); // false// 匹配一个数字字符System.out.println(----------2----------);System.out.println(5.matches(\\d)); // trueSystem.out.println(a.matches(\\d)); // false// 匹配一个非数字字符System.out.println(----------3----------);System.out.println(a.matches(\\D)); // trueSystem.out.println(5.matches(\\D)); // false// 匹配一个空白字符System.out.println(----------4----------);System.out.println( .matches(\\s)); // trueSystem.out.println(\t.matches(\\s)); // trueSystem.out.println(a.matches(\\s)); // false// 匹配一个非空白字符System.out.println(----------5----------);System.out.println(a.matches(\\S)); // trueSystem.out.println( .matches(\\S)); // false// 匹配一个单词字符System.out.println(----------6----------);System.out.println(a.matches(\\w)); // trueSystem.out.println(1.matches(\\w)); // trueSystem.out.println(_.matches(\\w)); // trueSystem.out.println(!.matches(\\w)); // false// 匹配一个非单词字符System.out.println(----------7----------);System.out.println(!.matches(\\W)); // trueSystem.out.println(a.matches(\\W)); // false}
}在Java中使用正则表达式进行字符串匹配时字符类和预定义字符的写法有一些区别。以下是两种写法的主要区别
7.1.3 区别总结 字符类 使用方括号[]定义。可以包含单个字符、字符范围或字符集的交集和补集。适用于需要匹配特定字符集合的情况。 预定义字符 使用反斜杠\加特定字符定义。是常用字符类的简写形式。适用于匹配常见字符类型如数字、字母、空白字符等的情况。
7.2 使用Pattern和Matcher类与直接使用String类的matches方法的区别。
1 使用Pattern和Matcher类
这种方法适用于需要多次复用同一个正则表达式的情况。通过编译正则表达式为Pattern对象然后使用Matcher对象进行匹配可以提高效率。
示例代码
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class PatternMatcherExample {public static void main(String[] args) {String regex1 [abc];String input1 apple;System.out.println(matchesPattern(regex1, input1)); // true}private static boolean matchesPattern(String regex, String input) {Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(input);return matcher.find();}
}2直接使用String类的matches方法
这种方法适用于简单的、一次性的正则表达式匹配。String类的matches方法会在内部编译正则表达式并进行匹配适合于不需要复用正则表达式的情况。
示例代码
public class StringMatchesExample {public static void main(String[] args) {// 只能是 a b cSystem.out.println(----------1----------);System.out.println(a.matches([abc])); // trueSystem.out.println(k.matches([abc])); // false}
}3区别总结 使用Pattern和Matcher类 适用于需要多次复用同一个正则表达式的情况。通过编译正则表达式为Pattern对象然后使用Matcher对象进行匹配。提高了效率特别是在需要多次匹配的情况下。 直接使用String类的matches方法 适用于简单的、一次性的正则表达式匹配。每次调用matches方法时都会编译正则表达式并进行匹配。适合于不需要复用正则表达式的情况。
4示例对比
使用Pattern和Matcher类
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class PatternMatcherExample {public static void main(String[] args) {String regex1 [abc];String input1 apple;System.out.println(matchesPattern(regex1, input1)); // true}private static boolean matchesPattern(String regex, String input) {Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(input);return matcher.find();}
}直接使用String类的matches方法
public class StringMatchesExample {public static void main(String[] args) {// 只能是 a b cSystem.out.println(----------1----------);System.out.println(a.matches([abc])); // trueSystem.out.println(k.matches([abc])); // false}
}7.3 数量词
X?X一次或0次X*X零次或多次XX一次或多次X{n}X正好n次X{n,}X至少n次X{n,m}X至少n但不超过m次
这些量词用于正则表达式中来指定字符或子模式的重复次数。
public class RegexExample {public static void main(String[] args) {// 示例1: X?System.out.println(aaab.matches(a?)); // falseSystem.out.println(a.matches(a?)); // trueSystem.out.println(.matches(a?)); // true// 示例2: X*System.out.println(aaab.matches(a*)); // falseSystem.out.println(aaa.matches(a*)); // trueSystem.out.println(.matches(a*)); // true// 示例3: XSystem.out.println(aaab.matches(a)); // falseSystem.out.println(aaa.matches(a)); // trueSystem.out.println(a.matches(a)); // true// 示例4: X{n}System.out.println(aaab.matches(a{2})); // falseSystem.out.println(aa.matches(a{2})); // true// 示例5: X{n,}System.out.println(aaab.matches(a{2,})); // falseSystem.out.println(aaa.matches(a{2,})); // true// 示例6: X{n,m}System.out.println(aaab.matches(a{1,2})); // falseSystem.out.println(aa.matches(a{1,2})); // trueSystem.out.println(a.matches(a{1,2})); // true}
}(?i)这是一个正则表达式的模式修饰符用于忽略大小写。
public class RegexExample {public static void main(String[] args) {// 忽略大小写的书写方式// 在匹配的时候忽略abc的大小写String regex a(?i)bc;System.out.println(----------------------------);System.out.println(abc.matches(regex)); // trueSystem.out.println(ABC.matches(regex)); // trueSystem.out.println(aBC.matches(regex)); // true}
}同样的忽略 X|x与 [Xx]
注意的使用 立大功
public class RegexExample {public static void main(String[] args) {// 忽略大小写的书写方式// 在匹配的时候忽略b的大小写String regex a((?i)b)c;System.out.println(----------------------------);System.out.println(abc.matches(regex)); // trueSystem.out.println(ABC.matches(regex)); // falseSystem.out.println(aBc.matches(regex)); // true}
}7.4这是一个正则表达式符号的总结表。
7.4.1 各个符号
符号含义示例[]里面的内容出现一次[0-9] [a-zA-Z0-9]()分组a(bc)^取反[^abc]交集不能写单个的[a-zm-p]写在方括号外面表示并集.任意字符\n 回车符号不匹配\转义字符\\d\d0-9\\d\D非0-9\\D\s空白字符[ \t\n\x0B\f\r]\S非空白字符[^\\s]\w单词字符[a-zA-Z_0-9]\W非单词字符[^\\w]
解释
[]匹配方括号内的任意一个字符。例如[0-9]匹配任何一个数字。()用于分组。例如a(bc)匹配a后面跟一个或多个bc。^在方括号内表示取反。例如[^abc]匹配任何不是a、b或c的字符。表示交集。例如[a-zm-p]匹配m到p之间的字符。|表示并集。例如x|X匹配x或X。.匹配任意字符除了换行符。\转义字符用于转义特殊字符。\d匹配任何一个数字0-9。\D匹配任何一个非数字字符。\s匹配任何一个空白字符包括空格、制表符、换行符等。\S匹配任何一个非空白字符。\w匹配任何一个单词字符包括字母、数字和下划线。\W匹配任何一个非单词字符。
这些符号和示例可以帮助你更好地理解和使用正则表达式。
7.4.2 量词总结表。
符号含义示例?0次或1次\\d?*0次或多次\\d* (abc)*1次或多次\\d (abc){}具体次数a{7} \\d{7,19}(?i)忽略后面字符的大小写(?i)abca((?i)b)c只忽略b的大小写a((?i)b)c
解释
?匹配前面的字符0次或1次。例如\\d?匹配0个或1个数字。*匹配前面的字符0次或多次。例如\\d*匹配0个或多个数字(abc)*匹配0个或多个abc。匹配前面的字符1次或多次。例如\\d匹配1个或多个数字(abc)匹配1个或多个abc。{}匹配前面的字符具体的次数。例如a{7}匹配7个a\\d{7,19}匹配7到19个数字。(?i)忽略后面字符的大小写。例如(?i)abc匹配abc、ABC、aBc等。a((?i)b)c只忽略b的大小写。例如a((?i)b)c匹配abc、aBc但不匹配ABC。
八、爬虫
8.1 条件爬取
8.1.1 正向预查
要匹配的内容后面加上一个正向预查指定后面的数据需要存在但不包含在匹配结果中。
String text 前面的数据后面的数据;
String pattern 前面的数据(?后面的数据);
Pattern p Pattern.compile(pattern);
Matcher m p.matcher(text);if (m.find()) {System.out.println(m.group());
}在这个示例中正则表达式(?后面的数据)表示匹配前面的数据后面紧跟着后面的数据但只返回前面的数据部分。
8.1.2 其他的
String text 前面的数据后面的数据;
String pattern 前面的数据(?:后面的数据);
Pattern p Pattern.compile(pattern);
Matcher m p.matcher(text);if (m.find()) {System.out.println(m.group());
}非捕获分组不需要再用本组数据仅仅把数据括起来不占组号。 ?:(?)
符号含义?:正则获取所有?正则获取前面?! 正则 获取不是指定内容的前面的部分
8.2贪婪爬取
只写或者·*·就是贪婪爬取 非贪婪爬取 *非贪婪爬取
以下是使用贪婪匹配和非贪婪匹配的正则表达式示例
使用贪婪匹配
String text aaaaaab;
String pattern a;
Pattern p Pattern.compile(pattern);
Matcher m p.matcher(text);while (m.find()) {System.out.println(贪婪匹配结果 m.group());
}使用非贪婪匹配?
String text aaaaaab;
String pattern a?;
Pattern p Pattern.compile(pattern);
Matcher m p.matcher(text);while (m.find()) {System.out.println(非贪婪匹配结果 m.group());
}使用贪婪匹配*
String text aaaaaab;
String pattern a*;
Pattern p Pattern.compile(pattern);
Matcher m p.matcher(text);while (m.find()) {System.out.println(贪婪匹配结果 m.group());
}使用非贪婪匹配*?
String text aaaaaab;
String pattern a*?;
Pattern p Pattern.compile(pattern);
Matcher m p.matcher(text);while (m.find()) {System.out.println(非贪婪匹配结果 m.group());
}这些示例演示了贪婪匹配和非贪婪匹配在正则表达式中的应用。
8.3 正则表达式中的方法
在Java中正则表达式的常用方法包括matches、replaceAll和split。下面是它们的简要介绍
matches用于检查整个字符串是否匹配正则表达式。返回一个布尔值表示是否完全匹配。
String text Hello, World!;
boolean isMatch text.matches(Hello.*);
System.out.println(isMatch); // truereplaceAll用于替换字符串中匹配正则表达式的部分。可以用指定的字符串替换匹配的部分。
String text apple, orange, banana;
String replacedText text.replaceAll(\\b\\w\\b, fruit);
System.out.println(replacedText); // fruit, fruit, fruitsplit根据正则表达式将字符串拆分为子字符串数组。返回一个字符串数组包含根据正则表达式拆分的子字符串。
String text apple,orange,banana;
String[] fruits text.split(a);
for (String fruit : fruits) {System.out.println(fruit);
}
//pple,or
//nge,b
//n
//n这些方法可以帮助你在Java中使用正则表达式进行匹配、替换和拆分字符串。
8.4 分组
在Java中可以使用圆括号()来创建一个分组。
在正则表达式中分组可以对匹配的部分进行逻辑分组以便后续引用或操作。
组号是连续的从1开始不间断的。以左括号为基准。
非捕获分组不需要再用本组数据仅仅把数据括起来不占组号。?:(?)
public class SimplifyString {public static void main(String[] args) {// 定义原始字符串String s aabbbbbbcccc;// 使用正则表达式替换重复的字符// (.) 捕获组匹配任意字符// \\1 量词匹配捕获组1的一次或多次出现// $1 引用捕获组1的内容即匹配的单个字符进行替换String simplified s.replaceAll((.)\\1, $1);// 输出简化后的字符串System.out.println(simplified); // 输出: abc}
}8.4.1 首尾相同单字符 abc123cba
\\组号意味着吧X组的东西在拿来用一次
String regex1(.).\\1;8.4.2 首尾相同多字符abc123abc
String regex1(.).\\1;8.4.3 开始的样式和结束的样式一样aaa12aaa
(.)是把字母看做一组 \\2是把首字母重复 *是把\\2, ——— 0次或者多次
String regex1((.)\\2*).\\1;
