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

123adbsd

d

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

参考答案

1. a.replaceAll(“(m|M)[o]+n”, “moon”)

2. a.replaceAll(“[^a-zA-Z]”, “”)

3. String[] b = a.split(“([^\w])+”)

4. String[] b = a.split(“([^\w])+”,-1);

5. String[] b = a.split(“([^\w])+”,2);

6. a.matches(“^.([a-zA-Z])\1{3,}+.$”)

7. a.matches(“^.([0-9])\1{3,}+.$”)
| a.matches(“^.([\d])\1{3,}+.$”)

8. a.matches(“^.([a-zA-Z]{4,}).\1+.*$”)