本文提供的工具类，是平时开发中经常会使用到的，使用工具类，提高开发效率。
1，驼峰转下划线，下划线转驼峰
/**
* 驼峰转下划线
*
* @param value 待转换值
* @return 结果
*/
public static String camelToUnderscore(String value) {
if (StringUtils.isBlank(value)) {
return value;
}
String[] arr = StringUtils.splitByCharacterTypeCamelCase(value);
if (arr.length == 0) {
return value;
}
StringBuilder result = new StringBuilder();
IntStream.range(0, arr.length).forEach(i -> {
if (i != arr.length - 1) {
result.append(arr[i]).append(StringPool.UNDERSCORE);
}else {
result.append(arr[i]);
}
});
return StringUtils.lowerCase(result.toString());
}
/**
* 下划线转驼峰
*
* @param value 待转换值
* @return 结果
*/
public static String underscoreToCamel(String value) {
StringBuilder result = new StringBuilder();
String[] arr = value.split("_");
for (String s : arr) {
result.append((String.valueOf(s.charAt(0))).toUpperCase()).append(s.substring(1));
}
return result.toString();
}
2，判断是否是Ajax请求
/**
* 判断是否为 ajax请求
*
* @param request HttpServletRequest
* @return boolean
*/
public static boolean isAjaxRequest(HttpServletRequest request) {
return (request.getHeader("X-Requested-With") != null
&& "XMLHttpRequest".equals(request.getHeader("X-Requested-With")));
}
3，正则校验
/**
* 正则校验
*
* @param regex 正则表达式字符串
* @param value 要匹配的字符串
* @return 正则校验结果
*/
public static boolean match(String regex, String value) {
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(value);
return matcher.matches();
}4，判断是否包含中文
/**
* 判断是否包含中文
*
* @param value 内容
* @return 结果
*/
public static boolean containChinese(String value) {
Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
Matcher m = p.matcher(value);
return m.find();
}
5，获取唯一编号，日期+自增
/**
* @description: 获取当前唯一编号，日期+自增
* @return:
* @author: zxq
* @Date: 2020/11/26 11:55
*/
public class RandomNumber {
// 使用单例模式，不允许直接创建实例
private RandomNumber() {}
// 创建一个空实例对象，类需要用的时候才赋值
private static RandomNumber instance = null;
// 单例模式--懒汉模式
public static synchronized RandomNumber getInstance() {
if (instance == null) {
instance = new RandomNumber();
}
return instance;
}
// 全局自增数
private static int count = 1;
// 格式化的时间字符串
private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
// 获取当前时间年月日时分秒毫秒字符串
private static String getNowDateStr() {
return sdf.format(new Date());
}
// 记录上一次的时间，用来判断是否需要递增全局数
private static String now = null;
//定义锁对象
private final static ReentrantLock lock=new ReentrantLock();
//调用的方法
public static String GetRandom(){
String Newnumber=null;
String dateStr=getNowDateStr();
lock.lock();//加锁
//判断是时间是否相同
if (dateStr.equals(now)) {
try {
if (count >= 10000)
{
count = 1;
}
if (count<10) {
Newnumber = getNowDateStr()+"000"+count;
}else if (count<100) {
Newnumber = getNowDateStr()+"00"+count;
}else if(count<1000){
Newnumber = getNowDateStr()+"0"+count;
}else {
Newnumber = getNowDateStr()+count;
}
count++;
} catch (Exception e) {
}finally{
lock.unlock();
}
}else{
count=1;
now =getNowDateStr();
try {
if (count >= 10000)
{
count = 1;
}
if (count<10) {
Newnumber = getNowDateStr()+"000"+count;
}else if (count<100) {
Newnumber = getNowDateStr()+"00"+count;
}else if(count<1000){
Newnumber =getNowDateStr()+"0"+count;
}else {
Newnumber = getNowDateStr()+count;
}
count++;
} catch (Exception e) {
}finally{
lock.unlock();
}
}
return Newnumber;//返回的值
}
public static String GetRandom(String prefix){
String Newnumber=null;
String dateStr=getNowDateStr();
lock.lock();//加锁
//判断是时间是否相同
if (dateStr.equals(now)) {
try {
if (count >= 10000)
{
count = 1;
}
if (count<10) {
Newnumber = prefix + getNowDateStr()+"000"+count;
}else if (count<100) {
Newnumber = prefix + getNowDateStr()+"00"+count;
}else if(count<1000){
Newnumber = prefix + getNowDateStr()+"0"+count;
}else {
Newnumber = prefix + getNowDateStr()+count;
}
count++;
} catch (Exception e) {
}finally{
lock.unlock();
}
}else{
count=1;
now =getNowDateStr();
try {
if (count >= 10000)
{
count = 1;
}
if (count<10) {
Newnumber = prefix + getNowDateStr()+"000"+count;
}else if (count<100) {
Newnumber = prefix + getNowDateStr()+"00"+count;
}else if(count<1000){
Newnumber = prefix + getNowDateStr()+"0"+count;
}else {
Newnumber = prefix + getNowDateStr()+count;
}
count++;
} catch (Exception e) {
}finally{
lock.unlock();
}
}
return Newnumber;//返回的值
}View Code
6，排序工具类
import cc.mrbird.febs.common.entity.FebsConstant;
import cc.mrbird.febs.common.entity.QueryRequest;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.commons.lang3.StringUtils;
/**
* 处理排序工具类
*
* @author MrBird
*/
public class SortUtil {
/**
* 处理排序（分页情况下） for mybatis-plus
*
* @param request QueryRequest
* @param page Page
* @param defaultSort 默认排序的字段
* @param defaultOrder 默认排序规则
* @param camelToUnderscore 是否开启驼峰转下划线
*/
public static void handlePageSort(QueryRequest request, Page<?> page, String defaultSort, String defaultOrder, boolean camelToUnderscore) {
page.setCurrent(request.getPageNum());
page.setSize(request.getPageSize());
String sortField = request.getField();
if (camelToUnderscore) {
sortField = FebsUtil.camelToUnderscore(sortField);
defaultSort = FebsUtil.camelToUnderscore(defaultSort);
}
if (StringUtils.isNotBlank(request.getField())
&& StringUtils.isNotBlank(request.getOrder())
&& !StringUtils.equalsIgnoreCase(request.getField(), "null")
&& !StringUtils.equalsIgnoreCase(request.getOrder(), "null")) {
if (StringUtils.equals(request.getOrder(), FebsConstant.ORDER_DESC))
page.addOrder(OrderItem.desc(sortField));
else
page.addOrder(OrderItem.asc(sortField));
} else {
if (StringUtils.isNotBlank(defaultSort)) {
if (StringUtils.equals(defaultOrder, FebsConstant.ORDER_DESC))
page.addOrder(OrderItem.desc(defaultSort));
else
page.addOrder(OrderItem.asc(defaultSort));
}
}
}
/**
* 处理排序 for mybatis-plus
*
* @param request QueryRequest
* @param page Page
*/
public static void handlePageSort(QueryRequest request, Page<?> page) {
handlePageSort(request, page, null, null, false);
}
/**
* 处理排序 for mybatis-plus
*
* @param request QueryRequest
* @param page Page
* @param camelToUnderscore 是否开启驼峰转下划线
*/
public static void handlePageSort(QueryRequest request, Page<?> page, boolean camelToUnderscore) {
handlePageSort(request, page, null, null, camelToUnderscore);
}
/**
* 处理排序 for mybatis-plus
*
* @param request QueryRequest
* @param wrapper wrapper
* @param defaultSort 默认排序的字段
* @param defaultOrder 默认排序规则
* @param camelToUnderscore 是否开启驼峰转下划线
*/
public static void handleWrapperSort(QueryRequest request, QueryWrapper<?> wrapper, String defaultSort, String defaultOrder, boolean camelToUnderscore) {
String sortField = request.getField();
if (camelToUnderscore) {
sortField = FebsUtil.camelToUnderscore(sortField);
defaultSort = FebsUtil.camelToUnderscore(defaultSort);
}
if (StringUtils.isNotBlank(request.getField())
&& StringUtils.isNotBlank(request.getOrder())
&& !StringUtils.equalsIgnoreCase(request.getField(), "null")
&& !StringUtils.equalsIgnoreCase(request.getOrder(), "null")) {
if (StringUtils.equals(request.getOrder(), FebsConstant.ORDER_DESC))
wrapper.orderByDesc(sortField);
else
wrapper.orderByAsc(sortField);
} else {
if (StringUtils.isNotBlank(defaultSort)) {
if (StringUtils.equals(defaultOrder, FebsConstant.ORDER_DESC))
wrapper.orderByDesc(defaultSort);
else
wrapper.orderByAsc(defaultSort);
}
}
}
/**
* 处理排序 for mybatis-plus
*
* @param request QueryRequest
* @param wrapper wrapper
*/
public static void handleWrapperSort(QueryRequest request, QueryWrapper<?> wrapper) {
handleWrapperSort(request, wrapper, null, null, false);
}
/**
* 处理排序 for mybatis-plus
*
* @param request QueryRequest
* @param wrapper wrapper
* @param camelToUnderscore 是否开启驼峰转下划线
*/
public static void handleWrapperSort(QueryRequest request, QueryWrapper<?> wrapper, boolean camelToUnderscore) {
handleWrapperSort(request, wrapper, null, null, camelToUnderscore);
}View Code
7，金额的加减乘除
import java.math.BigDecimal;
/**
* 金额的加减乘除
* Created by IntelliJ IDEA.
* User: 98078
* Date: 2019/10/22
*
* @author sun
*/
public class MathMoney {
private static final int DEF_DIV_SCALE = 10;
//这个类不能实例化
private MathMoney() {
}
/**
* 提供精确的加法运算。
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static String add(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
BigDecimal b3 = b1.add(b2);
return b3.setScale(2, BigDecimal.ROUND_HALF_UP).toString();
}
public static String add(String v1, String v2,int scale) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
BigDecimal b3 = b1.add(b2);
return b3.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 提供精确的减法运算。
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static String sub(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
BigDecimal subtract = b1.subtract(b2);
return subtract.setScale(2, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 提供精确的乘法运算。
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static String mul(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
BigDecimal multiply = b1.multiply(b2);
return multiply.setScale(2, BigDecimal.ROUND_HALF_UP).toString();
}
public static String mul(String v1, String v2,int scal) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
BigDecimal multiply = b1.multiply(b2);
return multiply.setScale(scal, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static String div(String v1, String v2) {
return div(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static String div(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
}
/**
* 提供精确的小数位四舍五入处理。
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static String round(String v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(v);
BigDecimal one = new BigDecimal("1");
BigDecimal two = b.divide(one, scale, BigDecimal.ROUND_HALF_UP);
return two.setScale(2, BigDecimal.ROUND_HALF_UP).toString();
}
}View Code
8，通过经纬度获取单位距离（米）
import java.util.UUID;
/**
* Created by IntelliJ IDEA.
* User: 98078
* Date: 2019/12/30
*
* @author sun
*/
public class LocationUtils {
private static double EARTH_RADIUS = 6378.137;
private static double rad(double d) {
return d * Math.PI / 180.0;
}
/**
* 通过经纬度获取距离(单位：米)
*
* @param lat1 纬度
* @param lng1 经度
* @param lat2
* @param lng2
* @return 距离
*/
public static double getDistance(double lat1, double lng1, double lat2,
double lng2) {
double radLat1 = rad(lat1);
double radLat2 = rad(lat2);
double a = radLat1 - radLat2;
double b = rad(lng1) - rad(lng2);
double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2)
+ Math.cos(radLat1) * Math.cos(radLat2)
* Math.pow(Math.sin(b / 2), 2)));
s = s * EARTH_RADIUS;
s = Math.round(s * 10000d) / 10000d;
s = s * 1000;
return s;
}
public static void main(String[] args) {
System.out.println(UUID.randomUUID());
double distance =
getDistance(121.487187, 31.228371,
121.487959, 31.228267);
System.out.println("距离" + distance / 1000 + "公里");
}
}View Code
9，UUID
/**
* @description: 获取UUID，去除 -
* @param prefix 前缀
* @return: java.lang.String
* @author: zxq
* @Date: 2020/10/23 14:32
*/
public static String UUID(String prefix){
String uuid = UUID.randomUUID().toString().replaceAll("-", "");
if(!StringUtils.isEmpty(prefix)){
uuid = prefix+uuid;
}
return uuid;
}
/**
* @description:获取UUID
* @return: java.lang.String
* @author: zxq
* @Date: 2020/10/23 14:34
*/
public static String UUID(){
String uuid = UUID.randomUUID().toString().replaceAll("-", "");
return uuid;
}
10，雪花算法
/**
* Project Name:cms
* File Name:SnowflakeIdWorker.java
* Package Name:com.bangbangsky.cms.core.utils
* Date:2018年6月26日上午9:37:48
* Copyright (c) 2018, www.bangbangsky.com All Rights Reserved.
*
*/
package com.zy.core.util;
/**
* ClassName:SnowflakeIdWorker <br/>
* Function: Twitter_Snowflake. <br/>
* SnowFlake的结构如下(每部分用-分开):<br>
* 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
* 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
* 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
* 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
* 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
* 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
* 加起来刚好64位，为一个Long型。<br>
* SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
* Date: 2020年9月24日 上午9:37:48 <br/>
* @author zxq
* @version
* @since JDK 1.8
* @see
*/
@SuppressWarnings("static-access")
public class SnowflakeIdWorker {
// ==============================Fields===========================================
/** 开始时间截 (2015-01-01) */
private static final long twepoch = 1420041600000L;
/** 机器id所占的位数 */
private static final long workerIdBits = 5L;
/** 数据标识id所占的位数 */
private static final long datacenterIdBits = 5L;
/** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
/** 支持的最大数据标识id，结果是31 */
private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
/** 序列在id中占的位数 */
private static final long sequenceBits = 12L;
/** 机器ID向左移12位 */
private static final long workerIdShift = sequenceBits;
/** 数据标识id向左移17位(12+5) */
private static final long datacenterIdShift = sequenceBits + workerIdBits;
/** 时间截向左移22位(5+5+12) */
private static final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
/** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
private static final long sequenceMask = -1L ^ (-1L << sequenceBits);
/** 工作机器ID(0~31) */
private static long workerId;
/** 数据中心ID(0~31) */
private static long datacenterId;
/** 毫秒内序列(0~4095) */
private static long sequence = 0L;
/** 上次生成ID的时间截 */
private static long lastTimestamp = -1L;
//==============================Constructors=====================================
/**
* 构造函数
* @param workerId 工作ID (0~31)
* @param datacenterId 数据中心ID (0~31)
*/
public SnowflakeIdWorker(long workerId, long datacenterId) {
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
}
if (datacenterId > maxDatacenterId || datacenterId < 0) {
throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
}
this.workerId = workerId;
this.datacenterId = datacenterId;
}
// ==============================Methods==========================================
/**
* 获得下一个ID (该方法是线程安全的)
* @return SnowflakeId
*/
public synchronized static long nextId() {
long timestamp = timeGen();
//如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
if (timestamp < lastTimestamp) {
throw new RuntimeException(
String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
}
//如果是同一时间生成的，则进行毫秒内序列
if (lastTimestamp == timestamp) {
sequence = (sequence + 1) & sequenceMask;
//毫秒内序列溢出
if (sequence == 0) {
//阻塞到下一个毫秒,获得新的时间戳
timestamp = tilNextMillis(lastTimestamp);
}
}
//时间戳改变，毫秒内序列重置
else {
sequence = 0L;
}
//上次生成ID的时间截
lastTimestamp = timestamp;
//移位并通过或运算拼到一起组成64位的ID
return ((timestamp - twepoch) << timestampLeftShift) //
| (datacenterId << datacenterIdShift) //
| (workerId << workerIdShift) //
| sequence;
}
/**
* 阻塞到下一个毫秒，直到获得新的时间戳
* @param lastTimestamp 上次生成ID的时间截
* @return 当前时间戳
*/
protected static long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
/**
* 返回以毫秒为单位的当前时间
* @return 当前时间(毫秒)
*/
protected static long timeGen() {
return System.currentTimeMillis();
}
/**
* getSnowflakeId:获取主键. <br/>
*
* @author zxq
* @return
* @since JDK 1.8
*/
public static String getSnowflakeId(){
return String.valueOf(nextId());
}
//==============================Test=============================================
/** 测试 */
public static void main(String[] args) {
SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
for (int i = 0; i < 1000; i++) {
long id = idWorker.nextId();
System.out.println(Long.toBinaryString(id));
System.out.println(id);
}
}
}View Code
未完，待续...
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
