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)”都完全相同的情况下，才认定匹配.比如用了这个标志之后，表达式”a\u030A”会匹配”?”.默认情况下，不考虑”规范相等性(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) 在这个模式下,只有’\n’才被认作一行的中止,并且与’.’,’^’,以及’$’进行匹配.

  • 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^$545\E

  • 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^$545\E

方法解释

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

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

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

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)还没有研究明白,等待后续补充.

Java 后台验证的工具类的更多相关文章

  1. Java学习-041-颜色工具类（RGB,HEX）

    在日常的网页开发中,经常需要进行颜色数值获取.转换,例如获取红色,获取蓝色,获取绿色,RGB转十六进制颜色,十六进制颜色转RGB等,因而在学习过程中,写了一个小工具类,仅供各位小主参考! 多不闲言,直 ...

  2. JAVA自动生成正则表达式工具类

    经过很久的努力,终于完成了JAVA自动生成正则表达式工具类.还记得之前需要正则,老是从网上找吗?找了想修改也不会修改.现在不用再为此烦恼了,使用此生成类轻松搞定所有正则表达式.赶快在同事面前炫一下吧. ...

  3. Java后台验证

    前台的js验证,可以通过其他手段绕过,存在安全问题,所以引入Java后台进行验证 一.导入jar包 此为hibernate-validator jar包,进行Java后台验证使用,在Java 1.9及 ...

  4. Rhino+envjs-1.2.js 在java运行网站js 工具类

    java爬虫遇到个页面加密的东西,找了些资料学习学习 做了个java运行js的工具类,希望对大家有用,其中用到client(获取js)可以自行换成自己的client.主要是用了 Rhino就是Java ...

  5. java中常用的工具类（一）

    我们java程序员在开发项目的是常常会用到一些工具类.今天我汇总了一下java中常用的工具方法.大家可以在项目中使用.可以收藏!加入IT江湖官方群:383126909 我们一起成长 一.String工 ...

  6. JAVA中封装JSONUtils工具类及使用

    在JAVA中用json-lib-2.3-jdk15.jar包中提供了JSONObject和JSONArray基类,用于JSON的序列化和反序列化的操作.但是我们更习惯将其进一步封装,达到更好的重用. ...

  7. java 二进制数字符串转换工具类

    java 二进制数字符串转换工具类 将二进制转换成八进制 将二进制转换成十进制 将二进制转换成十六进制 将十进制转换成二进制 package com.iteye.injavawetrust.ad; i ...

  8. Java学习-049-正则工具类

    自去年九月份决定再次入学和职业资格进阶,开始备战二者考试至今,以及当下进行中的职称申请,犹如孤独的狼,不断前行在路上,而今凡凡总总的已历8月... 不感慨了,如下为一园友需要的正则工具类,直接上码: ...

  9. java后端时间处理工具类，返回 "XXX 前" 的字符串

    转自:https://www.cnblogs.com/devise/p/9974672.html 我们经常会遇到显示 "某个之间之前" 的需求(比如各种社交软件,在回复消息时,显示 ...

随机推荐

  1. 计算apk包的安装之后占用空间以及运行时占用内存

    1.统计结果如下 计算apk安装占用空间大小方式 为了方式apk包运行时出现缓存数据等对空间计算造成影响.应该先进行安装,然后分别计算空间变化 所有apk包安装完毕后再运行 开启两个cmd窗口 第一个 ...

  2. oracle命令2

    使用DDL创建和管理表 DBA角色:拥有全部特权,是系统最高权限,只有DBA才可以创建数据库结构,并且系统权限也需要DBA授出,且DBA用户可以操作全体用户的任意基表,包括删除 grant dba t ...

  3. opencv：：将两幅图像合并后，在同一个窗口显示；并将合并的图像流保存成视频文件

    /** * @file main-opencv.cpp * @date July 2014 * @brief An exemplative main file for the use of ViBe ...

  4. Python变量以及类型

    变量的定义 在程序中,有时我们需要对2个数据进行求和,那么该怎样做呢? 大家类比一下现实生活中,比如去超市买东西,往往咱们需要一个菜篮子,用来进行存储物品,等到所有的物品都购买完成后,在收银台进行结账 ...

  5. 【剑指offer】判断出栈序列是否合法

    输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否可能为该栈的弹出顺序.假设压入栈的所有数字均不相等.例如序列1,2,3,4,5是某栈的压入顺序,序列4,5,3,2,1是该压栈序列对应 ...

  6. docker入门 什么是docker? 为什么使用docker?

    1.什么是docker? 轻量级操作系统虚拟化解决方案 2.为什么使用docker? 1.docker的启动是秒级的,比传统虚拟机快很多 2.资源利用率高,一台主机上可同时运行数千个docker容器 ...

  7. 使用Maven

    MyEclipse2015自带有Maven,但是建个工程老出错. (Eclipse J2EE也自带有) 1.下载maven.官网 http://maven.apache.org/download.cg ...

  8. day34进程相关

    进程1 什么是进程    进程指的是一个正在进行/运行的程序,进程是用来描述程序执行过程的虚拟概念    进程vs程序    程序:一堆代码    进程:程序的执行的过程    进程的概念起源于操作系 ...

  9. 小程序开发------mpvue开发时间轴

    亲们支持我的新博客哦==>地址(以后更新会尽量在新博客更新,欢迎大家访问加入我的后宫w) ) 效果展示: 技术栈:mpvue demo==> 代码:

  10. RobotFramework - AppiumLibrary 之元素定位

    一.介绍 AppiumLibrary 是 Robot Framework 的App测试库. 它使用Appium 与Android 和 iOS应用程序进行通信,类似于Selenium WebDriver ...