Java正则表达式工具类

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Field;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 常用工具类
 *
 * @version 1.0.0
 * @date 2020/1/5
 */
public class CommonUtil {

    private static final Logger logger = LoggerFactory.getLogger(CommonUtil.class);

    /**
     * 正则表达式：验证手机号
     */
    public static final String REGEX_MOBILE = "^((17[0-9])|(13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$";
    private static final String PDF_FIC_NAME = "name=";

    /**
     * 获取pdf接口返回的图片名称
     *
     * @param url
     * @return java.lang.String
     * @date 2020/1/5
     */
    public static String getPicName(String url) {
        int start = url.lastIndexOf(PDF_FIC_NAME);
        String out = url.substring(start + PDF_FIC_NAME.length());
        return out;
    }

    /**
     * 获取文件后缀
     *
     * @param filepath
     * @return java.lang.String
     * @date 2019/1/5
     */
    public static String getSuffix(String filepath) {
        int ps = filepath.lastIndexOf(".");
        return filepath.substring(ps);
    }

    /**
     * 获取文件前缀
     *
     * @param filepath
     * @return java.lang.String
     * @date 2019/1/5
     */
    public static String getPrefix(String filepath) {
        String end = "";
        int ps = filepath.lastIndexOf(".");
        end = filepath.substring(0, ps);
        return end;
    }

    /**
     * 检查邮件是否合法
     *
     * @param value  邮件地址
     * @param length 长度
     * @return true 邮箱格式合法 false 邮箱格式不合法
     * @date 2019/1/5
     */
    public static boolean checkEmail(String value, int length) {
        if (StringUtils.isBlank(value)) {
            return false;
        }
        return value.matches("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*") && value.length() <= length;
    }

    /**
     * 检查电话输入 是否正确 正确格 式 012-87654321、0123-87654321、0123－7654321
     *
     * @param value
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkTel(String value) {
        return value.matches("\\d{4}-\\d{8}|\\d{4}-\\d{7}|\\d(3)-\\d(8)");
    }

    /**
     * 检查手机输入 是否正确
     *
     * @param mobile
     * @return boolean 校验通过返回true，否则返回false
     * @date 2019/1/5
     */
    public static boolean checkMobile(String mobile) {
        if (StringUtils.isBlank(mobile)) {
            return false;
        }
        return mobile.matches("^[1][3,5,7,0,8,4,9,6]\\d{9}");
    }

    /**
     * 检查中文名输 入是否正确
     *
     * @param value, length
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkChineseName(String value, int length) {
        return value.matches("^[\u4e00-\u9fa5]+{1}") && value.length() <= length;
    }

    /**
     * 检查HTML 中首尾空行或空格
     *
     * @param value
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkBlank(String value) {
        return value.matches("^\\s*|\\s*{1}");
    }

    /**
     * 检查字符串是 否含有HTML标签
     *
     * @param value
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkHtmlTag(String value) {
        return value.matches("<(\\S*?)[^>]*>.*?</\\1>|<.*? />");
    }

    /**
     * 检查URL是 否合法
     *
     * @param value
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkURL(String value) {
        return value.matches("[a-zA-z]+://[^\\s]*");
    }

    /**
     * 检查IP是否 合法
     *
     * @param value
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkIP(String value) {
        return value.matches("\\d{1,3}+\\.\\d{1,3}+\\.\\d{1,3}+\\.\\d{1,3}");
    }

    /**
     * 检查ID是否 合法，开头必须是大小写字母，其他位可以有大小写字符、数字、下划线
     *
     * @param value
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkID(String value) {
        return value.matches("[a-zA-Z][a-zA-Z0-9_]{4,15}{1}");
    }

    /**
     * 检查邮编是否 合法
     *
     * @param value
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkPostCode(String value) {
        return value.matches("[1-9]\\d{5}(?!\\d)");
    }

    /**
     * 检查身份证是 否合法,15位或18位
     *
     * @param value
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkIDCard(String value) {
        return value.matches("\\d{15}|\\d{17}([0-9]|X|x)");
    }

    /**
     * 检查输入是否 超出规定长度
     *
     * @param value, length
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkLength(String value, int length) {
        return ((value == null || "".equals(value.trim())) ? 0 : value.length()) <= length;
    }

    /**
     * 检查是否为空 字符串,空：true,不空:false
     *
     * @param value
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkNull(String value) {
        return value == null || "".equals(value.trim());
    }

    /**
     * 数组转换成字符串
     *
     * @param array, split
     * @return java.lang.String
     * @date 2019/1/5
     */
    public static String arraytostring(Object[] array, String split) {
        StringBuffer sb = new StringBuffer();
        if (null == array) {
            return "";
        }
        for (Object obj : array) {
            sb.append(obj);
            sb.append(split);
        }
        return sb.toString();
    }


    /**
     * 字符串截长
     *
     * @param s, length
     * @return java.lang.String
     * @date 2019/1/5
     */
    public static String bSubstring(String s, int length) {
        if (null == s || "".equals(s)) {
            return "";
        }
        String ss = "";
        byte[] bytes;
        int i;
        try {
            bytes = s.getBytes("Unicode");
            // 表示当前的字节数
            int n = 0;
            i = 2;
            for (; i < bytes.length && n < length; i++) {
                // 奇数位置，如3、5、7等，为UCS2编码中两个字节的第二个字节
                if (i % 2 == 1) {
                    n++; // 在UCS2第二个字节时n加1
                } else {
                    // 当UCS2编码的第一个字节不等于0时，该UCS2字符为汉字，一个汉字算两个字节
                    if (bytes[i] != 0) {
                        n++;
                    }
                }
            }
            // 如果i为奇数时，处理成偶数
            if (i % 2 == 1) {
                // 该UCS2字符是汉字时，去掉这个截一半的汉字
                if (bytes[i - 1] != 0) {
                    i = i - 1;
                }
                // 该UCS2字符是字母或数字，则保留该字符
                else {
                    i = i + 1;
                }
            }
            ss = new String(bytes, 0, i, "Unicode");
            if (bytes.length > length) {
                ss += "...";
            }
        } catch (Exception e) {
            logger.error("### bSubstring e :{}", e);
        }
        return ss;
    }

    /**
     * 分割字符串并保留分割字符
     *
     * @param str   需要分割的字符 如：第一句。第二句！第三句：第四句；第五句。
     * @param regEx 正则表达式：分隔符 如：：|。|！|；
     * @return java.lang.String[]
     * @date 2019/1/5
     */
    public static String[] splitStrIncludeSplitChar(String str, String regEx) {
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        String[] words = p.split(str);

        /* 将句子结束符连接到相应的句子后 */
        if (words.length > 0) {
            int count = 0;
            while (count < words.length) {
                if (m.find()) {
                    words[count] += m.group();
                }
                count++;
            }
        }
        return words;
    }

    /**
     * 把字符串的内容分成N部分 如： str:suxiao1 n：3 则分割出为：sux,iao,1
     *
     * @param str  指定字符串
     * @param part part部分
     * @return java.lang.String[] 分割出的字符串数组
     * @date 2019/1/5
     */
    public static String[] splitPartsOfStr(String str, int part) {
        int strLength = str.length();
        Integer partLength = strLength / part + 1;
        String[] result = new String[part];
        for (int i = 0; i < part; i++) {
            result[i] = str.substring(i * partLength, (i + 1) * partLength > strLength ? strLength : (i + 1) * partLength);
        }
        return result;
    }

    /**
     * 获得简写的字符串：
     *
     * @param str    需要简写的字符串
     * @param length 长度
     * @return java.lang.String
     * @date 2019/1/5
     */
    public static String getAbbreviationStr(String str, int length) {
        return str.length() > length ? (str.subSequence(0, length - 1) + "..") : str;
    }

    /**
     * anotherStrs数组中的是否存在一个元素在strs数组中不包含，
     * 如存在，则返回anotherStrs中第一个不包含的字符 不存在，返回null
     *
     * @param strs        字符串数组
     * @param anotherStrs 另一个字符串数组
     * @return java.lang.String 如：strs:{1,3,4} anotherStrs:{3,4},则返回null
     * strs:{1,3,4} anotherStrs:{2,4},则返回第一个不包含的字符串2
     * @date 2019/1/5
     */
    public static String findAnotherStrsElementNotContainInStrsElement(String[] strs, String[] anotherStrs) {
        List<String> strList = new ArrayList<String>();
        Collections.addAll(strList, strs);
        for (String str : anotherStrs) {
            if (!strList.contains(str)) {
                return str;
            }
        }
        return null;
    }

    /**
     * anotherStrs数组中的是否存在一个元素在strs数组中包含，
     * 如存在，则返回anotherStrs中第一个包含的字符
     * 不存在，返回null
     *
     * @param strs        字符串数组
     * @param anotherStrs 另一个字符串数组
     * @return java.lang.String 如：strs:{2,3,4} anotherStrs:{1,2},则返回2
     * strs:{1,4} anotherStrs:{2,3},则返回null
     * @date 2019/1/5
     */
    public static String findAnotherStrsElementContainInStrsElement(String[] strs, String[] anotherStrs) {
        List<String> strList = new ArrayList<String>();
        Collections.addAll(strList, strs);
        for (String str : anotherStrs) {
            if (strList.contains(str)) {
                return str;
            }
        }
        return null;
    }

    /**
     * 从字符串数组中移除指定字符
     *
     * @param strs 字符串数组
     * @param str  字符
     * @return java.lang.String[] 去掉str的字符串数组
     * @date 2019/1/5
     */
    public static String[] removeStrFromStrArr(String[] strs, String str) {
        List<String> strList = new ArrayList<String>();
        Collections.addAll(strList, strs);
        strList.remove(str);
        String[] strArr = new String[strList.size()];
        return (String[]) strList.toArray(strArr);
    }

   
    /**
     * 校验银行卡卡号
     *
     * @param cardId
     * @return boolean
     * @date 2019/1/5
     */
    public static boolean checkBankCard(String cardId) {
        char bit = getBankCardCheckCode(cardId.substring(0, cardId.length() - 1));
        if (bit == 'N') {
            return false;
        }
        return cardId.charAt(cardId.length() - 1) == bit;
    }

    /**
     * 从不含校验位的银行卡卡号采用 Luhm 校验算法获得校验位
     *
     * @param nonCheckCodeCardId
     * @return char
     * @date 2019/1/5
     */
    public static char getBankCardCheckCode(String nonCheckCodeCardId) {
        if (nonCheckCodeCardId == null || nonCheckCodeCardId.trim().length() == 0 || !nonCheckCodeCardId.matches("\\d+")) {
            // 如果传的不是数据返回N
            return 'N';
        }
        char[] chs = nonCheckCodeCardId.trim().toCharArray();
        int luhmSum = 0;
        for (int i = chs.length - 1, j = 0; i >= 0; i--, j++) {
            int k = chs[i] - '0';
            if (j % 2 == 0) {
                k *= 2;
                k = k / 10 + k % 10;
            }
            luhmSum += k;
        }
        return (luhmSum % 10 == 0) ? '0' : (char) ((10 - luhmSum % 10) + '0');
    }

    public static String xssEncode(String s) {
        if (s == null || "".equals(s)) {
            return s;
        }
        StringBuilder sb = new StringBuilder(s.length() + 16);
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            switch (c) {
                case '>':
                    /** 全角大于号 */
                    sb.append('＞');
                    break;
                case '<':
                    /** 全角小于号 */
                    sb.append('＜');
                    break;
                case '\'':
                    /** 全角单引号 */
                    sb.append('‘');
                    break;
                case '\"':
                    /** 全角双引号 */
                    sb.append('“');
                    break;
                /*
                 * case '&': sb.append('＆');//全角 break;
                 */
                case '\\':
                    /** 全角斜线 */
                    sb.append('＼');
                    break;
                case '#':
                    /** 全角井号 */
                    sb.append('＃');
                    break;
                case '[':
                    /** 全角左小括号 */
                    sb.append('【');
                    break;
                case ']':
                    /** 全角右小括号 */
                    sb.append('】');
                    break;
                case '{':
                    /** 全角左大括号  */
                    sb.append('｛');
                    break;
                case '}':
                    /** 全角右大括号 */
                    sb.append('｝');
                    break;
                default:
                    sb.append(c);
                    break;
            }
        }
        return sb.toString();
    }

    /**
     * 对象转map
     *
     * @param
     * @return
     * @date 2019/10/31
     */
    public static Map objectToMap(Object obj) throws IllegalAccessException {
        Map<String, Object> map = new HashMap<>();
        Class<?> clazz = obj.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            field.setAccessible(true);
            String fileName = field.getName();
            Object value = field.get(obj);
            map.put(fileName, value);
        }
        return map;
    }

    /**
     * 请求参数转map
     *
     * @param queryString
     * @param enc
     * @return java.util.Map
     * @date 2020/3/24
     */
    public static String getUrlParams(String url, String key) {
        String[] urlParam = url.split("\\?");
        urlParam = urlParam[1].split("&");
        for (int i = 0; i < urlParam.length; i++) {
            String[] cc = urlParam[i].split("=");
            String k = cc[0];
            String[] vv = urlParam[i].split(k + "=");
            String v = vv[1];
            if (key.equals(k)) {
//                String v = cc[1];
                return v;
            }

        }
        return null;
    }

    public static void main(String[] args) {

        String str = "{}";
//        String copyStr = str.replace("{}", "code");
//        System.out.println(copyStr);
//        String rex = "code";
        if (str.contains("{}")) {
            System.out.println("666");
        }

    }

    public static Set removeDuplication(Set set1 , Set set2) {

        Set<String> result = new HashSet<String>();

        result.addAll(set1);

        result.retainAll(set2);

        return result;

    }


}

Java正则表达式：校验手机号 ，邮箱，电话号码 信息。