Java技术-项目中经常使用的工具类汇总

末蓝、 2024-02-05 21:22 44阅读 0赞

> 工具类在现代Java应用程序中发挥着重要的作用。通过提供一系列的实用方法和功能，工具类极大地简化了开发人员的任务，提高了代码的可维护性和可读性。其核心特性包括\[列举关键特性\]，使其成为处理\[特定任务/场景\]的理想选择。工具类的各种方法，演示了在不同情境下的实际用例。总的来说，Java工具类不仅为开发人员提供了高效的解决方案，还为项目的成功实施和持续发展做出了重要贡献。无论是初学者还是经验丰富的开发人员，都能从工具类中获得实际的价值，为他们的Java项目增添更多的灵活性和效率。

## 依赖添加 ##

<properties>
 <java.version>1.8</java.version>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 <spring-boot.version>2.3.12.RELEASE</spring-boot.version>
 <commons-lang3.version>3.12.0</commons-lang3.version>
 <jjwt.version>0.9.1</jjwt.version>
 </properties>
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-lang3</artifactId>
 <version>${commons-lang3.version}</version>
 </dependency>
 
 <dependency>
 <groupId>io.jsonwebtoken</groupId>
 <artifactId>jjwt</artifactId>
 <version>${jjwt.version}</version>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 <exclusions>
 <exclusion>
 <groupId>org.junit.vintage</groupId>
 <artifactId>junit-vintage-engine</artifactId>
 </exclusion>
 </exclusions>
 </dependency>
 </dependencies>
 <dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-dependencies</artifactId>
 <version>${spring-boot.version}</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
 </dependencyManagement>

## 常量类代码 ##

### 通用常量信息 ###

package com.xiaobai.toolclass.common.core.constant;
    
    /**
     * 通用常量信息
     * 
     * @author 小白程序员
     */
    public class Constants
    {
        /**
         * UTF-8 字符集
         */
        public static final String UTF8 = "UTF-8";
    
        /**
         * GBK 字符集
         */
        public static final String GBK = "GBK";
    
        /**
         * www主域
         */
        public static final String WWW = "www.";
    
        /**
         * RMI 远程方法调用
         */
        public static final String LOOKUP_RMI = "rmi:";
    
        /**
         * LDAP 远程方法调用
         */
        public static final String LOOKUP_LDAP = "ldap:";
    
        /**
         * LDAPS 远程方法调用
         */
        public static final String LOOKUP_LDAPS = "ldaps:";
    
        /**
         * http请求
         */
        public static final String HTTP = "http://";
    
        /**
         * https请求
         */
        public static final String HTTPS = "https://";
    
        /**
         * 成功标记
         */
        public static final Integer SUCCESS = 200;
    
        /**
         * 失败标记
         */
        public static final Integer FAIL = 500;
    
        /**
         * 登录成功状态
         */
        public static final String LOGIN_SUCCESS_STATUS = "0";
    
        /**
         * 登录失败状态
         */
        public static final String LOGIN_FAIL_STATUS = "1";
    
        /**
         * 登录成功
         */
        public static final String LOGIN_SUCCESS = "Success";
    
        /**
         * 注销
         */
        public static final String LOGOUT = "Logout";
    
        /**
         * 注册
         */
        public static final String REGISTER = "Register";
    
        /**
         * 登录失败
         */
        public static final String LOGIN_FAIL = "Error";
    
        /**
         * 当前记录起始索引
         */
        public static final String PAGE_NUM = "pageNum";
    
        /**
         * 每页显示记录数
         */
        public static final String PAGE_SIZE = "pageSize";
    
        /**
         * 排序列
         */
        public static final String ORDER_BY_COLUMN = "orderByColumn";
    
        /**
         * 排序的方向 "desc" 或者 "asc".
         */
        public static final String IS_ASC = "isAsc";
    
        /**
         * 验证码有效期（分钟）
         */
        public static final long CAPTCHA_EXPIRATION = 2;
    
        /**
         * 资源映射路径 前缀
         */
        public static final String RESOURCE_PREFIX = "/profile";
    
        /**
         * 自动识别json对象白名单配置（仅允许解析的包名，范围越小越安全）
         */
        public static final String[] JSON_WHITELIST_STR = { "org.springframework", "com.xiaobai" };
    
        /**
         * 定时任务白名单配置（仅允许访问的包名，如其他需要可以自行添加）
         */
        public static final String[] JOB_WHITELIST_STR = { "com.xiaobai" };
    
        /**
         * 定时任务违规的字符
         */
        public static final String[] JOB_ERROR_STR = { "java.net.URL", "javax.naming.InitialContext", "org.yaml.snakeyaml",
                "org.springframework", "org.apache", "com.xiaobai.common.core.utils.file" };
    }

### 返回状态码 ###

package com.xiaobai.toolclass.common.core.constant;
    
    /**
     * 返回状态码
     * 
     * @author 小白程序员
     */
    public class HttpStatus
    {
        /**
         * 操作成功
         */
        public static final int SUCCESS = 200;
    
        /**
         * 对象创建成功
         */
        public static final int CREATED = 201;
    
        /**
         * 请求已经被接受
         */
        public static final int ACCEPTED = 202;
    
        /**
         * 操作已经执行成功，但是没有返回数据
         */
        public static final int NO_CONTENT = 204;
    
        /**
         * 资源已被移除
         */
        public static final int MOVED_PERM = 301;
    
        /**
         * 重定向
         */
        public static final int SEE_OTHER = 303;
    
        /**
         * 资源没有被修改
         */
        public static final int NOT_MODIFIED = 304;
    
        /**
         * 参数列表错误（缺少，格式不匹配）
         */
        public static final int BAD_REQUEST = 400;
    
        /**
         * 未授权
         */
        public static final int UNAUTHORIZED = 401;
    
        /**
         * 访问受限，授权过期
         */
        public static final int FORBIDDEN = 403;
    
        /**
         * 资源，服务未找到
         */
        public static final int NOT_FOUND = 404;
    
        /**
         * 不允许的http方法
         */
        public static final int BAD_METHOD = 405;
    
        /**
         * 资源冲突，或者资源被锁
         */
        public static final int CONFLICT = 409;
    
        /**
         * 不支持的数据，媒体类型
         */
        public static final int UNSUPPORTED_TYPE = 415;
    
        /**
         * 系统内部错误
         */
        public static final int ERROR = 500;
    
        /**
         * 接口未实现
         */
        public static final int NOT_IMPLEMENTED = 501;
    
        /**
         * 系统警告消息
         */
        public static final int WARN = 601;
    }

### 权限相关通用常量 ###

package com.xiaobai.toolclass.common.core.constant;
    
    /**
     * 权限相关通用常量
     * 
     * @author 小白程序员
     */
    public class SecurityConstants
    {
        /**
         * 用户ID字段
         */
        public static final String DETAILS_USER_ID = "user_id";
    
        /**
         * 用户名字段
         */
        public static final String DETAILS_USERNAME = "username";
    
        /**
         * 授权信息字段
         */
        public static final String AUTHORIZATION_HEADER = "authorization";
    
        /**
         * 请求来源
         */
        public static final String FROM_SOURCE = "from-source";
    
        /**
         * 内部请求
         */
        public static final String INNER = "inner";
    
        /**
         * 用户标识
         */
        public static final String USER_KEY = "user_key";
    
        /**
         * 登录用户
         */
        public static final String LOGIN_USER = "login_user";
    
        /**
         * 角色权限
         */
        public static final String ROLE_PERMISSION = "role_permission";
    }

### Token的Key常量 ###

package com.xiaobai.toolclass.common.core.constant;
    
    /**
     * Token的Key常量
     * 
     * @author 小白程序员
     */
    public class TokenConstants
    {
        /**
         * 令牌自定义标识
         */
        public static final String AUTHENTICATION = "Authorization";
    
        /**
         * 令牌前缀
         */
        public static final String PREFIX = "Bearer ";
    
        /**
         * 令牌秘钥
         */
        public final static String SECRET = "abcdefghijklmnopqrstuvwxyz";
    
    }

## 工具类代码 ##

### 字符集工具类 ###

package com.xiaobai.toolclass.common.core.text;
    
    
    
    import com.xiaobai.toolclass.utils.StringUtils;
    
    import java.nio.charset.Charset;
    import java.nio.charset.StandardCharsets;
    
    /**
     * 字符集工具类
     * 
     * @author 小白程序员
     */
    public class CharsetKit
    {
        /** ISO-8859-1 */
        public static final String ISO_8859_1 = "ISO-8859-1";
        /** UTF-8 */
        public static final String UTF_8 = "UTF-8";
        /** GBK */
        public static final String GBK = "GBK";
    
        /** ISO-8859-1 */
        public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);
        /** UTF-8 */
        public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);
        /** GBK */
        public static final Charset CHARSET_GBK = Charset.forName(GBK);
    
        /**
         * 转换为Charset对象
         * 
         * @param charset 字符集，为空则返回默认字符集
         * @return Charset
         */
        public static Charset charset(String charset)
        {
            return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);
        }
    
        /**
         * 转换字符串的字符集编码
         * 
         * @param source 字符串
         * @param srcCharset 源字符集，默认ISO-8859-1
         * @param destCharset 目标字符集，默认UTF-8
         * @return 转换后的字符集
         */
        public static String convert(String source, String srcCharset, String destCharset)
        {
            return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));
        }
    
        /**
         * 转换字符串的字符集编码
         * 
         * @param source 字符串
         * @param srcCharset 源字符集，默认ISO-8859-1
         * @param destCharset 目标字符集，默认UTF-8
         * @return 转换后的字符集
         */
        public static String convert(String source, Charset srcCharset, Charset destCharset)
        {
            if (null == srcCharset)
            {
                srcCharset = StandardCharsets.ISO_8859_1;
            }
    
            if (null == destCharset)
            {
                destCharset = StandardCharsets.UTF_8;
            }
    
            if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset))
            {
                return source;
            }
            return new String(source.getBytes(srcCharset), destCharset);
        }
    
        /**
         * @return 系统字符集编码
         */
        public static String systemCharset()
        {
            return Charset.defaultCharset().name();
        }
    }

### 类型转换器 ###

package com.xiaobai.toolclass.common.core.text;
 
 
 
 import com.xiaobai.toolclass.utils.StringUtils;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.math.RoundingMode;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.text.NumberFormat;
 import java.util.Set;
 
 /**
 * 类型转换器
 * 
 * @author 小白程序员
 */
 public class Convert
 {
 /**
 * 转换为字符串 
 * 如果给定的值为null，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static String toStr(Object value, String defaultValue)
 {
 if (null == value)
 {
 return defaultValue;
 }
 if (value instanceof String)
 {
 return (String) value;
 }
 return value.toString();
 }
 
 /**
 * 转换为字符串 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static String toStr(Object value)
 {
 return toStr(value, null);
 }
 
 /**
 * 转换为字符 
 * 如果给定的值为null，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Character toChar(Object value, Character defaultValue)
 {
 if (null == value)
 {
 return defaultValue;
 }
 if (value instanceof Character)
 {
 return (Character) value;
 }
 
 final String valueStr = toStr(value, null);
 return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
 }
 
 /**
 * 转换为字符 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static Character toChar(Object value)
 {
 return toChar(value, null);
 }
 
 /**
 * 转换为byte 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Byte toByte(Object value, Byte defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof Byte)
 {
 return (Byte) value;
 }
 if (value instanceof Number)
 {
 return ((Number) value).byteValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 return Byte.parseByte(valueStr);
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为byte 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static Byte toByte(Object value)
 {
 return toByte(value, null);
 }
 
 /**
 * 转换为Short 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Short toShort(Object value, Short defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof Short)
 {
 return (Short) value;
 }
 if (value instanceof Number)
 {
 return ((Number) value).shortValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 return Short.parseShort(valueStr.trim());
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为Short 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static Short toShort(Object value)
 {
 return toShort(value, null);
 }
 
 /**
 * 转换为Number 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Number toNumber(Object value, Number defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof Number)
 {
 return (Number) value;
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 return NumberFormat.getInstance().parse(valueStr);
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为Number 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static Number toNumber(Object value)
 {
 return toNumber(value, null);
 }
 
 /**
 * 转换为int 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Integer toInt(Object value, Integer defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof Integer)
 {
 return (Integer) value;
 }
 if (value instanceof Number)
 {
 return ((Number) value).intValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 return Integer.parseInt(valueStr.trim());
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为int 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static Integer toInt(Object value)
 {
 return toInt(value, null);
 }
 
 /**
 * 转换为Integer数组 
 * 
 * @param str 被转换的值
 * @return 结果
 */
 public static Integer[] toIntArray(String str)
 {
 return toIntArray(",", str);
 }
 
 /**
 * 转换为Long数组 
 * 
 * @param str 被转换的值
 * @return 结果
 */
 public static Long[] toLongArray(String str)
 {
 return toLongArray(",", str);
 }
 
 /**
 * 转换为Integer数组 
 * 
 * @param split 分隔符
 * @param str 被转换的值
 * @return 结果
 */
 public static Integer[] toIntArray(String split, String str)
 {
 if (StringUtils.isEmpty(str))
 {
 return new Integer[] {};
 }
 String[] arr = str.split(split);
 final Integer[] ints = new Integer[arr.length];
 for (int i = 0; i < arr.length; i++)
 {
 final Integer v = toInt(arr[i], 0);
 ints[i] = v;
 }
 return ints;
 }
 
 /**
 * 转换为Long数组 
 * 
 * @param split 分隔符
 * @param str 被转换的值
 * @return 结果
 */
 public static Long[] toLongArray(String split, String str)
 {
 if (StringUtils.isEmpty(str))
 {
 return new Long[] {};
 }
 String[] arr = str.split(split);
 final Long[] longs = new Long[arr.length];
 for (int i = 0; i < arr.length; i++)
 {
 final Long v = toLong(arr[i], null);
 longs[i] = v;
 }
 return longs;
 }
 
 /**
 * 转换为String数组 
 * 
 * @param str 被转换的值
 * @return 结果
 */
 public static String[] toStrArray(String str)
 {
 return toStrArray(",", str);
 }
 
 /**
 * 转换为String数组 
 * 
 * @param split 分隔符
 * @param str 被转换的值
 * @return 结果
 */
 public static String[] toStrArray(String split, String str)
 {
 return str.split(split);
 }
 
 /**
 * 转换为long 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Long toLong(Object value, Long defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof Long)
 {
 return (Long) value;
 }
 if (value instanceof Number)
 {
 return ((Number) value).longValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 // 支持科学计数法
 return new BigDecimal(valueStr.trim()).longValue();
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为long 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static Long toLong(Object value)
 {
 return toLong(value, null);
 }
 
 /**
 * 转换为double 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Double toDouble(Object value, Double defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof Double)
 {
 return (Double) value;
 }
 if (value instanceof Number)
 {
 return ((Number) value).doubleValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 // 支持科学计数法
 return new BigDecimal(valueStr.trim()).doubleValue();
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为double 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static Double toDouble(Object value)
 {
 return toDouble(value, null);
 }
 
 /**
 * 转换为Float 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Float toFloat(Object value, Float defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof Float)
 {
 return (Float) value;
 }
 if (value instanceof Number)
 {
 return ((Number) value).floatValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 return Float.parseFloat(valueStr.trim());
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为Float 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static Float toFloat(Object value)
 {
 return toFloat(value, null);
 }
 
 /**
 * 转换为boolean 
 * String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Boolean toBool(Object value, Boolean defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof Boolean)
 {
 return (Boolean) value;
 }
 String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 valueStr = valueStr.trim().toLowerCase();
 switch (valueStr)
 {
 case "true":
 case "yes":
 case "ok":
 case "1":
 return true;
 case "false":
 case "no":
 case "0":
 return false;
 default:
 return defaultValue;
 }
 }
 
 /**
 * 转换为boolean 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static Boolean toBool(Object value)
 {
 return toBool(value, null);
 }
 
 /**
 * 转换为Enum对象 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 
 * @param clazz Enum的Class
 * @param value 值
 * @param defaultValue 默认值
 * @return Enum
 */
 public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (clazz.isAssignableFrom(value.getClass()))
 {
 @SuppressWarnings("unchecked")
 E myE = (E) value;
 return myE;
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 return Enum.valueOf(clazz, valueStr);
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为Enum对象 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 
 * @param clazz Enum的Class
 * @param value 值
 * @return Enum
 */
 public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value)
 {
 return toEnum(clazz, value, null);
 }
 
 /**
 * 转换为BigInteger 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static BigInteger toBigInteger(Object value, BigInteger defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof BigInteger)
 {
 return (BigInteger) value;
 }
 if (value instanceof Long)
 {
 return BigInteger.valueOf((Long) value);
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 return new BigInteger(valueStr);
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为BigInteger 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static BigInteger toBigInteger(Object value)
 {
 return toBigInteger(value, null);
 }
 
 /**
 * 转换为BigDecimal 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue)
 {
 if (value == null)
 {
 return defaultValue;
 }
 if (value instanceof BigDecimal)
 {
 return (BigDecimal) value;
 }
 if (value instanceof Long)
 {
 return new BigDecimal((Long) value);
 }
 if (value instanceof Double)
 {
 return BigDecimal.valueOf((Double) value);
 }
 if (value instanceof Integer)
 {
 return new BigDecimal((Integer) value);
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr))
 {
 return defaultValue;
 }
 try
 {
 return new BigDecimal(valueStr);
 }
 catch (Exception e)
 {
 return defaultValue;
 }
 }
 
 /**
 * 转换为BigDecimal 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 * 
 * @param value 被转换的值
 * @return 结果
 */
 public static BigDecimal toBigDecimal(Object value)
 {
 return toBigDecimal(value, null);
 }
 
 /**
 * 将对象转为字符串 
 * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
 * 
 * @param obj 对象
 * @return 字符串
 */
 public static String utf8Str(Object obj)
 {
 return str(obj, CharsetKit.CHARSET_UTF_8);
 }
 
 /**
 * 将对象转为字符串 
 * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
 * 
 * @param obj 对象
 * @param charsetName 字符集
 * @return 字符串
 */
 public static String str(Object obj, String charsetName)
 {
 return str(obj, Charset.forName(charsetName));
 }
 
 /**
 * 将对象转为字符串 
 * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
 * 
 * @param obj 对象
 * @param charset 字符集
 * @return 字符串
 */
 public static String str(Object obj, Charset charset)
 {
 if (null == obj)
 {
 return null;
 }
 
 if (obj instanceof String)
 {
 return (String) obj;
 }
 else if (obj instanceof byte[] || obj instanceof Byte[])
 {
 if (obj instanceof byte[])
 {
 return str((byte[]) obj, charset);
 }
 else
 {
 Byte[] bytes = (Byte[]) obj;
 int length = bytes.length;
 byte[] dest = new byte[length];
 for (int i = 0; i < length; i++)
 {
 dest[i] = bytes[i];
 }
 return str(dest, charset);
 }
 }
 else if (obj instanceof ByteBuffer)
 {
 return str((ByteBuffer) obj, charset);
 }
 return obj.toString();
 }
 
 /**
 * 将byte数组转为字符串
 * 
 * @param bytes byte数组
 * @param charset 字符集
 * @return 字符串
 */
 public static String str(byte[] bytes, String charset)
 {
 return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
 }
 
 /**
 * 解码字节码
 * 
 * @param data 字符串
 * @param charset 字符集，如果此字段为空，则解码的结果取决于平台
 * @return 解码后的字符串
 */
 public static String str(byte[] data, Charset charset)
 {
 if (data == null)
 {
 return null;
 }
 
 if (null == charset)
 {
 return new String(data);
 }
 return new String(data, charset);
 }
 
 /**
 * 将编码的byteBuffer数据转换为字符串
 * 
 * @param data 数据
 * @param charset 字符集，如果为空使用当前系统字符集
 * @return 字符串
 */
 public static String str(ByteBuffer data, String charset)
 {
 if (data == null)
 {
 return null;
 }
 
 return str(data, Charset.forName(charset));
 }
 
 /**
 * 将编码的byteBuffer数据转换为字符串
 * 
 * @param data 数据
 * @param charset 字符集，如果为空使用当前系统字符集
 * @return 字符串
 */
 public static String str(ByteBuffer data, Charset charset)
 {
 if (null == charset)
 {
 charset = Charset.defaultCharset();
 }
 return charset.decode(data).toString();
 }
 
 // ----------------------------------------------------------------------- 全角半角转换
 /**
 * 半角转全角
 * 
 * @param input String.
 * @return 全角字符串.
 */
 public static String toSBC(String input)
 {
 return toSBC(input, null);
 }
 
 /**
 * 半角转全角
 * 
 * @param input String
 * @param notConvertSet 不替换的字符集合
 * @return 全角字符串.
 */
 public static String toSBC(String input, Set<Character> notConvertSet)
 {
 char[] c = input.toCharArray();
 for (int i = 0; i < c.length; i++)
 {
 if (null != notConvertSet && notConvertSet.contains(c[i]))
 {
 // 跳过不替换的字符
 continue;
 }
 
 if (c[i] == ' ')
 {
 c[i] = '\u3000';
 }
 else if (c[i] < '\177')
 {
 c[i] = (char) (c[i] + 65248);
 
 }
 }
 return new String(c);
 }
 
 /**
 * 全角转半角
 * 
 * @param input String.
 * @return 半角字符串
 */
 public static String toDBC(String input)
 {
 return toDBC(input, null);
 }
 
 /**
 * 替换全角为半角
 * 
 * @param text 文本
 * @param notConvertSet 不替换的字符集合
 * @return 替换后的字符
 */
 public static String toDBC(String text, Set<Character> notConvertSet)
 {
 char[] c = text.toCharArray();
 for (int i = 0; i < c.length; i++)
 {
 if (null != notConvertSet && notConvertSet.contains(c[i]))
 {
 // 跳过不替换的字符
 continue;
 }
 
 if (c[i] == '\u3000')
 {
 c[i] = ' ';
 }
 else if (c[i] > '\uFF00' && c[i] < '\uFF5F')
 {
 c[i] = (char) (c[i] - 65248);
 }
 }
 return new String(c);
 }
 
 /**
 * 数字金额大写转换 先写个完整的然后将如零拾替换成零
 * 
 * @param n 数字
 * @return 中文大写数字
 */
 public static String digitUppercase(double n)
 {
 String[] fraction = { "角", "分" };
 String[] digit = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
 String[][] unit = { { "元", "万", "亿" }, { "", "拾", "佰", "仟" } };
 
 String head = n < 0 ? "负" : "";
 n = Math.abs(n);
 
 String s = "";
 for (int i = 0; i < fraction.length; i++)
 {
 // 优化double计算精度丢失问题
 BigDecimal nNum = new BigDecimal(n);
 BigDecimal decimal = new BigDecimal(10);
 BigDecimal scale = nNum.multiply(decimal).setScale(2, RoundingMode.HALF_EVEN);
 double d = scale.doubleValue();
 s += (digit[(int) (Math.floor(d * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
 }
 if (s.length() < 1)
 {
 s = "整";
 }
 int integerPart = (int) Math.floor(n);
 
 for (int i = 0; i < unit[0].length && integerPart > 0; i++)
 {
 String p = "";
 for (int j = 0; j < unit[1].length && n > 0; j++)
 {
 p = digit[integerPart % 10] + unit[1][j] + p;
 integerPart = integerPart / 10;
 }
 s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
 }
 return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
 }
 }

### 字符串格式化 ###

package com.xiaobai.toolclass.common.core.text;
 
 
 import com.xiaobai.toolclass.utils.StringUtils;
 
 /**
 * 字符串格式化
 * 
 * @author 小白程序员
 */
 public class StrFormatter
 {
 public static final String EMPTY_JSON = "{}";
 public static final char C_BACKSLASH = '\\';
 public static final char C_DELIM_START = '{';
 public static final char C_DELIM_END = '}';
 
 /**
 * 格式化字符串 
 * 此方法只是简单将占位符 {} 按照顺序替换为参数 
 * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可 
 * 例： 
 * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b 
 * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a 
 * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b 
 * 
 * @param strPattern 字符串模板
 * @param argArray 参数列表
 * @return 结果
 */
 public static String format(final String strPattern, final Object... argArray)
 {
 if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray))
 {
 return strPattern;
 }
 final int strPatternLength = strPattern.length();
 
 // 初始化定义好的长度以获得更好的性能
 StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
 
 int handledPosition = 0;
 int delimIndex;// 占位符所在位置
 for (int argIndex = 0; argIndex < argArray.length; argIndex++)
 {
 delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
 if (delimIndex == -1)
 {
 if (handledPosition == 0)
 {
 return strPattern;
 }
 else
 { // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果
 sbuf.append(strPattern, handledPosition, strPatternLength);
 return sbuf.toString();
 }
 }
 else
 {
 if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH)
 {
 if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH)
 {
 // 转义符之前还有一个转义符，占位符依旧有效
 sbuf.append(strPattern, handledPosition, delimIndex - 1);
 sbuf.append(Convert.utf8Str(argArray[argIndex]));
 handledPosition = delimIndex + 2;
 }
 else
 {
 // 占位符被转义
 argIndex--;
 sbuf.append(strPattern, handledPosition, delimIndex - 1);
 sbuf.append(C_DELIM_START);
 handledPosition = delimIndex + 1;
 }
 }
 else
 {
 // 正常占位符
 sbuf.append(strPattern, handledPosition, delimIndex);
 sbuf.append(Convert.utf8Str(argArray[argIndex]));
 handledPosition = delimIndex + 2;
 }
 }
 }
 // 加入最后一个占位符后所有的字符
 sbuf.append(strPattern, handledPosition, strPattern.length());
 
 return sbuf.toString();
 }
 }

### 工具类异常 ###

package com.xiaobai.toolclass.common.core.uuid;
    
    /**
     * 工具类异常
     * 
     * @author 小白程序员
     */
    public class UtilException extends RuntimeException
    {
        private static final long serialVersionUID = 8247610319171014183L;
    
        public UtilException(Throwable e)
        {
            super(e.getMessage(), e);
        }
    
        public UtilException(String message)
        {
            super(message);
        }
    
        public UtilException(String message, Throwable throwable)
        {
            super(message, throwable);
        }
    }

### 提供通用唯一识别码（universally unique identifier）（UUID）实现 ###

package com.xiaobai.toolclass.common.core.uuid;
 
 
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.util.Random;
 import java.util.concurrent.ThreadLocalRandom;
 
 /**
 * 提供通用唯一识别码（universally unique identifier）（UUID）实现
 *
 * @author 小白程序员
 */
 public final class UUID implements java.io.Serializable, Comparable<UUID>
 {
 private static final long serialVersionUID = -1185015143654744140L;
 
 /**
 * SecureRandom 的单例
 *
 */
 private static class Holder
 {
 static final SecureRandom numberGenerator = getSecureRandom();
 }
 
 /** 此UUID的最高64有效位 */
 private final long mostSigBits;
 
 /** 此UUID的最低64有效位 */
 private final long leastSigBits;
 
 /**
 * 私有构造
 * 
 * @param data 数据
 */
 private UUID(byte[] data)
 {
 long msb = 0;
 long lsb = 0;
 assert data.length == 16 : "data must be 16 bytes in length";
 for (int i = 0; i < 8; i++)
 {
 msb = (msb << 8) | (data[i] & 0xff);
 }
 for (int i = 8; i < 16; i++)
 {
 lsb = (lsb << 8) | (data[i] & 0xff);
 }
 this.mostSigBits = msb;
 this.leastSigBits = lsb;
 }
 
 /**
 * 使用指定的数据构造新的 UUID。
 *
 * @param mostSigBits 用于 {@code UUID} 的最高有效 64 位
 * @param leastSigBits 用于 {@code UUID} 的最低有效 64 位
 */
 public UUID(long mostSigBits, long leastSigBits)
 {
 this.mostSigBits = mostSigBits;
 this.leastSigBits = leastSigBits;
 }
 
 /**
 * 获取类型 4（伪随机生成的）UUID 的静态工厂。 
 * 
 * @return 随机生成的 {@code UUID}
 */
 public static UUID fastUUID()
 {
 return randomUUID(false);
 }
 
 /**
 * 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。
 * 
 * @return 随机生成的 {@code UUID}
 */
 public static UUID randomUUID()
 {
 return randomUUID(true);
 }
 
 /**
 * 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。
 * 
 * @param isSecure 是否使用{@link SecureRandom}如果是可以获得更安全的随机码，否则可以得到更好的性能
 * @return 随机生成的 {@code UUID}
 */
 public static UUID randomUUID(boolean isSecure)
 {
 final Random ng = isSecure ? Holder.numberGenerator : getRandom();
 
 byte[] randomBytes = new byte[16];
 ng.nextBytes(randomBytes);
 randomBytes[6] &= 0x0f; /* clear version */
 randomBytes[6] |= 0x40; /* set to version 4 */
 randomBytes[8] &= 0x3f; /* clear variant */
 randomBytes[8] |= 0x80; /* set to IETF variant */
 return new UUID(randomBytes);
 }
 
 /**
 * 根据指定的字节数组获取类型 3（基于名称的）UUID 的静态工厂。
 *
 * @param name 用于构造 UUID 的字节数组。
 *
 * @return 根据指定数组生成的 {@code UUID}
 */
 public static UUID nameUUIDFromBytes(byte[] name)
 {
 MessageDigest md;
 try
 {
 md = MessageDigest.getInstance("MD5");
 }
 catch (NoSuchAlgorithmException nsae)
 {
 throw new InternalError("MD5 not supported");
 }
 byte[] md5Bytes = md.digest(name);
 md5Bytes[6] &= 0x0f; /* clear version */
 md5Bytes[6] |= 0x30; /* set to version 3 */
 md5Bytes[8] &= 0x3f; /* clear variant */
 md5Bytes[8] |= 0x80; /* set to IETF variant */
 return new UUID(md5Bytes);
 }
 
 /**
 * 根据 {@link #toString()} 方法中描述的字符串标准表示形式创建{@code UUID}。
 *
 * @param name 指定 {@code UUID} 字符串
 * @return 具有指定值的 {@code UUID}
 * @throws IllegalArgumentException 如果 name 与 {@link #toString} 中描述的字符串表示形式不符抛出此异常
 *
 */
 public static UUID fromString(String name)
 {
 String[] components = name.split("-");
 if (components.length != 5)
 {
 throw new IllegalArgumentException("Invalid UUID string: " + name);
 }
 for (int i = 0; i < 5; i++)
 {
 components[i] = "0x" + components[i];
 }
 
 long mostSigBits = Long.decode(components[0]).longValue();
 mostSigBits <<= 16;
 mostSigBits |= Long.decode(components[1]).longValue();
 mostSigBits <<= 16;
 mostSigBits |= Long.decode(components[2]).longValue();
 
 long leastSigBits = Long.decode(components[3]).longValue();
 leastSigBits <<= 48;
 leastSigBits |= Long.decode(components[4]).longValue();
 
 return new UUID(mostSigBits, leastSigBits);
 }
 
 /**
 * 返回此 UUID 的 128 位值中的最低有效 64 位。
 *
 * @return 此 UUID 的 128 位值中的最低有效 64 位。
 */
 public long getLeastSignificantBits()
 {
 return leastSigBits;
 }
 
 /**
 * 返回此 UUID 的 128 位值中的最高有效 64 位。
 *
 * @return 此 UUID 的 128 位值中最高有效 64 位。
 */
 public long getMostSignificantBits()
 {
 return mostSigBits;
 }
 
 /**
 * 与此 {@code UUID} 相关联的版本号. 版本号描述此 {@code UUID} 是如何生成的。
 * 
 * 版本号具有以下含意:
 * <ul>
 * <li>1 基于时间的 UUID
 * <li>2 DCE 安全 UUID
 * <li>3 基于名称的 UUID
 * <li>4 随机生成的 UUID
 * </ul>
 *
 * @return 此 {@code UUID} 的版本号
 */
 public int version()
 {
 // Version is bits masked by 0x000000000000F000 in MS long
 return (int) ((mostSigBits >> 12) & 0x0f);
 }
 
 /**
 * 与此 {@code UUID} 相关联的变体号。变体号描述 {@code UUID} 的布局。
 * 
 * 变体号具有以下含意：
 * <ul>
 * <li>0 为 NCS 向后兼容保留
 * <li>2 <a href="http://www.ietf.org/rfc/rfc4122.txt">IETF RFC 4122</a>(Leach-Salz), 用于此类
 * <li>6 保留，微软向后兼容
 * <li>7 保留供以后定义使用
 * </ul>
 *
 * @return 此 {@code UUID} 相关联的变体号
 */
 public int variant()
 {
 // This field is composed of a varying number of bits.
 // 0 - - Reserved for NCS backward compatibility
 // 1 0 - The IETF aka Leach-Salz variant (used by this class)
 // 1 1 0 Reserved, Microsoft backward compatibility
 // 1 1 1 Reserved for future definition.
 return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62))) & (leastSigBits >> 63));
 }
 
 /**
 * 与此 UUID 相关联的时间戳值。
 *
 * 
 * 60 位的时间戳值根据此 {@code UUID} 的 time_low、time_mid 和 time_hi 字段构造。 
 * 所得到的时间戳以 100 毫微秒为单位，从 UTC（通用协调时间） 1582 年 10 月 15 日零时开始。
 *
 * 
 * 时间戳值仅在在基于时间的 UUID（其 version 类型为 1）中才有意义。 
 * 如果此 {@code UUID} 不是基于时间的 UUID，则此方法抛出 UnsupportedOperationException。
 *
 * @throws UnsupportedOperationException 如果此 {@code UUID} 不是 version 为 1 的 UUID。
 */
 public long timestamp() throws UnsupportedOperationException
 {
 checkTimeBase();
 return (mostSigBits & 0x0FFFL) << 48//
 | ((mostSigBits >> 16) & 0x0FFFFL) << 32//
 | mostSigBits >>> 32;
 }
 
 /**
 * 与此 UUID 相关联的时钟序列值。
 *
 * 
 * 14 位的时钟序列值根据此 UUID 的 clock_seq 字段构造。clock_seq 字段用于保证在基于时间的 UUID 中的时间唯一性。
 * 
 * {@code clockSequence} 值仅在基于时间的 UUID（其 version 类型为 1）中才有意义。 如果此 UUID 不是基于时间的 UUID，则此方法抛出
 * UnsupportedOperationException。
 *
 * @return 此 {@code UUID} 的时钟序列
 *
 * @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1
 */
 public int clockSequence() throws UnsupportedOperationException
 {
 checkTimeBase();
 return (int) ((leastSigBits & 0x3FFF000000000000L) >>> 48);
 }
 
 /**
 * 与此 UUID 相关的节点值。
 *
 * 
 * 48 位的节点值根据此 UUID 的 node 字段构造。此字段旨在用于保存机器的 IEEE 802 地址，该地址用于生成此 UUID 以保证空间唯一性。
 * 
 * 节点值仅在基于时间的 UUID（其 version 类型为 1）中才有意义。 
 * 如果此 UUID 不是基于时间的 UUID，则此方法抛出 UnsupportedOperationException。
 *
 * @return 此 {@code UUID} 的节点值
 *
 * @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1
 */
 public long node() throws UnsupportedOperationException
 {
 checkTimeBase();
 return leastSigBits & 0x0000FFFFFFFFFFFFL;
 }
 
 /**
 * 返回此{@code UUID} 的字符串表现形式。
 *
 * 
 * UUID 的字符串表示形式由此 BNF 描述：
 * 
 * <pre>
 * {@code
 * UUID = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node>
 * time_low = 4*<hexOctet>
 * time_mid = 2*<hexOctet>
 * time_high_and_version = 2*<hexOctet>
 * variant_and_sequence = 2*<hexOctet>
 * node = 6*<hexOctet>
 * hexOctet = <hexDigit><hexDigit>
 * hexDigit = [0-9a-fA-F]
 * }
 * </pre>
 * 
 * </blockquote>
 *
 * @return 此{@code UUID} 的字符串表现形式
 * @see #toString(boolean)
 */
 @Override
 public String toString()
 {
 return toString(false);
 }
 
 /**
 * 返回此{@code UUID} 的字符串表现形式。
 *
 * 
 * UUID 的字符串表示形式由此 BNF 描述：
 * 
 * <pre>
 * {@code
 * UUID = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node>
 * time_low = 4*<hexOctet>
 * time_mid = 2*<hexOctet>
 * time_high_and_version = 2*<hexOctet>
 * variant_and_sequence = 2*<hexOctet>
 * node = 6*<hexOctet>
 * hexOctet = <hexDigit><hexDigit>
 * hexDigit = [0-9a-fA-F]
 * }
 * </pre>
 * 
 * </blockquote>
 *
 * @param isSimple 是否简单模式，简单模式为不带'-'的UUID字符串
 * @return 此{@code UUID} 的字符串表现形式
 */
 public String toString(boolean isSimple)
 {
 final StringBuilder builder = new StringBuilder(isSimple ? 32 : 36);
 // time_low
 builder.append(digits(mostSigBits >> 32, 8));
 if (false == isSimple)
 {
 builder.append('-');
 }
 // time_mid
 builder.append(digits(mostSigBits >> 16, 4));
 if (false == isSimple)
 {
 builder.append('-');
 }
 // time_high_and_version
 builder.append(digits(mostSigBits, 4));
 if (false == isSimple)
 {
 builder.append('-');
 }
 // variant_and_sequence
 builder.append(digits(leastSigBits >> 48, 4));
 if (false == isSimple)
 {
 builder.append('-');
 }
 // node
 builder.append(digits(leastSigBits, 12));
 
 return builder.toString();
 }
 
 /**
 * 返回此 UUID 的哈希码。
 *
 * @return UUID 的哈希码值。
 */
 @Override
 public int hashCode()
 {
 long hilo = mostSigBits ^ leastSigBits;
 return ((int) (hilo >> 32)) ^ (int) hilo;
 }
 
 /**
 * 将此对象与指定对象比较。
 * 
 * 当且仅当参数不为 {@code null}、而是一个 UUID 对象、具有与此 UUID 相同的 varriant、包含相同的值（每一位均相同）时，结果才为 {@code true}。
 *
 * @param obj 要与之比较的对象
 *
 * @return 如果对象相同，则返回 {@code true}；否则返回 {@code false}
 */
 @Override
 public boolean equals(Object obj)
 {
 if ((null == obj) || (obj.getClass() != UUID.class))
 {
 return false;
 }
 UUID id = (UUID) obj;
 return (mostSigBits == id.mostSigBits && leastSigBits == id.leastSigBits);
 }
 
 // Comparison Operations
 
 /**
 * 将此 UUID 与指定的 UUID 比较。
 *
 * 
 * 如果两个 UUID 不同，且第一个 UUID 的最高有效字段大于第二个 UUID 的对应字段，则第一个 UUID 大于第二个 UUID。
 *
 * @param val 与此 UUID 比较的 UUID
 *
 * @return 在此 UUID 小于、等于或大于 val 时，分别返回 -1、0 或 1。
 *
 */
 @Override
 public int compareTo(UUID val)
 {
 // The ordering is intentionally set up so that the UUIDs
 // can simply be numerically compared as two numbers
 return (this.mostSigBits < val.mostSigBits ? -1 : //
 (this.mostSigBits > val.mostSigBits ? 1 : //
 (this.leastSigBits < val.leastSigBits ? -1 : //
 (this.leastSigBits > val.leastSigBits ? 1 : //
 0))));
 }
 
 // -------------------------------------------------------------------------------------------------------------------
 // Private method start
 /**
 * 返回指定数字对应的hex值
 * 
 * @param val 值
 * @param digits 位
 * @return 值
 */
 private static String digits(long val, int digits)
 {
 long hi = 1L << (digits * 4);
 return Long.toHexString(hi | (val & (hi - 1))).substring(1);
 }
 
 /**
 * 检查是否为time-based版本UUID
 */
 private void checkTimeBase()
 {
 if (version() != 1)
 {
 throw new UnsupportedOperationException("Not a time-based UUID");
 }
 }
 
 /**
 * 获取{@link SecureRandom}，类提供加密的强随机数生成器 (RNG)
 * 
 * @return {@link SecureRandom}
 */
 public static SecureRandom getSecureRandom()
 {
 try
 {
 return SecureRandom.getInstance("SHA1PRNG");
 }
 catch (NoSuchAlgorithmException e)
 {
 throw new UtilException(e);
 }
 }
 
 /**
 * 获取随机数生成器对象 
 * ThreadLocalRandom是JDK 7之后提供并发产生随机数，能够解决多个线程发生的竞争争夺。
 * 
 * @return {@link ThreadLocalRandom}
 */
 public static ThreadLocalRandom getRandom()
 {
 return ThreadLocalRandom.current();
 }
 }

### 操作消息提醒 ###

package com.xiaobai.toolclass.common.core.web.domain;
 
 
 
 import com.xiaobai.toolclass.common.core.constant.HttpStatus;
 import com.xiaobai.toolclass.utils.StringUtils;
 
 import java.util.HashMap;
 import java.util.Objects;
 
 /**
 * 操作消息提醒
 * 
 * @author 小白程序员
 */
 public class AjaxResult extends HashMap<String, Object>
 {
 private static final long serialVersionUID = 1L;
 
 /** 状态码 */
 public static final String CODE_TAG = "code";
 
 /** 返回内容 */
 public static final String MSG_TAG = "msg";
 
 /** 数据对象 */
 public static final String DATA_TAG = "data";
 
 /**
 * 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。
 */
 public AjaxResult()
 {
 }
 
 /**
 * 初始化一个新创建的 AjaxResult 对象
 * 
 * @param code 状态码
 * @param msg 返回内容
 */
 public AjaxResult(int code, String msg)
 {
 super.put(CODE_TAG, code);
 super.put(MSG_TAG, msg);
 }
 
 /**
 * 初始化一个新创建的 AjaxResult 对象
 * 
 * @param code 状态码
 * @param msg 返回内容
 * @param data 数据对象
 */
 public AjaxResult(int code, String msg, Object data)
 {
 super.put(CODE_TAG, code);
 super.put(MSG_TAG, msg);
 if (StringUtils.isNotNull(data))
 {
 super.put(DATA_TAG, data);
 }
 }
 
 /**
 * 返回成功消息
 * 
 * @return 成功消息
 */
 public static AjaxResult success()
 {
 return AjaxResult.success("操作成功");
 }
 
 /**
 * 返回成功数据
 * 
 * @return 成功消息
 */
 public static AjaxResult success(Object data)
 {
 return AjaxResult.success("操作成功", data);
 }
 
 /**
 * 返回成功消息
 * 
 * @param msg 返回内容
 * @return 成功消息
 */
 public static AjaxResult success(String msg)
 {
 return AjaxResult.success(msg, null);
 }
 
 /**
 * 返回成功消息
 * 
 * @param msg 返回内容
 * @param data 数据对象
 * @return 成功消息
 */
 public static AjaxResult success(String msg, Object data)
 {
 return new AjaxResult(HttpStatus.SUCCESS, msg, data);
 }
 
 /**
 * 返回警告消息
 *
 * @param msg 返回内容
 * @return 警告消息
 */
 public static AjaxResult warn(String msg)
 {
 return AjaxResult.warn(msg, null);
 }
 
 /**
 * 返回警告消息
 *
 * @param msg 返回内容
 * @param data 数据对象
 * @return 警告消息
 */
 public static AjaxResult warn(String msg, Object data)
 {
 return new AjaxResult(HttpStatus.WARN, msg, data);
 }
 
 /**
 * 返回错误消息
 * 
 * @return 错误消息
 */
 public static AjaxResult error()
 {
 return AjaxResult.error("操作失败");
 }
 
 /**
 * 返回错误消息
 * 
 * @param msg 返回内容
 * @return 错误消息
 */
 public static AjaxResult error(String msg)
 {
 return AjaxResult.error(msg, null);
 }
 
 /**
 * 返回错误消息
 * 
 * @param msg 返回内容
 * @param data 数据对象
 * @return 错误消息
 */
 public static AjaxResult error(String msg, Object data)
 {
 return new AjaxResult(HttpStatus.ERROR, msg, data);
 }
 
 /**
 * 返回错误消息
 * 
 * @param code 状态码
 * @param msg 返回内容
 * @return 错误消息
 */
 public static AjaxResult error(int code, String msg)
 {
 return new AjaxResult(code, msg, null);
 }
 
 /**
 * 是否为成功消息
 *
 * @return 结果
 */
 public boolean isSuccess()
 {
 return Objects.equals(HttpStatus.SUCCESS, this.get(CODE_TAG));
 }
 
 /**
 * 是否为警告消息
 *
 * @return 结果
 */
 public boolean isWarn()
 {
 return Objects.equals(HttpStatus.WARN, this.get(CODE_TAG));
 }
 
 /**
 * 是否为错误消息
 *
 * @return 结果
 */
 public boolean isError()
 {
 return Objects.equals(HttpStatus.ERROR, this.get(CODE_TAG));
 }
 
 /**
 * 方便链式调用
 *
 * @param key
 * @param value
 * @return
 */
 @Override
 public AjaxResult put(String key, Object value)
 {
 super.put(key, value);
 return this;
 }
 }

### 时间工具类 ###

package com.xiaobai.toolclass.utils;
    
    import org.apache.commons.lang3.time.DateFormatUtils;
    
    import java.lang.management.ManagementFactory;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.time.*;
    import java.util.Date;
    
    /**
     * 时间工具类
     *
     * @author 小白程序员
     * 使用时需要导入lang3的依赖
     */
    public class DateUtils extends org.apache.commons.lang3.time.DateUtils
    {
        public static String YYYY = "yyyy";
    
        public static String YYYY_MM = "yyyy-MM";
    
        public static String YYYY_MM_DD = "yyyy-MM-dd";
    
        public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
    
        public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
    
        private static String[] parsePatterns = {
                "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
                "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
                "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};
    
        /**
         * 获取当前Date型日期
         *
         * @return Date() 当前日期
         */
        public static Date getNowDate()
        {
            return new Date();
        }
    
        /**
         * 获取当前日期, 默认格式为yyyy-MM-dd
         *
         * @return String
         */
        public static String getDate()
        {
            return dateTimeNow(YYYY_MM_DD);
        }
    
        public static final String getTime()
        {
            return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
        }
    
        public static final String dateTimeNow()
        {
            return dateTimeNow(YYYYMMDDHHMMSS);
        }
    
        public static final String dateTimeNow(final String format)
        {
            return parseDateToStr(format, new Date());
        }
    
        public static final String dateTime(final Date date)
        {
            return parseDateToStr(YYYY_MM_DD, date);
        }
    
        public static final String parseDateToStr(final String format, final Date date)
        {
            return new SimpleDateFormat(format).format(date);
        }
    
        public static final Date dateTime(final String format, final String ts)
        {
            try
            {
                return new SimpleDateFormat(format).parse(ts);
            }
            catch (ParseException e)
            {
                throw new RuntimeException(e);
            }
        }
    
        /**
         * 日期路径 即年/月/日 如2018/08/08
         */
        public static final String datePath()
        {
            Date now = new Date();
            return DateFormatUtils.format(now, "yyyy/MM/dd");
        }
    
        /**
         * 日期路径 即年/月/日 如20180808
         */
        public static final String dateTime()
        {
            Date now = new Date();
            return DateFormatUtils.format(now, "yyyyMMdd");
        }
    
        /**
         * 日期型字符串转化为日期 格式
         */
        public static Date parseDate(Object str)
        {
            if (str == null)
            {
                return null;
            }
            try
            {
                return parseDate(str.toString(), parsePatterns);
            }
            catch (ParseException e)
            {
                return null;
            }
        }
    
        /**
         * 获取服务器启动时间
         */
        public static Date getServerStartDate()
        {
            long time = ManagementFactory.getRuntimeMXBean().getStartTime();
            return new Date(time);
        }
    
        /**
         * 计算时间差
         *
         * @param endDate 最后时间
         * @param startTime 开始时间
         * @return 时间差（天/小时/分钟）
         */
        public static String timeDistance(Date endDate, Date startTime)
        {
            long nd = 1000 * 24 * 60 * 60;
            long nh = 1000 * 60 * 60;
            long nm = 1000 * 60;
            // long ns = 1000;
            // 获得两个时间的毫秒时间差异
            long diff = endDate.getTime() - startTime.getTime();
            // 计算差多少天
            long day = diff / nd;
            // 计算差多少小时
            long hour = diff % nd / nh;
            // 计算差多少分钟
            long min = diff % nd % nh / nm;
            // 计算差多少秒//输出结果
            // long sec = diff % nd % nh % nm / ns;
            return day + "天" + hour + "小时" + min + "分钟";
        }
    
        /**
         * 增加 LocalDateTime ==> Date
         */
        public static Date toDate(LocalDateTime temporalAccessor)
        {
            ZonedDateTime zdt = temporalAccessor.atZone(ZoneId.systemDefault());
            return Date.from(zdt.toInstant());
        }
    
        /**
         * 增加 LocalDate ==> Date
         */
        public static Date toDate(LocalDate temporalAccessor)
        {
            LocalDateTime localDateTime = LocalDateTime.of(temporalAccessor, LocalTime.of(0, 0, 0));
            ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
            return Date.from(zdt.toInstant());
        }
    }

### ID生成器工具类 ###

package com.xiaobai.toolclass.utils;
    
    import com.xiaobai.toolclass.common.core.uuid.UUID;
    
    /**
     * ID生成器工具类
     * 
     * @author OnlineMuseums
     */
    public class IdUtils
    {
        /**
         * 获取随机UUID
         * 
         * @return 随机UUID
         */
        public static String randomUUID()
        {
            return UUID.randomUUID().toString();
        }
    
        /**
         * 简化的UUID，去掉了横线
         * 
         * @return 简化的UUID，去掉了横线
         */
        public static String simpleUUID()
        {
            return UUID.randomUUID().toString(true);
        }
    
        /**
         * 获取随机UUID，使用性能更好的ThreadLocalRandom生成UUID
         * 
         * @return 随机UUID
         */
        public static String fastUUID()
        {
            return UUID.fastUUID().toString();
        }
    
        /**
         * 简化的UUID，去掉了横线，使用性能更好的ThreadLocalRandom生成UUID
         * 
         * @return 简化的UUID，去掉了横线
         */
        public static String fastSimpleUUID()
        {
            return UUID.fastUUID().toString(true);
        }
    }

### Jwt工具类 ###

package com.xiaobai.toolclass.utils;
 
 
 import com.xiaobai.toolclass.common.core.constant.SecurityConstants;
 import com.xiaobai.toolclass.common.core.constant.TokenConstants;
 import com.xiaobai.toolclass.common.core.text.Convert;
 import io.jsonwebtoken.Claims;
 import io.jsonwebtoken.Jwts;
 import io.jsonwebtoken.SignatureAlgorithm;
 
 
 import java.util.Map;
 
 /**
 * Jwt工具类
 *
 * @author OnlineMuseums
 */
 public class JwtUtils
 {
 public static String secret = TokenConstants.SECRET;
 
 /**
 * 从数据声明生成令牌
 *
 * @param claims 数据声明
 * @return 令牌
 */
 public static String createToken(Map<String, Object> claims)
 {
 String token = Jwts.builder().setClaims(claims).signWith(SignatureAlgorithm.HS512, secret).compact();
 return token;
 }
 
 /**
 * 从令牌中获取数据声明
 *
 * @param token 令牌
 * @return 数据声明
 */
 public static Claims parseToken(String token)
 {
 return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
 }
 
 /**
 * 根据令牌获取用户标识
 * 
 * @param token 令牌
 * @return 用户ID
 */
 public static String getUserKey(String token)
 {
 Claims claims = parseToken(token);
 return getValue(claims, SecurityConstants.USER_KEY);
 }
 
 /**
 * 根据令牌获取用户标识
 * 
 * @param claims 身份信息
 * @return 用户ID
 */
 public static String getUserKey(Claims claims)
 {
 return getValue(claims, SecurityConstants.USER_KEY);
 }
 
 /**
 * 根据令牌获取用户ID
 * 
 * @param token 令牌
 * @return 用户ID
 */
 public static String getUserId(String token)
 {
 Claims claims = parseToken(token);
 return getValue(claims, SecurityConstants.DETAILS_USER_ID);
 }
 
 /**
 * 根据身份信息获取用户ID
 * 
 * @param claims 身份信息
 * @return 用户ID
 */
 public static String getUserId(Claims claims)
 {
 return getValue(claims, SecurityConstants.DETAILS_USER_ID);
 }
 
 /**
 * 根据令牌获取用户名
 * 
 * @param token 令牌
 * @return 用户名
 */
 public static String getUserName(String token)
 {
 Claims claims = parseToken(token);
 return getValue(claims, SecurityConstants.DETAILS_USERNAME);
 }
 
 /**
 * 根据身份信息获取用户名
 * 
 * @param claims 身份信息
 * @return 用户名
 */
 public static String getUserName(Claims claims)
 {
 return getValue(claims, SecurityConstants.DETAILS_USERNAME);
 }
 
 /**
 * 根据身份信息获取键值
 * 
 * @param claims 身份信息
 * @param key 键
 * @return 值
 */
 public static String getValue(Claims claims, String key)
 {
 return Convert.toStr(claims.get(key), "");
 }
 }

### 字符串工具类 ###

package com.xiaobai.toolclass.utils;
 
 import com.xiaobai.toolclass.common.core.constant.Constants;
 import com.xiaobai.toolclass.common.core.text.StrFormatter;
 import org.springframework.util.AntPathMatcher;
 
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 
 
 /**
 * 字符串工具类
 * 
 * @author 小白程序员
 * 使用时需要导入text目录下的所有文件
 */
 public class StringUtils extends org.apache.commons.lang3.StringUtils
 {
 /** 空字符串 */
 private static final String NULLSTR = "";
 
 /** 下划线 */
 private static final char SEPARATOR = '_';
 
 /**
 * 获取参数不为空值
 * 
 * @param value defaultValue 要判断的value
 * @return value 返回值
 */
 public static <T> T nvl(T value, T defaultValue)
 {
 return value != null ? value : defaultValue;
 }
 
 /**
 * * 判断一个Collection是否为空， 包含List，Set，Queue
 * 
 * @param coll 要判断的Collection
 * @return true：为空 false：非空
 */
 public static boolean isEmpty(Collection<?> coll)
 {
 return isNull(coll) || coll.isEmpty();
 }
 
 /**
 * * 判断一个Collection是否非空，包含List，Set，Queue
 * 
 * @param coll 要判断的Collection
 * @return true：非空 false：空
 */
 public static boolean isNotEmpty(Collection<?> coll)
 {
 return !isEmpty(coll);
 }
 
 /**
 * * 判断一个对象数组是否为空
 * 
 * @param objects 要判断的对象数组
 ** @return true：为空 false：非空
 */
 public static boolean isEmpty(Object[] objects)
 {
 return isNull(objects) || (objects.length == 0);
 }
 
 /**
 * * 判断一个对象数组是否非空
 * 
 * @param objects 要判断的对象数组
 * @return true：非空 false：空
 */
 public static boolean isNotEmpty(Object[] objects)
 {
 return !isEmpty(objects);
 }
 
 /**
 * * 判断一个Map是否为空
 * 
 * @param map 要判断的Map
 * @return true：为空 false：非空
 */
 public static boolean isEmpty(Map<?, ?> map)
 {
 return isNull(map) || map.isEmpty();
 }
 
 /**
 * * 判断一个Map是否为空
 * 
 * @param map 要判断的Map
 * @return true：非空 false：空
 */
 public static boolean isNotEmpty(Map<?, ?> map)
 {
 return !isEmpty(map);
 }
 
 /**
 * * 判断一个字符串是否为空串
 * 
 * @param str String
 * @return true：为空 false：非空
 */
 public static boolean isEmpty(String str)
 {
 return isNull(str) || NULLSTR.equals(str.trim());
 }
 
 /**
 * * 判断一个字符串是否为非空串
 * 
 * @param str String
 * @return true：非空串 false：空串
 */
 public static boolean isNotEmpty(String str)
 {
 return !isEmpty(str);
 }
 
 /**
 * * 判断一个对象是否为空
 * 
 * @param object Object
 * @return true：为空 false：非空
 */
 public static boolean isNull(Object object)
 {
 return object == null;
 }
 
 /**
 * * 判断一个对象是否非空
 * 
 * @param object Object
 * @return true：非空 false：空
 */
 public static boolean isNotNull(Object object)
 {
 return !isNull(object);
 }
 
 /**
 * * 判断一个对象是否是数组类型（Java基本型别的数组）
 * 
 * @param object 对象
 * @return true：是数组 false：不是数组
 */
 public static boolean isArray(Object object)
 {
 return isNotNull(object) && object.getClass().isArray();
 }
 
 /**
 * 去空格
 */
 public static String trim(String str)
 {
 return (str == null ? "" : str.trim());
 }
 
 /**
 * 截取字符串
 * 
 * @param str 字符串
 * @param start 开始
 * @return 结果
 */
 public static String substring(final String str, int start)
 {
 if (str == null)
 {
 return NULLSTR;
 }
 
 if (start < 0)
 {
 start = str.length() + start;
 }
 
 if (start < 0)
 {
 start = 0;
 }
 if (start > str.length())
 {
 return NULLSTR;
 }
 
 return str.substring(start);
 }
 
 /**
 * 截取字符串
 * 
 * @param str 字符串
 * @param start 开始
 * @param end 结束
 * @return 结果
 */
 public static String substring(final String str, int start, int end)
 {
 if (str == null)
 {
 return NULLSTR;
 }
 
 if (end < 0)
 {
 end = str.length() + end;
 }
 if (start < 0)
 {
 start = str.length() + start;
 }
 
 if (end > str.length())
 {
 end = str.length();
 }
 
 if (start > end)
 {
 return NULLSTR;
 }
 
 if (start < 0)
 {
 start = 0;
 }
 if (end < 0)
 {
 end = 0;
 }
 
 return str.substring(start, end);
 }
 
 /**
 * 判断是否为空，并且不是空白字符
 * 
 * @param str 要判断的value
 * @return 结果
 */
 public static boolean hasText(String str)
 {
 return (str != null && !str.isEmpty() && containsText(str));
 }
 
 private static boolean containsText(CharSequence str)
 {
 int strLen = str.length();
 for (int i = 0; i < strLen; i++)
 {
 if (!Character.isWhitespace(str.charAt(i)))
 {
 return true;
 }
 }
 return false;
 }
 
 /**
 * 格式化文本, {} 表示占位符 
 * 此方法只是简单将占位符 {} 按照顺序替换为参数 
 * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可 
 * 例： 
 * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b 
 * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a 
 * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b 
 * 
 * @param template 文本模板，被替换的部分用 {} 表示
 * @param params 参数值
 * @return 格式化后的文本
 */
 public static String format(String template, Object... params)
 {
 if (isEmpty(params) || isEmpty(template))
 {
 return template;
 }
 return StrFormatter.format(template, params);
 }
 
 /**
 * 是否为http(s)://开头
 * 
 * @param link 链接
 * @return 结果
 */
 public static boolean ishttp(String link)
 {
 return StringUtils.startsWithAny(link, Constants.HTTP, Constants.HTTPS);
 }
 
 /**
 * 判断给定的collection列表中是否包含数组array 判断给定的数组array中是否包含给定的元素value
 *
 * @param collection 给定的集合
 * @param array 给定的数组
 * @return boolean 结果
 */
 public static boolean containsAny(Collection<String> collection, String... array)
 {
 if (isEmpty(collection) || isEmpty(array))
 {
 return false;
 }
 else
 {
 for (String str : array)
 {
 if (collection.contains(str))
 {
 return true;
 }
 }
 return false;
 }
 }
 
 /**
 * 驼峰转下划线命名
 */
 public static String toUnderScoreCase(String str)
 {
 if (str == null)
 {
 return null;
 }
 StringBuilder sb = new StringBuilder();
 // 前置字符是否大写
 boolean preCharIsUpperCase = true;
 // 当前字符是否大写
 boolean curreCharIsUpperCase = true;
 // 下一字符是否大写
 boolean nexteCharIsUpperCase = true;
 for (int i = 0; i < str.length(); i++)
 {
 char c = str.charAt(i);
 if (i > 0)
 {
 preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
 }
 else
 {
 preCharIsUpperCase = false;
 }
 
 curreCharIsUpperCase = Character.isUpperCase(c);
 
 if (i < (str.length() - 1))
 {
 nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
 }
 
 if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
 {
 sb.append(SEPARATOR);
 }
 else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
 {
 sb.append(SEPARATOR);
 }
 sb.append(Character.toLowerCase(c));
 }
 
 return sb.toString();
 }
 
 /**
 * 是否包含字符串
 * 
 * @param str 验证字符串
 * @param strs 字符串组
 * @return 包含返回true
 */
 public static boolean inStringIgnoreCase(String str, String... strs)
 {
 if (str != null && strs != null)
 {
 for (String s : strs)
 {
 if (str.equalsIgnoreCase(trim(s)))
 {
 return true;
 }
 }
 }
 return false;
 }
 
 /**
 * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
 * 
 * @param name 转换前的下划线大写方式命名的字符串
 * @return 转换后的驼峰式命名的字符串
 */
 public static String convertToCamelCase(String name)
 {
 StringBuilder result = new StringBuilder();
 // 快速检查
 if (name == null || name.isEmpty())
 {
 // 没必要转换
 return "";
 }
 else if (!name.contains("_"))
 {
 // 不含下划线，仅将首字母大写
 return name.substring(0, 1).toUpperCase() + name.substring(1);
 }
 // 用下划线将原始字符串分割
 String[] camels = name.split("_");
 for (String camel : camels)
 {
 // 跳过原始字符串中开头、结尾的下换线或双重下划线
 if (camel.isEmpty())
 {
 continue;
 }
 // 首字母大写
 result.append(camel.substring(0, 1).toUpperCase());
 result.append(camel.substring(1).toLowerCase());
 }
 return result.toString();
 }
 
 /**
 * 驼峰式命名法
 * 例如：user_name->userName
 */
 public static String toCamelCase(String s)
 {
 if (s == null)
 {
 return null;
 }
 if (s.indexOf(SEPARATOR) == -1)
 {
 return s;
 }
 s = s.toLowerCase();
 StringBuilder sb = new StringBuilder(s.length());
 boolean upperCase = false;
 for (int i = 0; i < s.length(); i++)
 {
 char c = s.charAt(i);
 
 if (c == SEPARATOR)
 {
 upperCase = true;
 }
 else if (upperCase)
 {
 sb.append(Character.toUpperCase(c));
 upperCase = false;
 }
 else
 {
 sb.append(c);
 }
 }
 return sb.toString();
 }
 
 /**
 * 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
 * 
 * @param str 指定字符串
 * @param strs 需要检查的字符串数组
 * @return 是否匹配
 */
 public static boolean matches(String str, List<String> strs)
 {
 if (isEmpty(str) || isEmpty(strs))
 {
 return false;
 }
 for (String pattern : strs)
 {
 if (isMatch(pattern, str))
 {
 return true;
 }
 }
 return false;
 }
 
 /**
 * 判断url是否与规则配置: 
 * ? 表示单个字符; 
 * * 表示一层路径内的任意字符串，不可跨层级; 
 * ** 表示任意层路径;
 * 
 * @param pattern 匹配规则
 * @param url 需要匹配的url
 * @return
 */
 public static boolean isMatch(String pattern, String url)
 {
 AntPathMatcher matcher = new AntPathMatcher();
 return matcher.match(pattern, url);
 }
 
 @SuppressWarnings("unchecked")
 public static <T> T cast(Object obj)
 {
 return (T) obj;
 }
 
 /**
 * 数字左边补齐0，使之达到指定长度。注意，如果数字转换为字符串后，长度大于size，则只保留 最后size个字符。
 * 
 * @param num 数字对象
 * @param size 字符串指定长度
 * @return 返回数字的字符串格式，该字符串为指定长度。
 */
 public static final String padl(final Number num, final int size)
 {
 return padl(num.toString(), size, '0');
 }
 
 /**
 * 字符串左补齐。如果原始字符串s长度大于size，则只保留最后size个字符。
 * 
 * @param s 原始字符串
 * @param size 字符串指定长度
 * @param c 用于补齐的字符
 * @return 返回指定长度的字符串，由原字符串左补齐或截取得到。
 */
 public static final String padl(final String s, final int size, final char c)
 {
 final StringBuilder sb = new StringBuilder(size);
 if (s != null)
 {
 final int len = s.length();
 if (s.length() <= size)
 {
 for (int i = size - len; i > 0; i--)
 {
 sb.append(c);
 }
 sb.append(s);
 }
 else
 {
 return s.substring(len - size, len);
 }
 }
 else
 {
 for (int i = size; i > 0; i--)
 {
 sb.append(c);
 }
 }
 return sb.toString();
 }
 }