// 手机号码前三后四脱敏
    public static String mobileEncrypt(String mobile) {
        if (StringUtils.isEmpty(mobile) || (mobile.length() != 11)) {
            return mobile;
        }
        return mobile.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }

    //身份证前三后四脱敏
    public static String idEncrypt(String id) {
        if (StringUtils.isEmpty(id) || (id.length() < 8)) {
            return id;
        }
        return id.replaceAll("(?<=\\w{3})\\w(?=\\w{4})", "*");
    }
 
    public static void main(String[] args) {

    	System.out.println(CommonUtil.mobileEncrypt("13100002222"));
        System.out.println(CommonUtil.hideIdNumber("34082319940228258X"));
        System.out.println(CommonUtil.idEncrypt("34082319940228258X"));
    }
 
上面main执行结果：
 
131****2222
 3****************X
 340***********258X
 
 
 
 
 
id.replaceAll("(?<=\\w{3})\\w(?=\\w{4})", "*"); 部分解释如下：
 
正则表达式的使用(本文只说有关已经使用的，其余可自行百度）  
  
(?<=[\\w]{3})\\w(?=[\\w]{4})  
划分为三个部分1.(?<=[\\w]{3})    2.\\w    3.(?=[\\w]{4})  
整体意思就是：匹配到内容是 除了前3个和后4个 剩下的内容。  
（加上replaceAll函数，就是 除了前3个和后4个 剩下的内容 全部替换为 * ).  
  
1. \w表示匹配字母、数字、下划线  
2. 为什么上面都是用双\\呢，因为在java代码中，需要加个\进行转义，而本身就是 \w为一个整体代码相应内容，加起来就是两个\\。  
3. [\\w]{3}的意思是 匹配三个相应(字母或者数字或者下划线)的内容。  
4. 同理，[\\w]{4}的意思是 匹配4个相应的内容。  
5. (?<=xxxx)的意思是前面匹配但是不保留，比如：Hello world   (?<=H)则匹配到的内容是 ello world 不保留H，  
6. 在第五点中，如果改成 (?<=H).{3} 则匹配到的内容是 ell，即{3}代表个数。  
7. 整体(?<=[\\w]{3})就是代表 匹配除了前3个字母或者数字或者下划线的内容。  
8. (?=[\\w]{4})就是代表 匹配除了后4个字母或者数字或者下划线的内容。  
9. (?=xxxx)的意思是后面匹配但是不保留，
参考：https://www.geek-share.com/detail/2805593068.html

public static boolean isIDNumber(String IDNumber) {
        if (IDNumber == null || "".equals(IDNumber)) {
            return false;
        }
        // 定义判别用户身份证号的正则表达式（15位或者18位，最后一位可以为字母）
        String regularExpression =
                "(^[1-9]\\d{5}(18|19|20)\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$)|"
                        + "(^[1-9]\\d{5}\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}$)";
        boolean matches = IDNumber.matches(regularExpression);
        // 判断第18位校验值
        if (matches) {
            if (IDNumber.length() == 18) {
                try {
                    char[] charArray = IDNumber.toCharArray();
                    // 前十七位加权因子
                    int[] idCardWi = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
                    // 这是除以11后，可能产生的11位余数对应的验证码
                    String[] idCardY = {"1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"};
                    int sum = 0;
                    for (int i = 0; i < idCardWi.length; i++) {
                        int current = Integer.parseInt(String.valueOf(charArray[i]));
                        int count = current * idCardWi[i];
                        sum += count;
                    }
                    char idCardLast = charArray[17];
                    int idCardMod = sum % 11;
                    if (idCardY[idCardMod].toUpperCase()
                            .equals(String.valueOf(idCardLast).toUpperCase())) {
                        return true;
                    } else {
                        System.out.println("身份证最后一位:" + String.valueOf(idCardLast).toUpperCase()
                                + "错误,正确的应该是:" + idCardY[idCardMod].toUpperCase());
                        return false;
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    return false;
                }
            } else {
                return false;
            }
        }
        return matches;
    }
 
 

/**
 * 身份证号码验证
 */
public class IdentityUtils {
    public static boolean isIDNumber(String IDNumber) {
        if (IDNumber == null || "".equals(IDNumber)) {
            return false;
        }
        // 定义判别用户身份证号的正则表达式（15位或者18位，最后一位可以为字母）
        String regularExpression = "(^[1-9]\\d{5}(18|19|20)\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$)|" +
                "(^[1-9]\\d{5}\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}$)";
        //假设18位身份证号码:41000119910101123X  410001 19910101 123X
        //^开头
        //[1-9] 第一位1-9中的一个      4
        //\\d{5} 五位数字           10001（前六位省市县地区）
        //(18|19|20)                19（现阶段可能取值范围18xx-20xx年）
        //\\d{2}                    91（年份）
        //((0[1-9])|(10|11|12))     01（月份）
        //(([0-2][1-9])|10|20|30|31)01（日期）
        //\\d{3} 三位数字            123（第十七位奇数代表男，偶数代表女）
        //[0-9Xx] 0123456789Xx其中的一个 X（第十八位为校验值）
        //$结尾

        //假设15位身份证号码:410001910101123  410001 910101 123
        //^开头
        //[1-9] 第一位1-9中的一个      4
        //\\d{5} 五位数字           10001（前六位省市县地区）
        //\\d{2}                    91（年份）
        //((0[1-9])|(10|11|12))     01（月份）
        //(([0-2][1-9])|10|20|30|31)01（日期）
        //\\d{3} 三位数字            123（第十五位奇数代表男，偶数代表女），15位身份证不含X
        //$结尾
        boolean matches = IDNumber.matches(regularExpression);
        //判断第18位校验值
        if (matches) {
            if (IDNumber.length() == 18) {
                try {
                    char[] charArray = IDNumber.toCharArray();
                    //前十七位加权因子
                    int[] idCardWi = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
                    //这是除以11后，可能产生的11位余数对应的验证码
                    String[] idCardY = {"1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"};
                    int sum = 0;
                    for (int i = 0; i < idCardWi.length; i++) {
                        int current = Integer.parseInt(String.valueOf(charArray[i]));
                        int count = current * idCardWi[i];
                        sum += count;
                    }
                    char idCardLast = charArray[17];
                    int idCardMod = sum % 11;
                    if (idCardY[idCardMod].toUpperCase().equals(String.valueOf(idCardLast).toUpperCase())) {
                        return true;
                    } else {
                        return false;
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                    return false;
                }
            }
        }
        return matches;
    }
}
 
 

 
 
java身份证号码正则表达式校验（亲测可用）
 
 
 
// 原文：https://blog.csdn.net/u011106915/article/details/76066985
 public class IDUtils {
     public static boolean isIDNumber(String IDNumber) {
         if (IDNumber == null || "".equals(IDNumber)) {
             return false;
         }
         // 定义判别用户身份证号的正则表达式（15位或者18位，最后一位可以为字母）
         String regularExpression = "(^[1-9]\\d{5}(18|19|20)\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$)|" +
                 "(^[1-9]\\d{5}\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}$)";
         //假设18位身份证号码:41000119910101123X  410001 19910101 123X
         //^开头
         //[1-9] 第一位1-9中的一个      4
         //\\d{5} 五位数字           10001（前六位省市县地区）
         //(18|19|20)                19（现阶段可能取值范围18xx-20xx年）
         //\\d{2}                    91（年份）
         //((0[1-9])|(10|11|12))     01（月份）
         //(([0-2][1-9])|10|20|30|31)01（日期）
         //\\d{3} 三位数字            123（第十七位奇数代表男，偶数代表女）
         //[0-9Xx] 0123456789Xx其中的一个 X（第十八位为校验值）
         //$结尾
  
         //假设15位身份证号码:410001910101123  410001 910101 123
         //^开头
         //[1-9] 第一位1-9中的一个      4
         //\\d{5} 五位数字           10001（前六位省市县地区）
         //\\d{2}                    91（年份）
         //((0[1-9])|(10|11|12))     01（月份）
         //(([0-2][1-9])|10|20|30|31)01（日期）
         //\\d{3} 三位数字            123（第十五位奇数代表男，偶数代表女），15位身份证不含X
         //$结尾
  
  
         boolean matches = IDNumber.matches(regularExpression);
  
         //判断第18位校验值
         if (matches) {
  
             if (IDNumber.length() == 18) {
                 try {
                     char[] charArray = IDNumber.toCharArray();
                     //前十七位加权因子
                     int[] idCardWi = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
                     //这是除以11后，可能产生的11位余数对应的验证码
                     String[] idCardY = {"1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"};
                     int sum = 0;
                     for (int i = 0; i < idCardWi.length; i++) {
                         int current = Integer.parseInt(String.valueOf(charArray[i]));
                         int count = current * idCardWi[i];
                         sum += count;
                     }
                     char idCardLast = charArray[17];
                     int idCardMod = sum % 11;
                     if (idCardY[idCardMod].toUpperCase().equals(String.valueOf(idCardLast).toUpperCase())) {
                         return true;
                     } else {
                         return false;
                     }
  
                 } catch (Exception e) {
                     e.printStackTrace();
                     return false;
                 }
             }
  
         }
         return matches;
     }
 }
 
 
 
 
 
 
 
 
 
 
 
https://blog.csdn.net/huangdingsheng/article/details/94469497
 
Java正则校验手机号
 
package com.app.main.utils;
  
 import java.util.regex.Pattern;
  
 /**
  * Created with IDEA
  * author:Dingsheng Huang
  * Date:2019/7/2
  * Time:下午6:51
  */
 public class RegexUtils {
  
     /**
      *  正则：手机号（简单）, 1字头＋10位数字即可.
      * @param in
      * @return
      */
     public static boolean validateMobilePhone(String in) {
         Pattern pattern = Pattern.compile("^[1]\\d{10}$");
         return pattern.matcher(in).matches();
     }
  
     public static void main(String[] args) {
         System.out.println(validateMobilePhone("17778014396"));
  
         System.out.println(validateMobilePhone("123"));
     }
 }