1.身份证号码校验
代码如下（示例）：
/**
* 身份证校验
* @param IDNumber
* @return
*/
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;
}
2.手机号校验
代码如下（示例）：
public static boolean isPhoneLegal(String str) throws PatternSyntaxException {
return isChinaPhoneLegal(str) || isHKPhoneLegal(str);
}
/**
* 大陆手机号码11位数，匹配格式：前三位固定格式+后8位任意数
* 此方法中前三位格式有：
* 13+任意数
* 145,147,149
* 15+除4的任意数(不要写^4，这样的话字母也会被认为是正确的)
* 166
* 17+3,5,6,7,8
* 18+任意数
* 198,199
*/
public static boolean isChinaPhoneLegal(String str) throws PatternSyntaxException {
// ^ 匹配输入字符串开始的位置
// \d 匹配一个或多个数字，其中 \ 要转义，所以是 \\d
// $ 匹配输入字符串结尾的位置
String regExp = "^((13[0-9])|(14[5,7,9])|(15[0-3,5-9])|(166)|(17[3,5,6,7,8])" +
"|(18[0-9])|(19[8,9]))\\d{8}$";
Pattern p = Pattern.compile(regExp);
Matcher m = p.matcher(str);
return m.matches();
}
/**
* 香港手机号码8位数，5|6|8|9开头+7位任意数
*/
public static boolean isHKPhoneLegal(String str) throws PatternSyntaxException {
// ^ 匹配输入字符串开始的位置
// \d 匹配一个或多个数字，其中 \ 要转义，所以是 \\d
// $ 匹配输入字符串结尾的位置
String regExp = "^(5|6|8|9)\\d{7}$";
Pattern p = Pattern.compile(regExp);
Matcher m = p.matcher(str);
return m.matches();
}
/**
* 电话号校验
* @param str
* @return
*/
public static boolean checkPhone(String str) {
Pattern p1 = null, p2 = null;
Matcher m = null;
boolean isPhone = false;
p1 = Pattern.compile("^[0][1-9]{2,3}-[0-9]{5,10}$"); // 验证带区号的
p2 = Pattern.compile("^[1-9]{1}[0-9]{5,8}$"); // 验证没有区号的
if (str.length() > 9) {
m = p1.matcher(str);
isPhone = m.matches();
} else {
m = p2.matcher(str);
isPhone = m.matches();
}
return isPhone;
}
3.匹配是否为数字
/**
* 匹配是否为数字
* @param str 可能为中文，也可能是-19162431.1254，不使用BigDecimal的话，变成-1.91624311254E7
* @return
* @author yutao
* @date 2016年11月14日下午7:41:22
*/
public static boolean isNumeric(String str) {
// 该正则表达式可以匹配所有的数字 包括负数
Pattern pattern = Pattern.compile("-?[0-9]+(\\.[0-9]+)?");
String bigStr;
try {
bigStr = new BigDecimal(str).toString();
} catch (Exception e) {
//异常 说明包含非数字。
return false;
}
// matcher是全匹配
Matcher isNum = pattern.matcher(bigStr);
if (!isNum.matches()) {
return false;
}
return true;
}
4.日期格式校验
/**
* 日期格式校验工具
* @param str 日期str
* @param format 转换格式 yyyy-MM-dd yyyy/MM/dd
* @return
*/
static boolean checkDate (String str,String format) {
SimpleDateFormat sd=new SimpleDateFormat(format);
try {
//此处指定日期/时间解析是否不严格，在true是不严格，false时为严格
sd.setLenient(false);
//从给定字符串的开始解析文本，以生成一个日期
sd.parse(str);
}
catch (Exception e) {
return false;
}
return true;
}
5.反射工具类
package com.lxpd.nplsdisposal.collection.util;
import com.lxpd.nplsdisposal.collection.constant.FieldTypeEnum;
import com.lxpd.nplsdisposal.collection.vo.ColCaseBaseVO;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
/**
* 反射工具类
* @author l'b'h
*/
public class ReflectionUtil {
/**
* 通过反射给对象的属性赋值
* @param t 对象实体
* @param entityPath 对象路径
* @param fieldName 属性名称
* @param fieldValue 属性值
* @param <T>
* @throws Exception
*/
public static <T> T reflectionSet(T t,String entityPath,String fieldName,String fieldValue)throws Exception {
//1.获取Class对象
Class stuClass = Class.forName(entityPath);
Object obj = t;
Field field = stuClass.getDeclaredField(fieldName);
Class<?> type = field.getType();
//暴力反射，解除私有限定
field.setAccessible(true);
if(type.toString().contains(FieldTypeEnum.Long.getValue())){
field.set(obj, Long.valueOf(fieldValue));
}else if(type.toString().contains(FieldTypeEnum.BigDecimal.getValue())){
field.set(obj, new BigDecimal(fieldValue));
}else if(type.toString().contains(FieldTypeEnum.Integer.getValue())) {
field.set(obj, Integer.valueOf(fieldValue));
} else if(type.toString().contains(FieldTypeEnum.LocalDateTime.getValue())){
//格式化日期 只支持 yyyy-MM-dd yyyy/MM/dd
if(fieldValue.contains("-")){
String[] split = fieldValue.split("-");
field.set(obj, LocalDateTime.of(
Integer.valueOf(split[0]),
Integer.valueOf(split[1]),
Integer.valueOf(split[2]),
0,0,0
));
}else{
String[] split = fieldValue.split("/");
field.set(obj, LocalDateTime.of(
Integer.valueOf(split[0]),
Integer.valueOf(split[1]),
Integer.valueOf(split[2]),
0,0,0
));
}
}else if(type.toString().contains(FieldTypeEnum.LocalDate.getValue())){
if(fieldValue.contains("-")){
String[] split = fieldValue.split("-");
field.set(obj, LocalDate.of(
Integer.valueOf(split[0]),
Integer.valueOf(split[1]),
Integer.valueOf(split[2])
));
}else {
String[] split = fieldValue.split("/");
field.set(obj, LocalDate.of(
Integer.valueOf(split[0]),
Integer.valueOf(split[1]),
Integer.valueOf(split[2])
));
}
}
else{
field.set(obj, fieldValue);
}
return t;
}
/**
*通过反射获取对象的属性值
* @param t 对象实体
* @param entityPath 实体包路径
* @param fieldName 属性名
* @throws Exception
*/
public static <T> Object reflectionGet(T t,String entityPath,String fieldName)throws Exception {
//1.获取Class对象
Class stuClass = Class.forName(entityPath);
Object obj = t;
Field field = stuClass.getDeclaredField(fieldName);
//暴力反射，解除私有限定
field.setAccessible(true);
return field.get(t);
}
/**
* 判断对象是否为空，传入不检查的属性集合为空时，检查所有属性，否则只检查不在集合中的属性
* @param t 对象实体
* @param entityPath 对象包路径
* @param uncheckFieldName 不检查的属性集合
* @return
* @throws Exception
*/
public static <T> boolean reflectionIsNull(T t, String entityPath, List<String> uncheckFieldName)throws Exception{
boolean flag = true;
//1.获取Class对象
Class stuClass = Class.forName(entityPath);
Object obj = t;
Field[] declaredFields = stuClass.getDeclaredFields();
for (int i = 0; i < declaredFields.length; i++) {
Field declaredField = declaredFields[i];
declaredField.setAccessible(true);
if(uncheckFieldName != null && uncheckFieldName.size()>0){
if(uncheckFieldName.contains(declaredField.getName())){
continue;
}else{
if(declaredField.get(t) != null){
flag = false;
break;
}
}
}else{
if(declaredField.get(t) != null){
flag = false;
break;
}
}
}
return flag;
}
public static void main(String[] args) throws Exception {
ColCaseBaseVO vo = new ColCaseBaseVO();
vo.setAmount(new BigDecimal("50000"));
Object amount = reflectionGet(vo, FieldTypeEnum.vo_path.getValue() + "ColCaseBaseVO", "amount");
System.out.println(amount.toString());
}
}
6.字符串转换
package com.lxpd.nplsdisposal.collection.util;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 字符串转换工具类
*/
public class StringTransformUtil {
private static Pattern linePattern = Pattern.compile("_(\\w)");
/** 下划线转驼峰 */
public static String lineToHump(String str) {
str = str.toLowerCase();
Matcher matcher = linePattern.matcher(str);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
}
matcher.appendTail(sb);
return sb.toString();
}
/** 驼峰转下划线(简单写法，效率低于{@link #humpToLine2(String)}) */
public static String humpToLine(String str) {
return str.replaceAll("[A-Z]", "_$0").toLowerCase();
}
private static Pattern humpPattern = Pattern.compile("[A-Z]");
/** 驼峰转下划线,效率比上面高 */
public static String humpToLine2(String str) {
Matcher matcher = humpPattern.matcher(str);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
}
matcher.appendTail(sb);
return sb.toString();
}
/**
* 首字母大写
* @param name
* @return
*/
public static String captureName(String name) {
char[] cs = name.toCharArray();
cs[0] -= 32;
return String.valueOf(cs);
}
}
7.字符串格式校验
package com.lxpd.nplsdisposal.collection.util;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 字符串匹配工具类
*
* @author luobinhan
* @date 2021-11-16 09:47:23
*/
public class StrValidate {
// 纯数字
private static String DIGIT_REGEX = "[0-9]+";
// 含有数字
private static String CONTAIN_DIGIT_REGEX = ".*[0-9].*";
// 纯字母
private static String LETTER_REGEX = "[a-zA-Z]+";
// 包含字母
private static String CONTAIN_LETTER_REGEX = ".*[a-zA-z].*";
// 纯中文
private static String CHINESE_REGEX = "[\u4e00-\u9fa5]";
// 仅仅包含字母和数字
private static String LETTER_DIGIT_REGEX = "^[a-z0-9A-Z]+$";
private static String CHINESE_LETTER_REGEX = "([\u4e00-\u9fa5]+|[a-zA-Z]+)";
private static String CHINESE_LETTER_DIGIT_REGEX = "^[a-z0-9A-Z\u4e00-\u9fa5]+$";
/**
* 判断字符串是否仅含有数字和字母
*
* @param str
* @return
*/
public static boolean isLetterDigit(String str) {
return str.matches(LETTER_DIGIT_REGEX);
}
/**
* 是否为汉字，不包括标点符号
*
* @param con
* @return true 是汉字
*/
public static boolean isChinese(String con) {
Pattern pattern = Pattern.compile(CHINESE_REGEX);
for (int i = 0; i < con.length(); i = i + 1) {
if (!pattern.matcher(
String.valueOf(con.charAt(i))).find()) {
return false;
}
}
return true;
}
/**
* 用正则表达式判断字符串中是否
* 仅包含英文字母、数字和汉字
*
* @param str
* @return
*/
public static boolean isLetterDigitOrChinese(String str) {
return str.matches(CHINESE_LETTER_DIGIT_REGEX);
}
/**
* 姓名中可包含汉字和字母，无其它字符
*
* @param passengerName
* @return
*/
public static boolean checkChineseLetter(String passengerName) {
Pattern pattern = Pattern.compile(CHINESE_LETTER_REGEX);
Matcher matcher = pattern.matcher(passengerName);
if (matcher.matches()) {
//不包含特殊字符
return true;
} else {
//包含了特殊字符
return false;
}
}
/**
* 判断一个字符串是否包含标点符号（中文或者英文标点符号），true 包含。<br/>
* 原理：对原字符串做一次清洗，清洗掉所有标点符号。<br/>
* 此时，如果入参 ret 包含标点符号，那么清洗前后字符串长度不同，返回true；否则，长度相等，返回false。<br/>
*
* @param ret
* @return true 包含中英文标点符号
*/
public static boolean checkPunctuation(String ret) {
boolean b = false;
String tmp = ret;
// replaceAll里面的正则匹配可以清空字符串中的中英文标点符号，只保留数字、英文和中文。
tmp = tmp.replaceAll("\\p{P}", "");
if (ret.length() != tmp.length()) {
b = true;
}
return b;
}
public static boolean isDigit(String ret) {
return ret.matches(DIGIT_REGEX);
}
public static boolean isLetter(String ret) {
return ret.matches(LETTER_REGEX);
}
public static boolean hasDigit(String ret) {
return ret.matches(CONTAIN_DIGIT_REGEX);
}
public static boolean hasLetter(String ret) {
return ret.matches(CONTAIN_LETTER_REGEX);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
