Tool notes - common custom tool classes (regular, random, etc.)

Match mailbox

/** *  Email verification  * * @param email  mailbox  * @return true or false */
public static boolean isEmail(String email) {
    
    Matcher m = Pattern.compile("^([a-zA-Z]|[0-9])(\\w|\\-)[email protected][a-zA-Z0-9]+\\.([a-zA-Z]{2,4})$").matcher(email);
    return m.matches();
}

Match domestic 11 Phone number

/** *  Mobile number verification  * * @param phone * @return true or false */
public static boolean isPhone(String phone) {
    
    Matcher m = Pattern.compile("^[1][3,4,5,7,8][0-9]{9}$").matcher(phone);
    return m.matches();
}

matching 5-20 Can only contain numbers and letters , And at least include 1 Letters

/** *  length  5-20  Characters , It can only contain numbers 、 Case letters   And   Contains at least one letter  * * @param str  String to be verified  * @return true or false */
public static boolean isContainOneLetter(String str) {
    
    Matcher m = Pattern.compile("(?=.*[a-zA-Z])[a-zA-Z0-9]{5,20}").matcher(str);
    return m.matches();
}

Judge whether there is Chinese （ Chinese symbols are not included ）

/** *  Verify whether the string contains Chinese , Excluding Chinese characters  * * @param str  String to be verified  * @return true- contain  false- It doesn't contain  */
public static boolean isContainsChinese(String str) {
    
    Matcher m = Pattern.compile("[\u4e00-\u9fa5]").matcher(str);
    return m.find();
}

Judge whether a character is an expression

/** *  Judge whether a character is an expression  * * @param codePoint * @return true or false */
private static boolean isEmojiCharacter(char codePoint) {
    
    return (codePoint == 0x0) || (codePoint == 0x9) || (codePoint == 0xA)
            || (codePoint == 0xD)
            || ((codePoint >= 0x20) && (codePoint <= 0xD7FF))
            || ((codePoint >= 0xE000) && (codePoint <= 0xFFFD))
            || ((codePoint >= 0x10000) && (codePoint <= 0x10FFFF));
}

Determine whether the string contains an expression

/** *  Judge whether there is expression in the string  * * @param source * @return true or false */
public static boolean isContainsEmoji(String source) {
    
    int len = source.length();
    boolean isEmoji = false;
    for (int i = 0; i < len; i++) {
    
        char hs = source.charAt(i);
        if (0xd800 <= hs && hs <= 0xdbff) {
    
            if (source.length() > 1) {
    
                char ls = source.charAt(i + 1);
                int uc = ((hs - 0xd800) * 0x400) + (ls - 0xdc00) + 0x10000;
                if (0x1d000 <= uc && uc <= 0x1f77f) {
    
                    return true;
                }
            }
        } else {
    
            // non surrogate
            if (0x2100 <= hs && hs <= 0x27ff && hs != 0x263b) {
    
                return true;
            } else if (0x2B05 <= hs && hs <= 0x2b07) {
    
                return true;
            } else if (0x2934 <= hs && hs <= 0x2935) {
    
                return true;
            } else if (0x3297 <= hs && hs <= 0x3299) {
    
                return true;
            } else if (hs == 0xa9 || hs == 0xae || hs == 0x303d
                    || hs == 0x3030 || hs == 0x2b55 || hs == 0x2b1c
                    || hs == 0x2b1b || hs == 0x2b50 || hs == 0x231a) {
    
                return true;
            }
            if (!isEmoji && source.length() > 1 && i < source.length() - 1) {
    
                char ls = source.charAt(i + 1);
                if (ls == 0x20e3) {
    
                    return true;
                }
            }
        }
    }
    return isEmoji;
}

Filter out the expressions in the string

/** *  Filter out the expressions in the string  * * @param source * @return  Filtered string  */
public static String filterEmoji(String source) {
    
    if (StringUtils.isBlank(source)) {
    
        return source;
    }
    StringBuilder buf = null;
    int len = source.length();
    for (int i = 0; i < len; i++) {
    
        char codePoint = source.charAt(i);
        if (isEmojiCharacter(codePoint)) {
    
            if (buf == null) {
    
                buf = new StringBuilder(source.length());
            }
            buf.append(codePoint);
        }
    }
    if (buf == null) {
    
        return source;
    } else {
    
        if (buf.length() == len) {
    
            buf = null;
            return source;
        } else {
    
            return buf.toString();
        }
    }
}

Random generation 6 Digit verification code

/** *  Randomly generate six digit verification code  */
public static String randomSixCode() {
    
    return String.valueOf(new Random().nextInt(899999) + 100000);
}

The numerical value is converted to 10000 units （ Such as article visits, etc ）

public static String viewNumberFormat(Integer number) {
    
	if (number < 10000) {
    
		return number.toString();
	}else if (number <= 100000) {
    
        return number / 1000 % 10 == 0 ? number / 10000 + " ten thousand +" : number / 10000 + "." + number / 1000 % 10 + " ten thousand +";
	}else {
    
        return number / 10000 + " ten thousand +";
    }
}

Date format conversion （ character string -> Date）

year - month - Japan Format

/** *  from  Date Format date   Convert to  String Format date  * @param date  Original date  * @param isWhole  Full path or not （true ->  year - month - Japan   Format ,false ->  year - month - Japan   when : branch : second   Format ） * @return  Date after conversion  */
public static String toStringFromDate(Date date, boolean isWhole) {
    
    SimpleDateFormat format;
    if (isWhole) {
    
        format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }else {
    
        format = new SimpleDateFormat("yyyy-MM-dd");
    }
    return format.format(date);
}

Date format conversion （Date -> character string ）

/** *  from  String Format date   Convert to  Date Format date  * @param date  Original date  * @param isWhole  Full path or not （true ->  year - month - Japan   Format ,false ->  year - month - Japan   when : branch : second   Format ） * @return  Date after conversion  */
public static Date toDateFromString(String date, boolean isWhole) {
    
    SimpleDateFormat format;
    if (isWhole) {
    
        format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }else {
    
        format = new SimpleDateFormat("yyyy-MM-dd");
    }
    Date resultDate = new Date();
    try {
    
        resultDate =  format.parse(date);
    } catch (ParseException e) {
    
        e.printStackTrace();
    }
    return resultDate;
}

Long Simple handling of type primary keys （ XOR Encryption ）

encryption

/** * * @param key  Encrypted string  （ Such as  1524415450874658817） * @return  The encrypted string （ Such as  21d94c70ac5ae008746588179） */
public static String encrypt(String key) {
    
    //  Yes  10 - length  Length of the number to convert 
    Integer src = Integer.parseInt(key.substring(0, 10));

    String timeStr = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));

    long pwd = Long.parseLong(src + timeStr);
    long xorPwd = pwd ^ Integer.parseInt(timeStr);

    //  Returns the converted string 
    return Long.toHexString(xorPwd) + key.substring(10) + (key.length() - 10);
}

Decrypt

/** * * @param key  String to be decrypted  （ Such as  21d94c70ac5ae008746588179） * @return  Decrypted string （ Such as  1524415450874658817） */
public static String decode(String key) {
    
    try {
    
        int start = key.length() - Integer.parseInt(key.substring(key.length() - 1));
        //  Intercept  10 - length  Length to decode 
        key = key.substring(0, key.length() - 1);
        String src = key.substring(0, start - 1);

        Long timeInt = Long.parseLong(LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")));

        Long xorOrigin = (Long.parseLong(src, 16)) ^ timeInt;
        Long id = (xorOrigin - timeInt) / 100000000;

        //  Returns the decoded string 
        if (id * 100000000 == xorOrigin - timeInt) {
    
            return id.intValue() + key.substring(start - 1);
        }
    }catch (StringIndexOutOfBoundsException | NumberFormatException e) {
    
        return "";
    }
    return "";
}