长沙旅游网站开发,阿里巴巴官网下载app,北京移动端网站价格,wordpress企业主题教程介绍
为什么需要 正则表达式是处理文本的利器#xff1b;
基本介绍 正则表达式#xff0c;又称规则表达式,#xff08;Regular Expression#xff0c;在代码中常简写为regex、regexp或RE#xff09;。它是一个强大的字符串处理工具#xff0c;可以对字符串进行查找、提…介绍
为什么需要 正则表达式是处理文本的利器
基本介绍 正则表达式又称规则表达式,Regular Expression在代码中常简写为regex、regexp或RE。它是一个强大的字符串处理工具可以对字符串进行查找、提取、分割、替换等操作是一种可以用于模式匹配和替换的规范 一个正则表达式就是由普通的字符如字符 a~z以及特殊字符元字符组成的文字模式用以描述在查找文字主体时待匹配的一个或多个字符串。 jdk1.4推出 java.util.regex 包它包含了 Pattern 和 Matcher 类用于处理正则表达式的匹配操作。
package com.lhy.regex;import java.util.regex.Matcher;
import java.util.regex.Pattern;/*** 分析java的正则表达式的底层实现(重要.)*/
public class RegTheory {public static void main(String[] args) {String content 1998年12月8日第二代Java平台的企业版J2EE发布 ;//目标匹配所有四个数字//说明//1. \\d 表示一个任意的数字String regStr (\\d\\d)(\\d\\d);//2. 创建一个模式对象[即正则表达式对象]Pattern pattern Pattern.compile(regStr);//3. 创建一个匹配器对象//说明创建匹配器matcher 按照 正则表达式的规则(pattern模式) 去匹配 content字符串Matcher matcher pattern.matcher(content);//4.开始循环匹配while (matcher.find()) {//小结//1. 如果正则表达式有() 即分组//2. 取出匹配的字符串规则如下//3. group(0) 表示匹配到的子字符串//4. group(1) 表示匹配到的子字符串的第一组字串//5. group(2) 表示匹配到的子字符串的第2组字串//6. ... 但是分组的数不能越界.System.out.println(找到: matcher.group(0));//找到: 1998System.out.println(第1组()匹配到的值 matcher.group(1));//19System.out.println(第2组()匹配到的值 matcher.group(2));//98}}
} 语法
\\符号说明在我们使用正则表达式去检索某些特殊字符的时候需要用到转义字符否则检测不到结果甚至会报错。
注意在Java的正则表达式中两个\\代表其他语言中的一个\
元字符
限定符
用于指定其前面的字符和组合项连续出现多少次。
符号含义示例说明匹配输入*指定字符重复0次或n次(无要求)零到多(abc)*仅包含任意个abc的字符串等效于\w*abc、 abcabcabc指定字符重复1次或n次至少 一次1到多m(abc)*以至少1个m开头后接任意个abc的字 符串m、mabc、 mabcabc?指定字符重复0次或1次(最多 一次0到1mabc?以至少1个m开头后接ab或abc的字符 串mab、mabc、mmmab. mmabc{}只能输入n个字符[abcd]{3}由abcd中字母组成的任意长度为3的字 符串abc、dbc、adc{n,}指定至少n个匹配[abcd]{3,}由abcd中字母组成的任意长度不小于3的字符串aab、dbc、aaabdc{n,m}指定至少n个但不多于m个匹配[abcd]{3,5}由abcd中字母组成的任意长度不小于3,不大于5的字符串abc、abcd、aaaaa、bcdab java默认为贪婪匹配。 即在限定出现次数里优先匹配出现次数最多的一组。例如用a{3,5}来匹配aaaaaacx,返回的式aaaaa。例如a.*b它将会匹配最长的以a开始以b结束的字符串。如果用它来搜索aabab的 话它会匹配整个字符串aaba。 ?组合的时候它只作用于离他最近的那一个字符。 例如mabc?中?只作用于字符c。 如果想要使用非贪婪匹配懒惰匹配则在限定符后面加上?即可。 a.*?b匹配最短的以a开始以b结束的字符串。如果把它应用于aabab的话它会匹配aab第一到第三个字符和ab第四到第五个字符 选择匹配符
在匹配某个字符串的时候是选择性的即可以匹配这个也可以匹配那个。 符号 符号示例解释|匹配“|”之前或之后的表达式ab|cdab或者cd 分组组合和反向引用符
1、分组 我们可以用圆括号组成一个比较复杂的四配模式那么一个圆括号的部分我们可以看作是一个子表达式或一个分组。
2、捕获分组 把正则表达式中子表达式或分组匹配的内容保存到内存中以数字编号或显式命名的组里方便后面引用从左向右以分组的左括号为标志第一个出现的分组的组号为1第二个为2以此类推。组0代表的是整个正则式。
常用分组构造形式说明(pattern)非命名捕获。捕获匹配的子字符串。编号为零的第一个捕获是由整个正则表达式模式匹配的文本其它捕获结果则根据左括号的顺序从1开始自动编号。在分析底层源码的时候说过(?pattern)命名捕获。将匹配的子字符串捕获到一个组名称或编号名称中。用于name的字符串不能包括任何标点符号并且不能以数字开头。可以使用单引号替代尖括号例如?name String test 020-85653333;
String reg(0\\d{2})-(\\d{8});
Pattern pattern Pattern.compile(reg);
Matcher mc pattern.matcher(test);
if(mc.find()){System.out.println(分组的个数有mc.groupCount());for(int i0;imc.groupCount();i){System.out.println(第i个分组为mc.group(i));}
}
输出结果分组的个数有2
第0个分组为020-85653333
第1个分组为020
第2个分组为85653333String test 020-85653333;
String reg(?quhao0\\d{2})-(?haoma\\d{8});
Pattern pattern Pattern.compile(reg);
Matcher mc pattern.matcher(test);
if(mc.find()){System.out.println(分组的个数有mc.groupCount());System.out.println(mc.group(quhao));System.out.println(mc.group(haoma));
}
输出结果分组的个数有2
分组名称为:quhao,匹配内容为020
分组名称为:haoma,匹配内容为856533333、非捕获分组
常用分组构造形式说明(?:pattern)匹配pattern但不捕获该匹配的子表达式即它是一个非捕获匹配不存储以后使用的匹配。这对于用“or”字符(|)组合模式部件的情况很有用。例如industr(?:y(?pattern)它是一个非捕获匹配。例如windows(?95(?!pattern)该表达式匹配不处于匹配pattern的字符串的起始点的搜索字符串。它是一个非捕获匹配。例如windows(?!95 String test 020-85653333;
String reg(?:0\\d{2})-(\\d{8});
Pattern pattern Pattern.compile(reg);
Matcher mc pattern.matcher(test);
if(mc.find()){System.out.println(分组的个数有mc.groupCount());for(int i0;imc.groupCount();i){System.out.println(第i个分组为mc.group(i));}
}
输出结果分组的个数有1
第0个分组为020-85653333
第1个分组为85653333//正向先行断言
零宽度正预测先行断言语法?pattern作用匹配pattern表达式的前面内容不返回本身。【正向先行断言】可以匹配表达式前面的内容那意思就是(?) 就可以匹配到前面的内容了。Test
public void testAssert1(){String regex .(?/span);String context span class\read-count\阅读数641/span;Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(context);while (matcher.find()){System.out.println(matcher.group());}
}//匹配结果span classread-count阅读数641
//可是我们要的只是前面的数字呀那也简单咯匹配数字 \d,那可以改成Test
public void testAssert2(){String regex \\d(?/span);String context span class\read-count\阅读数641/span;Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(context);while (matcher.find()){System.out.println(matcher.group());}
}//匹配结果
//6414、反向引用 圆括号的内容被捕获后可以在这个括号后被使用从而写出一个比较实用的匹配模式这个我们称为反向引用这种引用既可以是在正则表达式内部也可以是在正则表达式外部内部反向引用\\分组号外部反向引用$分组号。
public class RegTheory {public static void main(String[] args) {String content 123-abc;String regStr (?i1\\d)(?i2\\d);Pattern pattern Pattern.compile(regStr);Matcher matcher pattern.matcher(content);while (matcher.find()){System.out.println(matcher.group(i1));System.out.println(matcher.group(i2));}}
}
// 结果是12正向后行断言零宽度正回顾后发断言断言在前模式在后语法?pattern作用匹配pattern表达式的后面的内容不返回本身。有先行就有后行先行是匹配前面的内容那后行就是匹配后面的内容啦。Test
public void testAssert3(){String regex (?span class\read-count\阅读数)\\d;String context span class\read-count\阅读数641/span;Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(context);while (matcher.find()){System.out.println(matcher.group());}
}Test
public void testRef(){String context aabbxxccdddsksdhfhshh;String regex (\\w)\\1;Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(context);while (matcher.find()){System.out.println(matcher.group());}
}
输出结果aa
bb
xx
cc
dd
hh//请编写一个 Servlet, 可以获取到浏览器所在电脑的操作系统版本和位数(32 还是 64), 显示在页面即可。
//User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/112.0public class ComputerServlet extends HttpServlet {Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {doPost(req,resp);}Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {String user_agent req.getHeader(User-Agent);//1.匹配目标String regStr \\((.*)\\);//2. 创建一个模式对象[即正则表达式对象]Pattern pattern Pattern.compile(regStr);//3. 创建一个匹配器对象//说明创建匹配器matcher 按照 正则表达式的规则(pattern模式) 去匹配 content字符串Matcher matcher pattern.matcher(user_agent);//4.开始循环匹配while (matcher.find()) {//匹配内容放在 matcher.group(0)String group01 matcher.group(1);String[] split group01.split(;);System.out.println(操作系统 split[0]);//Windows NT 10.0System.out.println(操作系统位数 split[1].trim());// Win64}}
} 特殊字符--转义符
需要用到转移符号的字符有以下:. * ( ) $ / \ ? [ ] ^ { } 字符匹配符
符号符号示例解释[]可接收的字符列表[efgh]e、f、g、h中的任意1个字符[^]不接收的字符列表[^abc]除a、b、c之外的任意1个字符 包括数字和特殊符号-连字符A-Z任意单个大写字母.匹配除\n以外的任何字节a…b以a开头b结尾中间包括2个任意字符的长度为4的字符串\\d匹配单个数字字符相当于[0-9]\\d{3}(\\d)?包含3个或4个数字的字符串\\D匹配单个非数字字符相当于[^0-9]\\D(\\d)*以单个非数字字符的开头后接任意个数字字符串\\w匹配单个数字、大小写字母字符相当于[0-9a-zA-Z]\\d{3}\\w{4}以3个数字字符开头的长度为7的数字字母字符串\\W匹配单个非数字大小写字母字符相当于[^0-9a-zA-Z]\\W\\d{2}以至少1个非数字字母字符开头2个数字字符结尾的字符串\\s匹配任何空白字符(空格制表符等)\\S匹配任何非空白字符和\\s刚好相反 定位符
规定要匹配的字符串出现的位置 比如在字符串的开始还是在结束的位置。 符号含义示例说明匹配输入^指定起始字符^[0-9][a-z]*以至少1个数字开头后接任意个小写字 母的字符串123、6aa、555edf$指定结束字符^[0-9]\\-[a-z]$以1个数字开头后接连字符“-”并以至少1个小写字母结尾的字符串1-a\\b匹配目标字符串的边界han\\b这里说的字符串的边界指的是子串间有空格或者是目标字符串的结束位置hanshunping sphan nnhan\\B匹配目标字符串的非边界han\\B和b的含义刚刚相反hanshunping sphan nr 其他
java正则表达式默认是区分字母的大小写。如何实现不区分大小写的方式❓
方式一在需要不区分大小写的表达式前面写上(?i)。但需要注意的是如果是表达式中间的某个字符不区分大小写的时候需要将它们括起来例如:a((?i)b)c。方式二Pattern pat Pattern.compile(regEx,Pattern.CASE_INSENSITIVE); 常用类
Pattern 类模式类
pattern 对象是一个正则表达式的编译表示形式指定为字符串的正则表达式必须首先被编译为此类的实例。然后可将得到的模式用于创建 Matcher 对象依照正则表达式该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中所以多个匹配器可以共享同一模式。
Pattern 类没有公共构造方法首先调用其公共静态编译方法可返回一个 Pattern 对象 该方法接受一个正则表达式作为它的第一个参数,比如:Pattern r Pattern.compile(pattem)
String content hello helloasdas;String regStr hello;Pattern pattern Pattern.compile(regStr);Matcher matcher pattern.matcher(content);while (matcher.find()){System.out.println(matcher.group(0));// 部分匹配这里会匹配到两个hello} boolean matches Pattern.matches(regStr, content);System.out.println(matches);// 这是false因为它是整体匹配即正则表达式去匹配整个字符表示字符串完全符合给出的正则表达式所表示的范围。只要有一个字符不匹配则返回false串。//matches()的底层也只是封装了find()方法。 Matcher 类匹配器类
Matcher 对象是对输入字符串进行解释和匹配操作的引擎与Pattern 类一样Matcher 也没有公共构造方法需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象
Macher类的常用方法
索引方法
序号方法说明1public int start()返回以前匹配的初始索引。2public int start(int group) 返回在以前的匹配操作期间由给定组所捕获的子序列的初始索引3public int end()返回最后匹配字符之后的偏移量。4public int end(int group)返回在以前的匹配操作期间由给定组所捕获子序列的最后字符之后的偏移量。
Pattern pPattern.compile(\\d);
Matcher mp.matcher(aaa2223bb);
m.find();//匹配2223
m.start();//返回3
m.end();//返回7,返回的是2223后的索引号
m.group();//返回2223 Mathcer m2m.matcher(2223bb);
m.lookingAt(); //匹配2223
m.start(); //返回0,由于lookingAt()只能匹配前面的字符串,所以当使用lookingAt()匹配时,start()方法总是返回0
m.end(); //返回4
m.group(); //返回2223 Matcher m3m.matcher(2223bb);
m.matches(); //匹配整个字符串
m.start(); //返回0,原因相信大家也清楚了
m.end(); //返回6,原因相信大家也清楚了,因为matches()需要匹配所有字符串
m.group(); //返回2223bbPattern pPattern.compile(([a-z])(\\d));
Matcher mp.matcher(aaa2223bb);
m.find(); //匹配aaa2223
m.groupCount(); //返回2,因为有2组
m.start(1); //返回0 返回第一组匹配到的子字符串在字符串中的索引号
m.start(2); //返回3
m.end(1); //返回3 返回第一组匹配到的子字符串的最后一个字符在字符串中的索引位置.
m.end(2); //返回7
m.group(1); //返回aaa,返回第一组匹配到的子字符串
m.group(2); //返回2223,返回第二组匹配到的子字符串
查找方法
序号方法说明1public boolean lookingAt() 尝试将从区域开头开始的输入序列与该模式匹配。2public boolean find()尝试查找与该模式匹配的输入序列的下一个子序列。3public boolean find(int start重置此匹配器然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。4public boolean matches()尝试将整个区域与模式匹配。 Test
public void testMatches() {String regex Mary;String content1 Mary;String content2 Mary is very handsome !;String content3 My name is Mary.;Pattern pattern Pattern.compile(regex);Matcher matcher1 pattern.matcher(content1);Matcher matcher2 pattern.matcher(content2);Matcher matcher3 pattern.matcher(content3);System.out.println(matches1(): matcher1.matches());System.out.println(lookingAt1(): matcher1.lookingAt());System.out.println(matches2(): matcher2.matches());System.out.println(lookingAt2(): matcher2.lookingAt());System.out.println(matches3(): matcher3.matches());System.out.println(lookingAt3(): matcher3.lookingAt());
}结果
matches(): true
lookingAt(): true
matches(): false
lookingAt(): true
matches(): false
lookingAt(): false//现在我们使用一下稍微高级点的正则匹配操作,例如有一段文本,里面有很多数字,而且这些数字是分开的,我们现在要将文本中所有数字都取出来,利用java的正则操作是那么的简单. Pattern pPattern.compile(\\d);
Matcher mp.matcher(我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123aaa.com);
while(m.find()) { System.out.println(m.group());
} 输出: 456456
0532214
123 package com.lhy.regex;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class regex02 {public static void main(String[] args) {Pattern pPattern.compile(\\d);Matcher mp.matcher(我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123aaa.com);while(m.find()) {System.out.println(m.group());System.out.print(start:m.start());System.out.println( end:m.end());}}
}则输出: 456456
start:6 end:12
0532214
start:19 end:26
123
start:36 end:39 每次执行匹配操作后start(),end(),group()三个方法的值都会改变,改变成匹配到的子字符串的信息,以及它们的重载方法,也会改变成相应的信息. 注意:只有当匹配操作成功,才可以使用start(),end(),group()三个方法,否则会抛出java.lang.IllegalStateException,也就是当matches(),lookingAt(),find()其中任意一个方法返回true时,才可以使用. 替换方法
序号方法说明1public Matcher appendReplacement(StringBuffer sb, String replacement)实现非终端添加和替换步骤。2public StringBuffer appendTail(StringBuffer sb)实现终端添加和替换步骤。3public String replaceAll(String replacement) 替换模式与给定替换字符串相匹配的输入序列的每个子序列。4public String replaceFirst(String replacement) 替换模式与给定替换字符串匹配的输入序列的第一个子序列。5public static String quoteReplacement(String s)返回指定字符串的字面替换字符串。这个方法返回一个字符串就像传递给Matcher类的appendReplacement 方法一个字面字符串一样工作。
Test
public void testReplace(){String regex Mary;String context My name is Mary, Mary is very handsome. ;String replacement Lucy;Pattern p Pattern.compile(regex);Matcher m p.matcher(context);String result1 m.replaceAll(replacement);System.out.println(result1);String result2 m.replaceFirst(replacement);System.out.println(result2);
}结果
My name is Lucy, itlils is very handsome.
My name is Lucy, itnanls is very handsome. Test
public void testAppend() {String REGEX a*b;String INPUT aabfooaabfooabfooabkkk;String REPLACE -;Pattern p Pattern.compile(REGEX);// 获取 matcher 对象Matcher m p.matcher(INPUT);StringBuffer sb new StringBuffer();m.find();m.appendReplacement(sb, REPLACE);System.out.println(sb);m.find();m.appendReplacement(sb, REPLACE);System.out.println(sb);m.appendTail(sb);System.out.println(sb);
}结果
-
-foo-
-foo-fooabfooabkkkPatternSyntaxException 它表示一个正则表达式模式中的语法错误PatternSyntaxException 是一个非强制异常类 其他
String类中使用正则表达式的方法
方法返回类型功能示例matches()boolean告知此字符串是否匹配给定的正则表达式。-1234.matches(^-?\\d$) truereplaceAll(String regex, String replacement)String使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。a1b2c3.replaceAll([a-zA-z], ) 123replaceFirst(String regex, String replacement)String使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。Hello World! Hello Everyone!.replaceFirst(\\s, ) HelloWorld! Hello Everyone!split(String regex)String[]根据给定正则表达式的匹配拆分此字符串。boo:and:foo.split(:) { boo, and, foo }split(String regex, int limit)String[]根据给定正则表达式的匹配拆分此字符串。boo:and:foo.split(:, 5) { boo, and, foo }
split(String regex, int limit)方法中limit 参数控制模式应用的次数因此影响所得数组的长度。
如果该限制 n 大于 0则模式将被最多应用 n - 1 次数组的长度将不会大于 n而且数组的最后一项将包含所有超出最后匹配的定界符的输入。如果 n 为非正那么模式将被应用尽可能多的次数而且数组可以是任何长度。如果 n 为 0那么模式将被应用尽可能多的次数数组可以是任何长度并且结尾空字符串将被丢弃。例如字符串 boo:and:foo 使用这些参数可生成以下结果
RegexLimit结果:2{ boo, and:foo }:5{ boo, and, foo }:-2{ boo, and, foo }o5{ b, , :and:f, , }o-2{ b, , :and:f, , }o0{ b, , :and:f }
调用此方法的 str.split(regex, n) 形式与以下表达式产生的结果完全相同Pattern.compile(regex).split(str, n)
String content hello helloasdas;
String str content.replaceAll((\\w)\\1, $1);
System.out.println(str); // 结果helo heloasdas String content hehllos;
String regex ^(h)\\w*s$;
boolean matches content.matches(^(h)\\w*s$);
System.out.println(matches); //结果 trueString content hehllos;
String[] hs content.split(h);
for (String h : hs) {System.out.println(h);
} // 结果 e llos 常用正则表达式
校验数字的表达式
1 数字^[0-9]*$
2 n位的数字^\d{n}$
3 至少n位的数字^\d{n,}$
4 m-n位的数字^\d{m,n}$
5 零和非零开头的数字^(0|[1-9][0-9]*)$
6 非零开头的最多带两位小数的数字^([1-9][0-9]*)(.[0-9]{1,2})?$
7 带1-2位小数的正数或负数^(\-)?\d(\.\d{1,2})?$
8 正数、负数、和小数^(\-|\)?\d(\.\d)?$
9 有两位小数的正实数^[0-9](.[0-9]{2})?$
10 有1~3位小数的正实数^[0-9](.[0-9]{1,3})?$
11 非零的正整数^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\?[1-9][0-9]*$
12 非零的负整数^\-[1-9][]0-9*$ 或 ^-[1-9]\d*$
13 非负整数^\d$ 或 ^[1-9]\d*|0$
14 非正整数^-[1-9]\d*|0$ 或 ^((-\d)|(0))$
15 非负浮点数^\d(\.\d)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0|0$
16 非正浮点数^((-\d(\.\d)?)|(0(\.0)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0|0$
17 正浮点数^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9])|([0-9]*[1-9][0-9]*))$
18 负浮点数^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9])|([0-9]*[1-9][0-9]*)))$
19 浮点数^(-?\d)(\.\d)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0|0)$ 校验字符的表达式
1 汉字^[\u4e00-\u9fa5]{0,}$
2 英文和数字^[A-Za-z0-9]$ 或 ^[A-Za-z0-9]{4,40}$
3 长度为3-20的所有字符^.{3,20}$
4 由26个英文字母组成的字符串^[A-Za-z]$
5 由26个大写英文字母组成的字符串^[A-Z]$
6 由26个小写英文字母组成的字符串^[a-z]$
7 由数字和26个英文字母组成的字符串^[A-Za-z0-9]$
8 由数字、26个英文字母或者下划线组成的字符串^\w$ 或 ^\w{3,20}$
9 中文、英文、数字包括下划线^[\u4E00-\u9FA5A-Za-z0-9_]$
10 中文、英文、数字但不包括下划线等符号^[\u4E00-\u9FA5A-Za-z0-9]$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
11 可以输入含有^%,;?$\等字符[^%,;?$\x22]
12 禁止输入含有~的字符[^~\x22] 特殊需求表达式
1 Email地址^\w([-.]\w)*\w([-.]\w)*\.\w([-.]\w)*$
2 域名[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})/.?
3 InternetURL[a-zA-z]://[^\s]* 或 ^https://([\w-]\.)[\w-](/[\w-./?%]*)?$
4 手机号码^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5 电话号码(XXX-XXXXXXX、XXXX-XXXXXXXX、XXX-XXXXXXX、XXX-XXXXXXXX、XXXXXXX和XXXXXXXX)^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$ 6 国内电话号码(0511-4405222、021-87888822)\d{3}-\d{8}|\d{4}-\d{7}
7 身份证号 15或18位身份证^\d{15}|\d{18}$ 15位身份证^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$ 18位身份证^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$ 8 短身份证号码(数字、字母x结尾)^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9 帐号是否合法(字母开头允许5-16字节允许字母数字下划线)^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10 密码(以字母开头长度在6~18之间只能包含字母、数字和下划线)^[a-zA-Z]\w{5,17}$
11 强密码(必须包含大小写字母和数字的组合不能使用特殊字符长度在8-10之间)^(?.*\d)(?.*[a-z])(?.*[A-Z]).{8,10}$ 12 日期格式^\d{4}-\d{1,2}-\d{1,2}
13 一年的12个月(0109和112)^(0?[1-9]|1[0-2])$
14 一个月的31天(0109和131)^((0?[1-9])|((1|2)[0-9])|30|31)$
15 钱的输入格式
16 1.有四种钱的表示形式我们可以接受:10000.00 和 10,000.00, 和没有 分 的 10000 和 10,000^[1-9][0-9]*$
17 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符0不通过,所以我们采用下面的形式^(0|[1-9][0-9]*)$
18 3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号^(0|-?[1-9][0-9]*)$
19 4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了. 把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分^[0-9](.[0-9])?$
20 5.必须说明的是,小数点后面至少应该有1位数,所以10.是不通过的,但是 10 和 10.2 是通过的^[0-9](.[0-9]{2})?$
21 6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样^[0-9](.[0-9]{1,2})?$
22 7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
23 8.1到3个数字,后面跟着任意个 逗号3个数字,逗号成为可选,而不是必须^([0-9]|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
24 备注这就是最终结果了,别忘了可以用*替代如果你觉得空字符串也可以接受的话(奇怪,为什么?) 最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里 25 xml文件^([a-zA-Z]-?)[a-zA-Z0-9]\\.[x|X][m|M][l|L]$
26 中文字符的正则表达式[\u4e00-\u9fa5]
27 双字节字符[^\x00-\xff] (包括汉字在内可以用来计算字符串的长度(一个双字节字符长度计2ASCII字符计1))
28 空白行的正则表达式\n\s*\r (可以用来删除空白行)
29 HTML标记的正则表达式(\S*?)[^]*.*?|.*? / (网上流传的版本太糟糕 上面这个也仅仅能部分对于复杂的嵌套标记依旧无能为力) 30 首尾空白字符的正则表达式^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的 空白字符(包括空格、制表符、换页符等等)非常有用的表达式)
31 腾讯QQ号[1-9][0-9]{4,} (腾讯QQ号从10000开始)
32 中国邮政编码[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
33 IP地址\d\.\d\.\d\.\d (提取IP地址时有用) 应用案例
//将一个文件中的电话的中间四个数字替换成xxxx? 例子 15236985456 -- 152xxxx5456姓名 年龄 邮箱 电话
张小强 23 526845845163.com 13759685424
丁新新 20 238011792qq.com 18011023709
李银龙 20 liyinl1199w163.com 17308811441
赵资本 19 anhuo69579126.com 18234417225
李成刚 21 19713318qq.com 13279906620
王铁柱 20 ykl3987671163.com 18802836971
张龙虎 22 zh199715gmail.com 13888906654
李洁一 18 nl897665yahoo.com 19762297581
刘大志 20 197685551qq.com 15299744196
杨天天 19 86765ytian126.com 17663999002
陈承成 21 rr796232hotmail.com 18137541864Test
public void hidePhoneNumber() throws IOException {StringBuilder sb new StringBuilder();// 1、将文件的内容读取到内存InputStream in new FileInputStream(D:\\user.txt);byte[] buf new byte[1024];int len;while ((len in.read(buf)) 0){sb.append(new String(buf,0,len));}// 2、进行正则匹配String regex (13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])(\\d{4})(\\d{4});Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(sb.toString());String result matcher.replaceAll($1xxxx$3);System.out.println(result);}//通过scanner输入一个字符串判断是否是一个邮箱public class TestEmail {public static void main(String[] args) {Scanner scanner new Scanner(System.in);String email scanner.next();String regex ^[a-zA-Z0-9_-][a-zA-Z0-9_-](\\.[a-zA-Z0-9_-])$;Pattern pattern Pattern.compile(regex);Matcher matcher pattern.matcher(email);boolean matches matcher.matches();if(matches){System.out.println(您输入的是一个邮箱);} else {System.out.println(您输入的不是邮箱);}}
}
