JAVA正则表达式校验密码实战实例

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/dixialieren/article/details/48517009

JAVA正则表达式-校验密码实战


校验规则如下:

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+.*$”)

展开阅读全文

没有更多推荐了,返回首页