Java 后台验证的工具类

Java 后台验证的工具类

public class ValidationUtil {

    //手机号

    public static String mobile = "^((13[0-9])|(14[0-9])|(15[0-9])|(16[0-9])|(17[0-9])|(18[0-9])|(19[0-9]))\d{8}$";

    //不允许为空

    public static String blank = ".*[^ ].*";

    //邮件

    public static String email = "^([a-z0-9A-Z]+[-|_|\.]?)+[a-z0-9A-Z]@([0-9a-z_\-]*)(\.(com|cn|inc|org|cc|edu|de)*){1,2}([a-z]{2})?$";

    //QQ，允许为空

    public static String tencentQQAllowNull = "((^$)|([1-9][0-9]{4,11}))";

    //QQ

    public static String tencentQQ = "[1-9][0-9]{4,11}";

    //网址，允许为空

    public static String urlAllowNull = "((^$)|(http|https)+://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?)";

    //网址

    public static String url = "(http|https)+://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?";

    //微信，允许为空

    public static String weixinAllowNull = "((^$)|(^[A-Za-z0-9]\w{3,60}+$))";

    //微信

    public static String weixin = "^[A-Za-z0-9]\w{3,60}+$";

    //正整数

    public static String PositiveInteger = "^[0-9]*[1-9][0-9]*$";

    //年份正则表达式

    public static String YearReg = "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})";

    //正整数或非负数

    public static String NonnegativeNumber ="^(\+?[1-9][0-9]*$)|(([0-9]+\.[0-9]*[0-9][0-9]*))";

    //不允许有任何空白

    public static String NoAnyEmpty = "^[\S]{5,30}$";

    //日期

    public static String DateReg ="^$|^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))$";

    //是否是Double数字类型

    public static boolean isDouble(String value) {

        if (value == null) {

            return false;

        }

        Pattern pattern = Pattern.compile("[0-9]*(\.?)[0-9]*");

        return pattern.matcher(value).matches();

    }

    //是否是Long类型

    public static boolean isValidLong(String str) {

        try {

            Long.parseLong(str);

            return true;

        } catch (NumberFormatException e) {

        }

        return false;

    }

    //是否是Int类型

    public static boolean isValidInt(String str) {

        try {

            Integer.parseInt(str);

            return true;

        } catch (NumberFormatException e) {

        }

        return false;

    }

    public static boolean mobile(String str) {

        return validata(str, mobile);

    }

    public static boolean blank(String str) {

        return validata(str, blank);

    }

    /****

     * 不为空，限制长度范围

     * @param str

     * @param start

     * @param end

     * @return

     */

    public static boolean blankforlenth(String str, int start, int end) {

        String reg = "\S{" + start + "," + end + "}";

        return validata(str, reg);

    }

    /***

     * 非负数

     * @param str

     * @return

     */

    public static boolean nonnegativeNumber(String str) {

        return validata(str, NonnegativeNumber);

    }

    /****

     * 不允许有任何空白

     * @param str

     * @return

     */

    public static boolean noAnyEmpty(String str) {

        return validata(str, NoAnyEmpty);

    }

    /***

     * 日期判断

     * @param str

     * @return

     */

    public static boolean isDateReg(String str) {

        return validata(str, DateReg);

    }

    public static boolean eimail(String str) {

        return validata(str, email);

    }

    public static boolean tencentQQAllNull(String str) {

        return validata(str, tencentQQAllowNull);

    }

    public static boolean tencentQQ(String str) {

        return validata(str, tencentQQ);

    }

    public static boolean webURLAllowNull(String str) {

        return validata(str, urlAllowNull);

    }

    public static boolean webURL(String str) {

        return validata(str, url);

    }

    public static boolean weixinAllowNull(String str) {

        return validata(str, weixinAllowNull);

    }

    public static boolean weixin(String str) {

        return validata(str, weixin);

    }

    public static boolean positiveInteger(String str) {

        return validata(str, PositiveInteger);

    }

    public static boolean isyear(String str) {

        return validata(str, YearReg);

    }

    public static boolean validata(String str, String type) {

        Pattern p = Pattern.compile(type);

        Matcher m = p.matcher(str);

        return m.matches();

    }

    public static void main(String[] args) {

        String xxx = "xxxxx";

        System.out.println(blankforlenth(xxx,5, 10));

    }

}

Java正则表达式Pattern和Matcher类详解

概述

• Pattern类的作用在于编译正则表达式后创建一个匹配模式.
• Matcher类使用Pattern实例提供的模式信息对正则表达式进行匹配
• Pattern complie(String regex) 
  由于Pattern的构造函数是私有的,不可以直接创建,所以通过静态方法compile(String regex)方法来创建,将给定的正则表达式编译并赋予给Pattern类
• String pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数
• Pattern compile(String regex, int flags) 方法功能和compile(String regex)相同,不过增加了flag参数
• int flags() 返回当前Pattern的匹配flag参数. 
  flag参数用来控制正则表达式的匹配行为,可取值范围如下:

Pattern类

常用方法及介绍

---

String regex = "\?|\*";

Pattern pattern = Pattern.compile(regex);

String patternStr = pattern.pattern();//返回?*

---

Pattern.CANON_EQ 当且仅当两个字符的”正规分解(canonical decomposition)”都完全相同的情况下，才认定匹配.比如用了这个标志之后，表达式”au030A”会匹配”?”.默认情况下，不考虑”规范相等性(canonical equivalence)”.

Pattern.CASE_INSENSITIVE(?i) 默认情况下,大小写不明感的匹配只适用于US-ASCII字符集.这个标志能让表达式忽略大小写进行匹配.要想对Unicode字符进行大小不明感的匹 配,只要将UNICODE_CASE与这个标志合起来就行了.

Pattern.COMMENTS(?x) 在这种模式下,匹配时会忽略(正则表达式里的)空格字符(译者注:不是指表达式里的”s”，而是指表达式里的空格,tab,回车之类).注释从#开始,一直到这行结束.可以通过嵌入式的标志来启用Unix行模式.

Pattern.DOTALL(?s)在这种模式下，表达式’.’可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式’.’不匹配行的结束符.

Pattern.MULTILINE(?m)在这种模式下,’^’和’$’分别匹配一行的开始和结束.此外,’^’仍然匹配字符串的开始,’$’也匹配字符串的结束.默认情况下,这两个表达式仅仅匹配字符串的开始和结束.

Pattern.UNICODE_CASE(?u) 在这个模式下,如果你还启用了CASE_INSENSITIVE标志,那么它会对Unicode字符进行大小写不明感的匹配.默认情况下,大小写不敏感的匹配只适用于US-ASCII字符集.

Pattern.UNIX_LINES(?d) 在这个模式下,只有’ ’才被认作一行的中止,并且与’.’,’^’,以及’$’进行匹配.

• Pattern.matcher(CharSequence input) 对指定输入的字符串创建一个Matcher对象
• String[] split(CharSequence input) 
  String[] split(CharSequence input, int limit)
• String[] split(CharSequence input, int limit) 
  功能和String[] split(CharSequence input)相同,增加参数limit目的在于要指定分割的段数
• Pattern.quote(String s) 返回给定的字符串的字面量,关于方法的具体信息请参考123

---

Pattern pattern = Pattern.compile("\?{2}");

Matcher matcher = pattern.matcher("??");

boolean matches = matcher.matches();// true

---

String regex = "\?|\*";

Pattern pattern = Pattern.compile(regex);

String[] splitStrs = pattern.split("123?123*456*456");//123 123 456 456

String[] splitStrs2 = pattern.split("123?123*456*456", 2);// 123 123*456*456

---

String pattern = Pattern.quote("1252343% 8 567 hdfg gf^$545");

System.out.println("Pattern is : "+pattern);

输出信息:

Pattern is : Q1252343% 8 567 hdfg gf^$545E

• matches()方法编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配,该方法适合于该正则表达式只会使用一次的情况,也就是只进行一次匹配工作,因为这种情况下并不需要生成一个Matcher实例.

---

String regex = "\?|\*";

Pattern pattern = Pattern.compile(regex);

boolean matches = pattern.matches(regex, "?");//返回true

Matcher类

常用方法及介绍

• boolean matches() 最常用方法:尝试对整个目标字符展开匹配检测,也就是只有整个目标字符串完全匹配时才返回真值.
• boolean lookingAt() 对前面的字符串进行匹配,只有匹配到的字符串在最前面才会返回true
• boolean find() 对字符串进行匹配,匹配到的字符串可以在任何位置
• int start() 返回当前匹配到的字符串在原目标字符串中的位置
• int end() 返回当前匹配的字符串的最后一个字符在原目标字符串中的索引位置.
• String group() 返回匹配到的子字符串 
  Pattern.start(),Pattern.end(),Pattern.group()代码示例

Pattern pattern = Pattern.compile("\?{2}");

Matcher matcher = pattern.matcher("??");

boolean matches = matcher.matches();//true

System.out.println(matches);

matcher=pattern.matcher("?");

matches = matcher.matches();//false

System.out.println(matches);

Pattern p = Pattern.compile("\d+");

Matcher m = p.matcher("22bb23");

boolean match = m.lookingAt();//true

System.out.println(match);

m = p.matcher("bb2233");

match= m.lookingAt();

System.out.println(match);//false

Pattern p = Pattern.compile("\d+");

Matcher m = p.matcher("22bb23");

m.find();// 返回true

Matcher m2 = p.matcher("aa2223");

m2.find();// 返回true

Matcher m3 = p.matcher("aa2223bb");

m3.find();// 返回true

Matcher m4 = p.matcher("aabb");

m4.find();// 返回false

Pattern p = Pattern.compile("\d+");

Matcher m = p.matcher("aa22bb23");

m.find();

int start = m.start();//2

String group = m.group();//22

int end = m.end();//4

System.out.println(start);

System.out.println(group);

System.out.println(end);

还有一些其他常用的方法,请参考API自行学习或者参考其他博客.

Java正则表达式Pattern.quote()方法详解

标签： java 正则表达式 Pattern quote 字面化

2016年07月27日 22:18:205377人阅读 评论(0) 收藏 举报

 分类：

java基础（5） 

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/yin380697242/article/details/52050023

目录(?)[+]

使用示例

String pattern = Pattern.quote("1252343% 8 567 hdfg gf^$545");

System.out.println("Pattern is : "+pattern);

·         1

·         2

---

输出结果为 
Pattern is : Q1252343% 8 567 hdfg gf^$545E

---

方法解释

在使用quote()方法之后,原有的字符串s变成了QsE的样式,那么Q和E代表什么意思呢?

• Q 代表字面内容的开始
• E 代表字面内容的结束

也就是说,调用Patter.quote()方法之后,原有的字符串被Q..E包裹,返回后的字符串成了正则字面量.举个例子,正则表达式”.*”表示匹配除“ ”之外的任何字符多次.

Pattern pattern = Pattern.compile(".*");

Matcher matcher = pattern.matcher("123");

boolean matches = matcher.matches();//true

System.out.println(matches);

matcher = pattern.matcher("foo");

matches = matcher.matches();//true

System.out.println(matches);

而使用quote()方法,可以把正则表达式”.*”转换为它的字面量,请看下例

String regex = Pattern.quote(".*");

Pattern pattern = Pattern.compile(regex);

Matcher matcher = pattern.matcher("123");

boolean match = matcher.matches();// false

System.out.println(match);

matcher = pattern.matcher("foo");// false

System.out.println(match);

matcher = pattern.matcher(".*");

match = matcher.matches();// true

System.out.println(match);

通过上面例子就可以看出,当使用quote()方法后,将”.*”转换为了它的字面量意思,也就是只能匹配”.*”字符串.用API里面的一句话解释就是Metacharacters or escape sequences in the input sequence will be given no special meaning(使给定的正则表达式没有任何的特殊意义)

Java正则表达式Matcher.group(int group)相关类解析

在Java正则表达式的相关类Matcher中,有如下几个方法: 
- int groupCount() 
- String group(int group) 
- int start(int group) 
- int end(int group) 
- String group(String name) 
- int start(String name) 
- int end(String name)

分组group的概念

首先先来看一段代码,理解一下正则表达式中分组的概念

demo1

String text = "John writes about this, and John writes about that," + " and John writes about everything. ";

String patternString1 = "(John)";

Pattern pattern = Pattern.compile(patternString1);

Matcher matcher = pattern.matcher(text);

System.out.println("groupCount is -->" + matcher.groupCount());

while (matcher.find()) {

    System.out.println("found: " + matcher.group(1));

}

输出结果为

groupCount is –>1 
found: John 
found: John 
found: John

demo2

String text = "John writes about this, and John writes about that," + " and John writes about everything. ";

String patternString1 = "John";

Pattern pattern = Pattern.compile(patternString1);

Matcher matcher = pattern.matcher(text);

System.out.println("groupCount is -->" + matcher.groupCount());

while (matcher.find()) {

    System.out.println("found: " + matcher.group(1));

}

输出结果为:

groupCount is –>0 
Exception in thread “main” java.lang.IndexOutOfBoundsException: No group 1

上面两个例子唯一的区别在于patternString1的值不同,具体表现正则表达式一个带有括号,一个不带括号.因此,我们也可以简单的理解为:

正则表达式中以’()’标记的子表达式所匹配的内容就是一个分组(group).

现在我们继续看一个例子 
demo3

String text = "John writes about this, and John writes about that," + " and John writes about everything. ";

String patternString1 = "(?:John)";

Pattern pattern = Pattern.compile(patternString1);

Matcher matcher = pattern.matcher(text);

System.out.println("groupCount is -->" + matcher.groupCount());

while (matcher.find()) {

    System.out.println("found: " + matcher.group(1));

}

输出结果:

groupCount is –>0 
Exception in thread “main” java.lang.IndexOutOfBoundsException: No group 1

从demo3中可以看到,类似于(?:pattern)格式的子表达式不能算是一个分组.

因此分组的概念我们总结如下: 
1. 正则表达式中以’()’标记的子表达式所匹配的内容就是一个分组(group). 
2. 类似于(?:pattern)格式的子表达式不能算是一个分组

分组索引 group number

还是从demo开始 
demo4

String text = "John writes about this, and John Doe writes about that,"

                + " and John Wayne writes about everything.";

String patternString1 = "(John) (.+?) ";

Pattern pattern = Pattern.compile(patternString1);

Matcher matcher = pattern.matcher(text);

matcher.find();//匹配字符串,匹配到的字符串可以在任何位置

int start = matcher.start();//返回当前匹配到的字符串在原目标字符串中的位置

int end = matcher.end();//返回当前匹配的字符串的最后一个字符在原目标字符串中的索引位置

System.out.println("found group: group(0) is '" + matcher.group(0));

System.out.println("found group: group(1) is '" + matcher.group(1) + "',group(2) is '" + matcher.group(2)+"'");

输出结果为:

found group: group(0) is ‘John writes 
found group: group(1) is ‘John’,group(2) is ‘writes’

从输出结果可以看出,当正则表达式包含多个group时,也就是含有多个’(pattern)’格式的子表达式时,它的分组索引(group number)是从1开始的,而group(0)代表了整个匹配的字符串. 
为了便于理解具体的分组以及分组编号的概念,请参考下图

通过上面的内容,我们就可以完整理解group(int group)函数的使用.总结为一下几点:

1. 类似于(pattern)格式((?:pattern)除外)的正则子表达式就代表的一个分组
2. 分组索引是从1开始的,0代表正则表达式匹配的整个字符串,group(i)代表第i组匹配的内容
3. groupCount() 函数返回当前正则表达式中分组的个数

好了,现在来看int start(int group)和int end(int group)两个函数 
首先呢,先回顾一下如下两个函数: 
1. int start() 返回当前匹配到的字符串在原目标字符串中的位置 
2. int end() 返回当前匹配的字符串的最后一个字符在原目标字符串中的索引位置.

那么加上int 类型的参数group后,其实就是返回指定分组的开始索引与结束索 具体如下例:demo5

String text = "John writes about this, and John Doe writes about that,"

                + " and John Wayne writes about everything.";

String patternString1 = "(John) (.+?) ";

Pattern pattern = Pattern.compile(patternString1);

Matcher matcher = pattern.matcher(text);

matcher.find();//匹配字符串,匹配到的字符串可以在任何位置

int start = matcher.start();//返回当前匹配到的字符串在原目标字符串中的位置

System.out.println(start);//0

int end = matcher.end();//返回当前匹配的字符串的最后一个字符在原目标字符串中的索引位置

System.out.println(end);//12

start = matcher.start(1);//第一个分组匹配的内容,也就是John开始的索引位置,0

System.out.println(start);//0

start = matcher.start(2);//第一个分组匹配的内容,也就是writes开始的索引位置,5

System.out.println(start);//5

end = matcher.end(1);//第一个分组匹配的内容,也就是John结束的索引位置,4

System.out.println(end);//4

end = matcher.end(2);//第二个分组匹配的内容,也就是writes开始的索引位置,12

System.out.println(end);//12

start = matcher.start(3);//Exception in thread "main" java.lang.IndexOutOfBoundsException: No group 3

注意最后一句,当你索引大于正则表达式中实际存在的索引数量,也就是groupCount()返回值是,会抛出异常,所以在使用时记得处理这一点. 
综上所述,可总结如下

1. int start(int group) 返回当前分组匹配到的字符串在原目标字符串中的位置
2. int end(int group) 返回当前分组匹配的字符串的最后一个字符在原目标字符串中的索引位置.

最后呢,就是如下几个函数String group(String name),int start(String name)和int end(String name)还没有研究明白,等待后续补充.