JAVA正则表达式校验密码实战实例
JAVA正则表达式-校验密码实战
Sysrd@RI:loulvlin
send mail to me
校验规则如下：
1. 必须包含数字、字母、特殊字符 三种
2. 长度至少8位
3. 不能包含3位及以上相同字符的重复【eg：x111@q& xxxx@q&1】
4 不能包含3位及以上字符组合的重复【eg：ab!23ab!】
5. 不能包含3位及以上的正序及逆序连续字符【eg：123%@#aop %@#321ao efg3%@#47 3%@#47gfe】
6. 不能包含空格、制表符、换页符等空白字符
7. 键盘123456789数字对应的正序逆序特殊字符：eg：12#$%pwtcp(#$%(345对应的特殊字符#$%，仍视作连续))
8. 支持的特殊字符范围：^$./,;:’!@#%&*|?+()[]{}
按照需求进行正则表达式拆解（从简单开始）
规则1&&8：
str.matches("^.*[a-zA-Z]+.*$") && str.matches("^.*[0-9]+.*$")
&& str.matches("^.*[/^/$/.//,;:'!@#%&/*/|/?/+/(/)/[/]/{/}]+.*$")
规则2：
str.matches("^.{8,}$")
规则3：
!str.matches("^.*(.)\\1{2,}+.*$")
规则4：
!str.matches("^.*(.{3})(.*)\\1+.*$")
规则5&&7：
javaImpl：
first change str to char[]
then for Math.abs(cc[0] - cc[1]) == 1 && (cc[0] - cc[1]) == (cc[1] - cc[2])
如果想去掉特殊字符的连续：
first str.split("[^\\w]+") as str1[]
then for str1[]
then for str1[i] javaImpl：
规则6：
!str.matches("^.*[\\s]+.*$")
正则符号说明
正则表达式（regular expression）描述了一种字符串匹配的模式，可以用来：（1）检查一个串中是否含有符合某个规则的子串，并且可以得到这个子串；（2）根据匹配规则对字符串进行灵活的替换操作
\d 数字 0~9 中的任意一个
\D 非数字
\w 单字字符(0-9,A-Z,a-z) 任意一个字母或数字或下划线
\W 非单字字符
\s 空白(空格符,换行符,回车符,制表符中的任意一个)
\S 非空白
[] 由方括号内的一个字符列表创建的自定义字符类
. 匹配任何单个字符 小数点可以匹配除了换行符（/n）以外的任意一个字符
下面的字符将用于控制将一个子模式应用到匹配次数的过程.
? 重复前面的子模式0次到一次
* 重复前面的子模式0次或多次
+ 重复前面的子模式一次到多次
{m,n} 表达式至少重复m次，最多重复n次
{n} 表达式重复n次
{m,} 表达式至少重复m次
注:方括号中只允许的单个字符,模式“b[aeiou]n”指定,只有以b开头,n结尾,中间是a,e,i,o,u中任意一个的才能匹配上,方括号[]表示只有其中指定的字符才能匹配
如果需要匹配多个字符,那么[]就不能用上了,这里我们可以用()加上|来代替,()表示一组,|表示或的关系,模式b(ee|ea|oo)n就能匹配been,bean,boon等
反向引用
“小括号包含的表达式所匹配到的字符串” 不仅是在匹配结束后才可以使用，在匹配过程中也可以使用。表达式后边的部分，可以引用前面 “括号内的子匹配已经匹配到的字符串”。引用方法是 “/” 加上一个数字。”/1” 引用第1对括号内匹配到的字符串，”/2” 引用第2对括号内匹配到的字符串……以此类推，如果一对括号内包含另一对括号，则外层的括号先排序号。换句话说，哪一对的左括号 “(” 在前，那这一对就先排序号
表达式 “(/w)/1{4,}” 在匹配 “aa bbbb abcdefg ccccc 111121111 999999999” 时，匹配结果是：成功；匹配到的内容是 “ccccc”。再次匹配下一个时，将得到 999999999。这个表达式要求 “/w” 范围的字符至少重复5次，注意与 “/w{5,}” 之间的区别。
正则扩展应用
1 不能包含3位及以上英文字符组合的重复【eg：abe23abee】
!str.matches("^.*(([\\w&&[^0-9_]]){3})(.*)\\1+.*$")
|| !str.matches("^.*(([A-Za-z]){3})(.*)\\1+.*$")
2 用.将IP”192.168.128.33”分隔成String数组
String value = "192.168.128.33";
String[] names = value.split(".");
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
string[] names = value.split(“//.”);
3 将”123adbsd!@%#d$g”用特殊字符分隔成数组，并打出数组的长度
String a = "123adbsd!@%#d$g";
String[] b = a.split("[^\\w]");
String[] c = a.split("[^\\w]+");
System.out.println(b.length);
for (int i = 0; i < b.length; i++) {
System.out.println(b[i]);
}
System.out.println("===========");
System.out.println(c.length);
for (int i = 0; i < c.length; i++) {
System.out.println(c[i]);
}
结果：
6
123adbsdd
g
===========
3
123adbsd
d
g
4 把”2007年12月11日”按年、月、日进行分隔
String str = "2007年12月11日";
Pattern p = Pattern.compile("[年月日]");
String[] dataArr = p.split(str);
for (String strTmp : dataArr) {
System.out.println(strTmp);
}
String[] dataArr1 = str.split("[年月日]");
for (String strTmp : dataArr1) {
System.out.println(strTmp);
}
结果：
2007
12
11
2007
12
11
5 “薪水,职位 姓名;年龄 性别”取出内容
String str="薪水,职位 姓名;年龄 性别";
String[] dataArr =str.split("[,\\s;]");
for (String strTmp : dataArr) {
System.out.println(strTmp);
}
结果：
薪水
职位
姓名
年龄
性别
6 split(String regex, int limit) split(String regex)
注：1. 大于0： 如limit的值为n，那么将对正则表达式使用n-1次
2. 小于0： 不忽略结尾的空串
3. 等于0：这是默认值，忽略结尾的空串
String s = "a0b1c3456";
String ss[] = s.split("\\d");
String ss1[] = s.split("\\d",4);
String ss2[] = s.split("\\d",-3);
for (String str : ss){
System.out.println(str);
}
System.out.println("+++++");
for (String str : ss1){
System.out.println(str);
}
System.out.println("+++++");
for (String str : ss2){
System.out.println(str);
}
System.out.println("+++++");
结果：
a
b
c
+++++
a
b
c
456
+++++
a
b
c+++++
7 replaceAll 贪婪模式 replaceFirst 非贪婪模式
String aString = "aa bbbb abcdefg ccccc 111121111 999999999";
System.out.println(aString.matches("^.*(\\w)\\1{4,}.*$"));
String b = aString.replaceAll("(\\w)\\1{4,}", "A");
String c = aString.replaceFirst("(\\w)\\1{4,}", "B");
System.out.println(b);
System.out.println(c);
结果:
true
aa bbbb abcdefg A 111121111 A
aa bbbb abcdefg B 111121111 999999999
Homework (use regEx)
1、”moon mooon Mon mooooon Mooon”-------->”moon moon moon moon moon”
2、”123123a$%2bdse323$”-------->”abdse”
3、”123123a$%2bdse323$”-------->{“123123a”，”2bdse323”}
4、”123123a$%2bdse323$”-------->{“123123a”，”2bdse323”,”“}
5、”123123a$%2bdse323$”-------->{“123123a”，”2bdse323$”}
6、判断字符串中是否有4个以上相同英文字母
7、判断字符串中是否有4个以上相同数字
8、判断字符串中是否有重复的4个以上英文字母组合，例如12#cdetf123@cdeth
附录
[abc] a, b 或 c（简单类）
[^abc] 除 a, b 或 c 之外的任意字符（取反）
[a-zA-Z] a 到 z，或 A 到 Z，包括（范围）
[a-d[m-p]] a 到 d，或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d，e 或 f（交集）
[a-z&&[^bc]] 除 b 和 c 之外的 a 到 z 字符：[ad-z]（差集）
[a-z&&[^m-p]] a 到 z，并且不包括 m 到 p：[a-lq-z]（差集）
规则实例
规则1&&8：
@Test
public void test4() {
String a1 = "121df@";
String a2 = "123d";
String a3 = "123#";
System.out.println(test5(a1));
System.out.println(test5(a2));
System.out.println(test5(a3));
}
public boolean test5(String str) {
return str.matches("^.*[a-zA-Z]+.*$")
&& str.matches("^.*[0-9]+.*$")
&& str.matches("^.*[/^/$/.//,;:'!@#%&/*/|/?/+/(/)/[/]/{/}]+.*$");
}
result :
true
false
false
规则2：
@Test
public void test4() {
String a1 = "121df@";
String a2 = "123ddfdd";
String a3 = "123#dffff";
System.out.println(test5(a1));
System.out.println(test5(a2));
System.out.println(test5(a3));
}
public boolean test5(String str) {
return str.matches("^.{8,}$");
}
result :
false
true
true
规则3：
@Test
public void test4() {
String a1 = "1222df";
String a2 = "123dddfee";
String a3 = "123#dff";
System.out.println(test5(a1));
System.out.println(test5(a2));
System.out.println(test5(a3));
}
public boolean test5(String str) {
return !str.matches("^.*(.)\\1{2,}+.*$");
}
result :
false
false
true
规则4：
@Test
public void test4() {
String a1 = "1222df222e";
String a2 = "1ddfdd1";
String a3 = "1567#d5678ff";
System.out.println(test5(a1));
System.out.println(test5(a2));
System.out.println(test5(a3));
}
public boolean test5(String str) {
return !str.matches("^.*(.{3})(.*)\\1+.*$");
}
result :
false
true
false
规则5&&7：
@Test
public void test4() {
String a1 = "1234df2234e";
String a2 = "1feddfed1";
String a3 = "1!@#d5!@#ff";
System.out.println(isOrder(a1));
System.out.println(isOrder(a2));
System.out.println(isOrder(a3));
}
private boolean isOrder(String string) {
char[] cc = string.toCharArray();
int length = cc.length;
if (length <= 2) {
return false;
} else if (length == 3) {
if (isOrderImpl(string)) {
return true;
} else {
return false;
}
} else {
String temp = "";
for (int i = 0; i < length; i++) {
if (i + 3 > length) {
break;
}
temp = string.substring(i, i + 3);
if (!isOrderImpl(temp)) {
continue;
} else {
return true;
}
}
return false;
}
}
private boolean isOrderImpl(String string) {
char[] cc = string.toCharArray();
return Math.abs(cc[0] - cc[1]) == 1
&& (cc[0] - cc[1]) == (cc[1] - cc[2]);
}
result :
true
true
false
规则6：
@Test
public void test4() {
String a1 = " ";
String a2 = " ";
System.out.println(test5(a1));
System.out.println(test5(a2));
}
public boolean test5(String str) {
return !str.matches("^.*[\\s]+.*$");
}
result :
false
false