java时间公用和StringUnitl以及java调用存储过程

1  构建存储过程的语句信息

/**
     * 从Function名称和参数信息拼接数据库存储过程访问SQL语句
     * 示例：
     * {?= call f_conf_qr_queryallconfig(?, ?, ?, ?, ?, ?, ?, ?)}
     * @param funcName Function名称
     * @param params 参数信息
     * @return 数据库存储过程访问SQL语句
     */
    String buildRunSql(final String funcName, final Object[][] params)
    {
        final StringBuffer buffer = new StringBuffer();
        buffer.append(WorkerKeys.LEFT_BRACKET);
        //拼接Oracle的function返回值处理
        buffer.append(WorkerKeys.WENHAO).append(WorkerKeys.EQUAL_MARK);
        buffer.append(WorkerKeys.DB_CALL_MARK).append(funcName);       
        if (null != params)
        {
            //参数部分字符串 (?, ?, ?)
            buffer.append(WorkerKeys.LEFT_GUAHAO);
            for (int i = 0; i < params.length; i++)
            {
                buffer.append(0 == i ? DaoKeys.EMPTY : WorkerKeys.COMMA_BLANK);
                buffer.append(WorkerKeys.WENHAO_STR);
            }
            buffer.append(WorkerKeys.RIGHT_GUAHAO);
        }
        buffer.append(WorkerKeys.RIGHT_BRACKET);
        return buffer.toString();
    }
   
  2 调用存储过程信息
   String[][] params = new String[][] {
            {DaoKeys.IN_STR, DaoKeys.VARCHAR, phoneNumber}, //电话号码
            {DaoKeys.IN_STR, DaoKeys.VARCHAR, toneInfo.getTonecode()}, //铃音编码
            {DaoKeys.IN_STR, DaoKeys.VARCHAR, toneInfo.getPurchase()}, //订购时间
            {DaoKeys.OUT_STR, DaoKeys.INTEGER, DaoKeys.EMPTY}}; //返回码
  String runSql = buildRunSql("",params);
   CallableStatement callableStatement = Connection.prepareCall(runSql);
   callableStatement.execute();
  
   ==================================================================
   /*
* 文 件 名:  TimeUtils.java
* 版    权:   Huawei Technologies Co., Ltd. Copyright YYYY-YYYY,  All rights reserved
* 描    述:   时间工具类
* 修 改 人:  w00106790
* 修改时间: 2012-03-08
* 修改版本: COMMON V1.0
* 修改内容: 新增
*
* 修改人：王顺
* 修改内容：新增getDBTimeOnceADay方法
* 修改时间： 2012-08-21
*/
package com.huawei.common.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

import com.huawei.common.constants.TimeKeys;
import com.huawei.common.system.action.SystemActions;


public final class TimeUtils
{
    /**
     * 时间正则表达式与格式对应关系
     */
    private static final String[][] COM_PATTERNS = new String[][]{
        new String[]{TimeKeys.REGEX_YYYY_MM_DD, TimeKeys.YYYY_MM_DD},
        new String[]{TimeKeys.REGEX_YYYY_MM_DD_HH_MM_SS, TimeKeys.YYYY_MM_DD_HH_MM_SS},
        new String[]{TimeKeys.REGEX_YYYYMMDD, TimeKeys.YYYYMMDD},
        new String[]{TimeKeys.REGEX_YYYYMMDDHHMMSS, TimeKeys.YYYYMMDDHHMMSS},
        new String[]{TimeKeys.REGEX_HH_MM_SS, TimeKeys.HH_MM_SS}
    };
   
    /**
     * 特殊时间正则表达式与格式对应关系
     */
    private static final String[][] SPECIAL_PATTERNS = new String[][]{
        //调用中音的qryUserTone的时候有些局点返回的时间格式是yyyy.MM.dd
        new String[]{TimeKeys.REGEX_YYYY_MM_DD_EX1, TimeKeys.YYYY_MM_DD_EX1}
    };
   
    /**
     * 数据库时间获取器
     */
    private static final DBTimeGetter DAILY_GETTER = new DBTimeGetter(TimeKeys.DAY_MILLIS);
       
    /**
     * 工具类，私有化构造方法
     */
    private TimeUtils()
    {

    }

    /**
     * 对输入时间进行加法操作（因子可以为负数，此时表减法）
     * @param inputTime 输入时间
     * @param field 加法类型
     * 1、Calendar.MONTH 按月份
     * 2、Calendar.DATE  按天
     * 3、Calendar.MINUTE  --按分钟
     * @param amount 增加幅度 负数则为减法
     * @return 加法后的时间
     */
    public static long addTime(long inputTime, int field, int amount)
    {
        //日期方法
        final Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date(inputTime));
        calendar.add(field, amount);
        return calendar.getTimeInMillis();
    }

    /**
     * 在原有日期上加上指定天数
     * @param inputTimeStr 原来日期String型
     * @param timePattern 时间格式
     * @param field 加法类型
     * 1、Calendar.MONTH 按月份
     * 2、Calendar.DATE  按天
     * 3、Calendar.MINUTE  --按分钟
     * @param amount 增加幅度 负数则为减法
     * @return date
     */
    public static String addTime(String inputTimeStr, String timePattern, int field, int amount)
    {
        //获取输入时间的长整型值
        long inputTime;
        try
        {
            inputTime = parseTimeInMillis(inputTimeStr, timePattern);
        }
        catch (ParseException e1)
        {
            return null;
        }

        //获取时间加减后的值
        long addedInputTime = addTime(inputTime, field, amount);

        //对时间进行字符串格式化
        return formatTime(addedInputTime, timePattern);
    }

    /**
     * 获取当前时间是否在约定的开始结束时间之间
     * @param beginTime 开始时间
     * @param endTime 结束时间
     * @return 是否在约定时间内
     * @throws ParseException 解析异常信息
     */
    public static boolean isThisTimeBetween(String beginTime, String endTime) throws ParseException
    {
        //时间格式器
        final SimpleDateFormat format = new SimpleDateFormat(TimeKeys.HH_MM_SS);

        //解析开始结束时间并获取当前时间
        final long beginTimeL = format.parse(beginTime).getTime();
        final long endTimeL = format.parse(endTime).getTime();
        final long thisTimeL = format.parse(format.format(new Date())).getTime();

        //返回当前时间是否在两者之间
        return (thisTimeL >= beginTimeL) && (thisTimeL <= endTimeL);
    }

    /**
     * 数据库时间格式转换
     * @param inputTime 字符串时间
     * @return long型时间
     * @throws ParseException 解析异常
     */
    public static long parseTimeInMillis(String inputTime) throws ParseException
    {
        //默认不支持特殊格式的时间格式
        return parseTimeInMillis(inputTime, false);
    }
   
    /**
     * 数据库时间格式转换
     * @param inputTime 字符串时间
     * @param specialPattern 特殊格式
     * @return long型时间
     * @throws ParseException 解析异常
     */
    public static long parseTimeInMillis(String inputTime, boolean specialPattern) throws ParseException
    {
        //判断输入时间是否为空，为空直接返回码
        if (StringUtils.isBlank(inputTime))
        {
            throw new ParseException("Empty param value input!", 0);
        }
       
        //根据输入时间获取格式
        String pattern = getTimePattern(inputTime, TimeKeys.HH_MM_SS, specialPattern);

        //解析
        return parseTimeInMillis(inputTime, pattern);
    }

    /**
     * 格式化字符串时间
     * @param inputTime 字符串时间
     * @param pattern 格式类型
     * @return 格式化后的时间（long型）
     * @throws ParseException 格式化异常
     */
    public static long parseTimeInMillis(String inputTime, String pattern) throws ParseException
    {
        //初始化格式初始工具
        final DateFormat dateFormat = new SimpleDateFormat(pattern);

        //格式化字符串
        final Date inputDate = dateFormat.parse(inputTime);

        //格式化字符串
        return inputDate.getTime();
    }

    /**
     * 根据时间值获取时间格式
     * @param inputTime 时间的值
     * @param defPattern 默认格式
     * @param specialPattern 特殊格式
     * @return 时间格式
     */
    private static String getTimePattern(String inputTime, String defPattern, boolean specialPattern)
    {
        //循环列表进行判断处理
        int length = COM_PATTERNS.length;
        for (int i = 0; i < length; i++)
        {
            //判断是否匹配正则表达式
            if (inputTime.matches(COM_PATTERNS[i][0]))
            {
                return COM_PATTERNS[i][1];
            }
        }
       
        //不包括特殊格式则直接返回
        if (!specialPattern)
        {
            return defPattern;
        }
       
        //循环遍历特殊格式列表
        length = SPECIAL_PATTERNS.length;
        for (int i = 0; i < length; i++)
        {
            //判断是否匹配正则表达式
            if (inputTime.matches(SPECIAL_PATTERNS[i][0]))
            {
                return SPECIAL_PATTERNS[i][1];
            }
        }
       
        //其他情况返回默认值
        return defPattern;
    }

    /**
     * 将Long型时间转换为字符串
     * @param inputTime long型时间
     * @param pattern 类型
     * @return 返回字符串时间
     */
    public static String formatTime(long inputTime, String pattern)
    {
        //返回格式化后的字符串时间
        return new SimpleDateFormat(pattern).format(new Date(inputTime));
    }
   
    /**
     * 将某格式字符串类型时间转换为另一个格式字符串
     * @param inputTime 字符串型时间
     * @param inputPattern 输入时间的格式
     * @param outputPattern 输出时间的格式
     * @return 返回字符串时间
     */
    public static String formatTime(String inputTime, String inputPattern, String outputPattern)
    {
        Date date = parseTime0(inputTime, inputPattern);
        //返回格式化后的字符串时间
        return new SimpleDateFormat(outputPattern).format(date);
    }

    /**
     * 将日期型时间转换为字符串
     * @param date 日期型时间
     * @param pattern 类型
     * @return 返回字符串时间
     */
    public static String formatTime(Date date, String pattern)
    {
        //返回格式化后的字符串时间
        return new SimpleDateFormat(pattern).format(date);
    }

    /**
     * 得到当前日期和时间
     * @param pattern 格式类型
     * @return 当前日期和时间
     */
    public static String getJavaThisTime(String pattern)
    {
        return new SimpleDateFormat(pattern).format(new Date());
    }

    /**
     * 获取今天开始时间的毫秒值
     * @return 今天开始时间的毫秒值
     */
    public static long getJavaTodayStartTime()
    {
        //获取JAVA系统当前时间
        final Calendar calendar = Calendar.getInstance();

        //使用内部方法获取今天的开始时间
        return getCalendarDayTopTime(calendar, false).getTimeInMillis();
    }

    /**
     * 获取今天结束时间的毫秒值
     * @return 今天结束时间的毫秒值
     */
    public static long getJavaTodayEndTime()
    {
        //获取JAVA系统当前时间
        final Calendar calendar = Calendar.getInstance();

        //使用内部方法获取今天的开始时间
        return getCalendarDayTopTime(calendar, true).getTimeInMillis();
    }

    /**
     * 获取今天开始时间的毫秒值
     * @param calendar0 日历对象
     * @param isEndDay 是否获取天的结束时间
     * @return 返回日历对象一天的开始或结束时间
     */
    public static Calendar getCalendarDayTopTime(Calendar calendar0, boolean isEndDay)
    {
        //检查日历对象
        final Calendar calendar = null == calendar0 ? Calendar.getInstance(Locale.ENGLISH) : calendar0;

        //清除当前的小时、分钟、秒 和 毫秒
        calendar.set(Calendar.MILLISECOND, 0);//清除毫秒位数字
        calendar.set(Calendar.SECOND, 0);//清除秒钟位数字
        calendar.set(Calendar.MINUTE, 0);//清除分钟位数字
        calendar.set(Calendar.HOUR_OF_DAY, 0);//清除小时位数字

        //判断是否为结束时间
        if (isEndDay)
        {
            //时间向后增加一天
            calendar.add(Calendar.DATE, 1);
            //退后一天的当天开始时间再减去一毫秒，则为当天的最后时间
            calendar.add(Calendar.MILLISECOND, -1);
        }

        //返回日历对象
        return calendar;
    }

    /**
     * 得到昨天当前日期和时间
     * @param pattern 格式类型
     * @return 当前日期和时间
     */
    public static String getJavaYesterdayThisTime(String pattern)
    {
        //获取系统当前时间
        long thisTime = System.currentTimeMillis();

        //获取昨天的当前时间
        long yesterdayThisTime = addTime(thisTime, Calendar.DATE, -1);

        //长整型时间转字符串
        return formatTime(yesterdayThisTime, pattern);
    }

    /**
     * 获取DB时间一天到数据库查询一次
     * 时间格式为：yyyyMMddHHmmss
     * @return 数据库系统时间
     */
    public static String getGoodishDBTimeDaily()
    {
        //获取指定格式的数据库时间
        return DAILY_GETTER.getFormatedGoodishDBThisTime(TimeKeys.YYYYMMDDHHMMSS);
    }
   
    /**
     * 获取DB时间一天到数据库查询一次
     * 时间格式为：yyyyMMddHHmmss
     * @return 数据库系统时间
     */
    public static long getGoodishDBTimeDailyInMillis()
    {
        //获取指定格式的数据库时间
        return DAILY_GETTER.getGoodishDBThisTime();
    }
   
    /**
     * 转换时间格式
     * @param inputTime 时间参数
     * @param toFormat 目标格式
     * @return 目标格式的时间
     */
    public static String switchTimeFormat(String inputTime, String toFormat)
    {
        //默认不支持特殊格式的时间格式进行检查跳转
        return switchTimeFormat(inputTime, toFormat, false);
    }
   
    /**
     * 转换时间格式
     * @param inputTime 时间参数
     * @param toFormat 目标格式
     * @param specialPattern 特殊格式
     * @return 目标格式的时间
     */
    public static String switchTimeFormat(String inputTime, String toFormat, boolean specialPattern)
    {
        //判断时间是否为空，为空直接返回
        if (StringUtils.isBlank(inputTime) || StringUtils.isBlank(toFormat))
        {
            return inputTime;
        }
       
        //根据输入时间获取格式
        String fromFormat = getTimePattern(inputTime, toFormat, specialPattern);
       
        //判断目标格式与当前格式是否一致,则直接返回
        if (toFormat.equals(fromFormat))
        {
            return inputTime;
        }

        //进行时间格式转换
        return switchTimeFormat(inputTime, fromFormat, Locale.getDefault(), toFormat, Locale.getDefault());
    }

    /**
     * 从一个时间格式转换到另一个时间格式
     * @param dateTime  需要改变的时间
     * @param fromFormat 原来的时间格式
     * @param toFormat 目标时间格式
     * @return 将原来的时间格式转换成需要的时间格式字符串
     */
    public static String switchTimeFormat(String dateTime, String fromFormat, String toFormat)
    {
        //使用默认语言类型进行转换
        return switchTimeFormat(dateTime, fromFormat, Locale.getDefault(), toFormat, Locale.getDefault());
    }

    /**
     * 从一个时间格式转换到另一个时间格式
     * @param dateTime  需要改变的时间
     * @param fromFormat 原来的时间格式
     * @param fromLocale 语言类型
     * @param toFormat 目标时间格式
     * @param toLocale  语言类型
     * @return 将原来的时间格式转换成需要的时间格式字符串
     */
    public static String switchTimeFormat(String dateTime, String fromFormat,
        Locale fromLocale, String toFormat, Locale toLocale)
    {
        //判断时间参数是否为空，为空直接返回
        if (StringUtils.isBlank(dateTime))
        {
            return dateTime;
        }

        //源格式
        final DateFormat from = new SimpleDateFormat(fromFormat, fromLocale);
        //目的格式
        final DateFormat to = new SimpleDateFormat(toFormat, toLocale);

        try
        {
            final Date date = from.parse(dateTime);
            return to.format(date);
        }
        catch (ParseException e)
        {
            return dateTime;
        }
    }

    /**
     * 检查字符串时间是为指定格式
     * @param inputTime 字符串格式的时间
     * @param pattern 类型
     * @return 是否指定格式的时间
     */
    public static boolean validateTimePattern(String inputTime, String pattern)
    {
        //初始化格式初始工具
        final DateFormat dateFormat = new SimpleDateFormat(pattern);
        //设置为强校验
        dateFormat.setLenient(false);

        try
        {
            //解析字符串时间
            dateFormat.parse(inputTime);
        }
        catch (ParseException e)
        {
            return false;
        }

        //返回成功
        return true;
    }
   
    /**
     * 检查字符串时间是为指定格式
     * @param inputTime 字符串格式的时间
     * @param pattern 类型
     * @return 是否指定格式的时间
     */
    public static boolean validateForceTimePattern(String inputTime, String pattern)
    {
        //判断时间内容是否为空
        if (StringUtils.isBlank(inputTime) || null == pattern)
        {
            return false;
        }
       
        //判断字符串长度是否一致
        if (inputTime.length() != pattern.length())
        {
            return false;
        }
       
        //格式校验
        return validateTimePattern(inputTime, pattern);
    }

    /**
     * UTC日期对象与Local日历对象进行跳转
     * @param calendar 日历对象
     * @param localToUTC 是否本地转UTC
     * @return 新的日历对象
     */
    private static Calendar switchUTCAndLocal(Calendar calendar, boolean localToUTC)
    {
        //获取时区域
        int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);
        int destOffset = calendar.get(Calendar.DST_OFFSET);

        //获取偏移量值(小时值)
        int hourOffset = (int)((zoneOffset + destOffset) / TimeKeys.HOUR_MILLIS);

        //获取现有的小时数值
        int curHours = calendar.get(Calendar.HOUR_OF_DAY);

        //获取系统新的小时值
        int newCurHours = localToUTC ? curHours - hourOffset : curHours + hourOffset;

        //更改时间为标准时间
        calendar.set(Calendar.HOUR_OF_DAY, newCurHours);

        //返回当前日历对象
        return calendar;
    }

    /**
     * 转换UTC至本地日历
     * @param utcCalendar UTC日历对象
     * @return 本地日历对象
     */
    public static Calendar changeUTCToLocal(Calendar utcCalendar)
    {
        return null == utcCalendar ? null : switchUTCAndLocal(utcCalendar, false);
    }

    /**
     * 转换本地至UTC日历
     * @param localCalendar 本地 日历对象
     * @return UTC日历对象
     */
    public static Calendar changeLocalToUTC(Calendar localCalendar)
    {
        return null == localCalendar ? null : switchUTCAndLocal(localCalendar, true);
    }

    /**
     * 获取系统当前UTC日历对象
     * @return 系统当前UTC日历对象
     */
    public static Calendar getThisUTCCalendar()
    {
        //获取本地系统日历对象
        Calendar calendar = Calendar.getInstance();

        //日历对象转换为UTC
        return switchUTCAndLocal(calendar, true);
    }

    /**
     * 获取格式为yyyy-MM-dd HH:mm:ssUTC当前时间
     * @return UTC当前时间
     */
    public static String getUTCThisTime()
    {
        return getUTCThisTime(TimeKeys.YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取系统当前时间
     * @param pattern 指定格式
     * @return 系统当前时间
     */
    public static String getUTCThisTime(String pattern)
    {
        //日历对象转换为UTC
        Calendar calendarUTC = getThisUTCCalendar();

        //日历信息转字符串
        return formatTime(calendarUTC.getTime(), pattern);
    }

    /**
     * 将格林威治时间转化成本地时间,返回格式为String
     * 格林威治时间+8小时=北京时间
     * @param utcTime 传入的格林威治
     * @param pattern 输入输出时间格式
     * @return 本地时间
     */
    public static String changeUTCToLocalString(String utcTime, String pattern)
    {
        return changeUTCToLocalString(utcTime, pattern, pattern);
    }

    /**
     * 将格林威治时间转化成本地时间,返回格式为String
     * 格林威治时间+8小时=北京时间
     * @param utcTime 传入的格林威治
     * @param inputPattern 输入时间格式
     * @param outputPattern 输出时间格式
     * @return 本地时间
     */
    public static String changeUTCToLocalString(String utcTime, String inputPattern, String outputPattern)
    {
        //判断输入的UTC字符串是否为空
        if (StringUtils.isBlank(utcTime))
        {
            return null;
        }

        //日期显示格式
        SimpleDateFormat format = new SimpleDateFormat(inputPattern);
        Date utcDate = format.parse(utcTime, new ParsePosition(utcTime.indexOf("")));

        //获取日历对象
        Calendar utcCalendar = Calendar.getInstance();
        utcCalendar.setTime(utcDate);

        //获取本地日历对象
        Calendar localCalendar = switchUTCAndLocal(utcCalendar, false);

        //转换时间为指定格式
        return new SimpleDateFormat(outputPattern).format(localCalendar.getTime());
    }

    /**
     * 将本地时间转化为UTC（格林威治）时间,返回格式为Calendar
     * 格林时间+8小时=北京时间
     * 说明：该方法不能自行删除，soap接口测试页面再使用
     * @param localTime 传入的本地时间
     * @param pattern 格式类型  时间 格式yyyy-MM-dd HH:mm:ss
     * @return UTC（格林威治）时间
     */
    public static Calendar changeToUTCCalendar(String localTime, String pattern)
    {
        //判断输入的UTC字符串是否为空
        if (StringUtils.isBlank(localTime))
        {
            return null;
        }

        //获取系统当前日历对象
        Calendar localCalendar = Calendar.getInstance();
        // 日期显示格式
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        Date localDate = format.parse(localTime, new ParsePosition(localTime.indexOf("")));
        //把时间放到日历表中
        localCalendar.setTime(localDate);

        // 返回UTC时间格式
        return switchUTCAndLocal(localCalendar, true);
    }

    /**
     * 将本地时间转化为UTC（格林威治）时间
     * 格林时间+8小时=北京时间
     * @param localTime 传入的本地时间 格式yyyy-MM-dd HH:mm:ss
     * @param pattern 输入输出时间格式
     * @return UTC（格林威治）时间 格式yyyy-MM-dd HH:mm:ss
     */
    public static String changeLocalToUTCString(String localTime, String pattern)
    {
        return changeLocalToUTCString(localTime, pattern, pattern);
    }

    /**
     * 将本地时间转化为UTC（格林威治）时间
     * 格林时间+8小时=北京时间
     * @param localTime 传入的本地时间 格式yyyy-MM-dd HH:mm:ss
     * @param inputPattern 输入时间格式
     * @param outputPattern 输出时间格式
     * @return UTC（格林威治）时间 格式yyyy-MM-dd HH:mm:ss
     */
    public static String changeLocalToUTCString(String localTime, String inputPattern, String outputPattern)
    {
        Calendar calendar = changeToUTCCalendar(localTime, inputPattern);

        //返回UTC时间格式
        return new SimpleDateFormat(outputPattern).format(calendar.getTime());
    }

    /**
     * 将Long型时间转换为字符串
     * @param inputTime long型时间
     * @param pattern 类型
     * @return 返回字符串时间
     */
    public static String parseTimeToStr(final long inputTime, final String pattern)
    {
        //初始化格式初始工具
        final DateFormat dateFormat = new SimpleDateFormat(pattern);

        //获取时间对象
        final Date date = new Date(inputTime);

        //返回格式化后的字符串时间
        return dateFormat.format(date);
    }
   
    /**
     * 解析事件内部方法
     * @param inputTime 输入时间
     * @param pattern 格式信息
     * @return 返回码对象
     */
    private static Date parseTime0(String inputTime, String pattern)
    {
        //判断输入时间是否为空
        if (StringUtils.isBlank(inputTime))
        {
            return null;
        }
       
        //初始化指定格式的初始工具
        DateFormat dateFormat = new SimpleDateFormat(pattern);
        try
        {
            return dateFormat.parse(inputTime);
        }
        catch (Exception e)
        {
            return null;
        }
    }
   
    /**
     * 事件比较方法
     * @param leftTime 左时间
     * @param rightTime 右事件
     * @param pattern 时间格式
     * @return 整型 -1：（leftTime < rightTime）,0:相等； 1：（leftTime > rightTime）
     */
    public static int compareTime(String leftTime, String rightTime, String pattern)
    {
        //格式化字符串
        Date leftDate = parseTime0(leftTime, pattern);
        Date rightDate = parseTime0(rightTime, pattern);
       
        //判断时间对象是否为空
        if (null == leftDate || null == rightDate)
        {
            return null == leftDate ? ((null == rightDate) ? 0 : -1) : 1;
        }
       
        //使用时间比较方法
        return leftDate.compareTo(rightDate);
    }
   
    /**
     * 获取本月第一天
     * @param pattern 时间格式
     * @return 当月第一天
     */
    public static String getFirstDayThisMonth(String pattern)
    {
        //若格式为空时，赋默认值
        if (StringUtils.isBlank(pattern))
        {
            pattern = TimeKeys.YYYY_MM_DD;
        }
        Calendar calendar = Calendar.getInstance();
       
        //设置当前日期
        calendar.setTime(new Date());
       
        //取得当前月的最小日期(天)
        int firstDay = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
        calendar.set(Calendar.DAY_OF_MONTH, firstDay);
       
        //格式化成字符串
        return new SimpleDateFormat(pattern).format(calendar.getTime());
    }
   
    /**
     * 获取本月最后一天
     * @param pattern 时间格式
     * @return 本月最后一天
     */
    public static String getLastDayThisMonth(String pattern)
    {
        //若格式为空时，赋默认值
        if (StringUtils.isBlank(pattern))
        {
            pattern = TimeKeys.YYYY_MM_DD;
        }
        Calendar calendar = Calendar.getInstance();
       
        //设置当前日期
        calendar.setTime(new Date());
       
        //取得当前月的最大日期(天)
        int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        calendar.set(Calendar.DAY_OF_MONTH, lastDay);
       
        // 格式化成字符串
        return new SimpleDateFormat(pattern).format(calendar.getTime());
    }
   
    /**
     * 数据库时间协助类
     * @version  [COMMON, 2012-8-23]
     */
    public static class DBTimeGetter
    {
        /**
         * 访问的间隔时间
         */
        private final long accessInterval;
       
        /**
         * 最近一次访问数据库时间
         */
        private long lastAccessTime;
       
        /**
         * JAVA与数据库时间偏差
         */
        private long offset;
       
        /**
         * <默认构造函数>
         * @param accessInterval 访问的间隔时间
         */
        public DBTimeGetter(long accessInterval)
        {
            this.accessInterval = accessInterval;
            this.lastAccessTime = 0;
            this.offset = 0;
        }
       
        /**
         * 获取数据库时间
         * @return 数据库时间
         */
        public static long queryDBThisTime()
        {
            //定义数据库配置信息
            String[] dbSystemParams;
            //定义数据库当前时间对象
            long dbThisTime = -1;
           
            try
            {
                //访问数据库获取系统信息
                dbSystemParams = SystemActions.queryDBSystemInfo();
               
                //获取时间字符串字段信息
                if (null != dbSystemParams && dbSystemParams.length > 0)
                {
                    //解析时间至长整型
                    dbThisTime = parseTimeInMillis(dbSystemParams[0], TimeKeys.YYYY_MM_DD_HH_MM_SS);
                }
            }
            catch (Exception e)
            {
                dbThisTime = -1;
            }
           
            //返回数据库当前时间
            return dbThisTime;
        }
       
        /**
         * 获取格式化后的数据库时间
         * @param pattern 时间格式
         * @return 格式化后的数据库时间
         */
        public static String getFormatedDBThisTime(String pattern)
        {
            //获取数据库当前时间
            long dbThisTime = queryDBThisTime();
            if (dbThisTime < 0)
            {
                dbThisTime = System.currentTimeMillis();
            }
           
            //格式化时间
            return formatTime(dbThisTime, null == pattern ? TimeKeys.YYYY_MM_DD_HH_MM_SS : pattern);
        }
       
        /**
         * 获取存在误差的数据库时间
         * @return 数据库时间
         */
        public long getGoodishDBThisTime()
        {
            //获取JAVA当前时间
            long javaThisTime = System.currentTimeMillis();
                       
            //定义数据库当前时间
            long dbThisTime;
           
            //仅当间隔时间大于0，则进行误差时间获取
            if (this.accessInterval <= 0)
            {
                dbThisTime = queryDBThisTime();
                return dbThisTime < 0 ? javaThisTime : dbThisTime;
            }
           
            //判断当前时间是否满足更新条件
            if (lastAccessTime + accessInterval <= javaThisTime)
            {
                //获取数据库时间
                synchronized (this)
                {
                    if (lastAccessTime + accessInterval <= javaThisTime)
                    {
                        this.lastAccessTime = javaThisTime;
                       
                        //获取数据库时间
                        dbThisTime = queryDBThisTime();
                        if (dbThisTime < 0)
                        {
                            dbThisTime = javaThisTime;
                        }
                       
                        //获取时间误差值
                        this.offset = dbThisTime - javaThisTime;
                    }
                }
            }
           
            //获取数据库当前时间
            return javaThisTime + this.offset;
        }
       
        /**
         * 获取带误差数据库时间的格式化字符串
         * @param pattern 格式字符串
         * @return 格式化后的字符串
         */
        public String getFormatedGoodishDBThisTime(String pattern)
        {
            //获取带误差的数据库时间
            long goodishDBThisTime = getGoodishDBThisTime();
           
            //格式化时间至字符串
            return formatTime(goodishDBThisTime, null == pattern ? TimeKeys.YYYY_MM_DD_HH_MM_SS : pattern);
        }
    }
   
    /**
     * 获取以毫秒的形式获取UTC当前时间
     * @return 以毫秒的形式的UTC当前时间
     */
    public static long getUTCTimeInMillis()
    {
        //1、取得本地时间
        Calendar calendar = Calendar.getInstance();  
       
        //2、取得时间偏移量    
        int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);  
       
        //3、取得夏令时差 
        int dstOffset = calendar.get(Calendar.DST_OFFSET);   
       
        //4、从本地时间里扣除这些差量，即可以取得UTC时间   
        calendar.add(Calendar.MILLISECOND, -(zoneOffset + dstOffset));   
       
        return calendar.getTimeInMillis();
    }
}
=====================================================================================================
public final class TimeKeys
{
    //**************************************************************************************/
    /**
     * 一秒钟大小
     */
    public static final long SECOND_MILLIS = 1000;
   
    /**
     * 一分钟大小
     */
    public static final long MINUTE_MILLIS = 60 * SECOND_MILLIS;
   
    /**
     * 一小时大小
     */
    public static final long HOUR_MILLIS = 60 * MINUTE_MILLIS;
   
    /**
     * 一天大小
     */
    public static final long DAY_MILLIS = 24 * HOUR_MILLIS;
   
    /**
     * 半小时大小
     */
    public static final long HALF_HOUR_MILLIS = 30 * MINUTE_MILLIS;
 
    //**************************************************************************************/
 
    //**************************************************************************************/
    /**
     * 时间格式1：yyyy-MM-dd HH:mm:ss.SSS
     */
    public static final String YYYY_MM_DD_HH_MM_SS_SSS = "yyyy-MM-dd HH:mm:ss.SSS";
       
    /**
     * 时间格式2： yyyy-MM-dd HH:mm:ss
     */
    public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
   
    /**
     * 时间格式3： yyyyMMddHHmmss
     */
    public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
   
    /**
     * 时间格式4： yyyy-MM-dd
     */
    public static final String YYYY_MM_DD = "yyyy-MM-dd";
   
    /**
     * 时间格式5： yyyyMMdd
     */
    public static final String YYYYMMDD = "yyyyMMdd";
   
    /**
     * 时间格式6： HH:mm:ss
     */
    public static final String HH_MM_SS = "HH:mm:ss";
   
    /**
     * 时间格式7：MMddHHmm
     */
    public static final String MMDDHHMM = "MMddHHmm";
   
    /**
     * 时间格式8： HHmmss
     */
    public static final String HHMMSS = "HHmmss";
   
    /**
     * 时间格式：HHmmssSSS
     */
    public static final String HHMMSSSSS = "HHmmssSSS";
   
    /**
     * 时间格式9：yyMMddHHmmssSSS
     */
    public static final String YYYYMMDDHHMMSSSSS = "yyyyMMddHHmmssSSS";
   
    /**
     * 全时间格式10： yyyy-MM-dd HH:mm:ss.SSS a Z E D w
     */
    public static final String YYYY_MM_DD_HH_MM_SS_FULL = "yyyy-MM-dd HH:mm:ss.SSS a Z E D w";
   
    /**
     * 时间格式11： yyyy.MM.dd
     */
    public static final String YYYY_MM_DD_EX1 = "yyyy.MM.dd";
   
    /**
     * JSON时间格式
     */
    public static final String YYYY_MM_DD_T_HH_MM_SS = "yyyy-MM-dd'T'HH:mm:ss";
   
    /**
     * 年份
     */
    public static final String YYYY = "yyyy";
   
    /**
     * 月份
     */
    public static final String MM = "MM";
   
    /**
     * 日
     */
    public static final String DD = "dd";
   
    /**
     * 小时
     */
    public static final String HH = "HH";
   
    /**
     * 分钟
     */
    public static final String MM_S = "mm";
   
    /**
     * 秒钟
     */
    public static final String SS = "ss";
   
    /**
     * 年周
     */
    public static final String YYYYW = "yyyyw";

    /**
     * 年周
     */
    public static final String YYYY_W = "yyyy w";
    //**************************************************************************************/
     
    //**************************************************************************************/
    /**
     * 日期时间
     */
    public static final String REGEX_YYYY_MM_DD = "\\d{4}-\\d{1,2}-\\d{1,2}";
   
    /**
     * 日期时间
     */
    public static final String REGEX_YYYY_MM_DD_HH_MM_SS =
        "\\d{4}-\\d{1,2}-\\d{1,2} ([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]";

    /**
     * 日期时间
     */
    public static final String REGEX_YYYYMMDD = "\\d{4}\\d{1,2}\\d{1,2}";
   
    /**
     * 日期时间
     */
    public static final String REGEX_YYYYMMDDHHMMSS = "\\d{4}\\d{1,2}\\d{1,2}([01][0-9]|2[0-3])[0-5][0-9][0-5][0-9]";
   
    /**
     * 时间格式
     */
    public static final String REGEX_HH_MM_SS = "([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]";
   
    /**
     * 时间格式
     */
    public static final String REGEX_YYYY_MM_DD_EX1 = "\\d{4}\\.\\d{1,2}\\.\\d{1,2}";
   
    /**
     * 常理类，私有化构造方法
     */
    private TimeKeys()
    {
       
    }
}
======================================================================================
public final class StringUtils
{
    /**
     * 空字符串
     */
    public static final String EMPTY = "";

    /**
     * 私有构造方法
     */
    private StringUtils()
    {
        super();
    }

    /**
     * 是否为空串(判断是否为null 或 "")
     * isEmpty(null)  = true;
     * isEmpty("")  = true;
     * isEmpty("  ")  = false;
     * @param value 输入的字符串
     * @return 是否为空串
     */
    public static boolean isEmpty(String value)
    {
        return null == value || 0 == value.length();
    }

    /**
     * 是否为空格串(判断是否为null 、"" 或 "   ")
     * isBlank(null)  = true;
     * isBlank("")  = true;
     * isBlank("  ")  = true;
     * @param value 输入的字符串
     * @return 是否为空格串
     */
    public static boolean isBlank(String value)
    {
        //是否为空串，如果为空串直接返回
        return null == value || 0 == value.length() || EMPTY.equals(value.trim());
    }

    /**
     * 字符串是否为非空
     * @param value 输入的字符串
     * @return 是否为非空格串
     */
    public static boolean isNoBlank(String value)
    {
        return !isBlank(value);
    }

    /**
     * trim字符串操作（如果字符串为空，则返回传入的默认值）
     * @param value 需要处理的字符串
     * @param defValue 默认值字符串
     * @return 处理后的字符串
     */
    public static String defaultIfBlank(String value, String defValue)
    {
        //是否为空格字符串
        if (isBlank(value))
        {
            return defValue;
        }

        //将结果进行trim操作
        return value.trim();
    }

    /**
     * 字符串为空则使用默认字符串
     * @param value 需要处理的字符串
     * @param defValue 默认值字符串
     * @return 处理后的字符串
     */
    public static String defaultIfNull(String value, String defValue)
    {
        //是否为空格字符串
        return null == value ? defValue : value.trim();
    }

    /**
     * 字符串清理
     * @param value 需要处理的字符串
     * @return 清理后的字符串
     */
    public static String emptyIfBlank(String value)
    {
        return null == value ? EMPTY : value.trim();
    }

    /**
     * 正则匹配字符串
     * @param value 待处理的字符串
     * @param regex 正则表达式
     * @return 是否不匹配
     */
    public static boolean noMatches(String value, String regex)
    {
        return !matches(value, regex);
    }

    /**
     * 正则匹配字符串
     * @param value 待处理的字符串
     * @param regex 正则表达式
     * @return 是否匹配
     */
    public static boolean matches(String value, String regex)
    {
        //如果校验字符为空
        if ((null == value) || (null == regex))
        {
            return false;
        }

        //非空的话进行匹配
        return value.matches(regex);
    }

    /**
     * 先对输入字符串进行trim操作再进行正则匹配字符串
     * @param value 待处理的字符串
     * @param regex 正则表达式
     * @return 是否匹配
     */
    public static boolean trimAndmatches(String value, String regex)
    {
        //如果校验字符为空
        if ((null == value) || (null == regex))
        {
            return false;
        }

        //非空的话进行匹配
        return value.trim().matches(regex);
    }

    /**
     * 字符串trim并转小写
     * @param value 待处理的字符串
     * @return 转小写后字符串
     */
    public static String trimAndLowerCase(String value)
    {
        return emptyIfBlank(value).toLowerCase(Locale.getDefault());
    }

    /**
     * 字符串trim并转大写
     * @param value 待处理的字符串
     * @return 转大写后字符串
     */
    public static String trimAndUpperCase(String value)
    {
        return emptyIfBlank(value).toUpperCase(Locale.getDefault());
    }

    /**
     * ToString方法
     * @param object 对象
     * @return 描述信息
     */
    public static String trimAndToString(Object object)
    {
        return null == object ? EMPTY : object.toString().trim();
    }

    /**
     * 构建固定长度的字符串
     * @param input 输入字符串
     * @param length 长度
     * @param filledChar 前补充字符
     * @param fillHead 是头填充还是尾填充
     * @return 固定长度后的字符串
     */
    public static String buildFixedLength(String input, int length, char filledChar, boolean fillHead)
    {
        //获取格式化后的字符串
        String inputTrimed = emptyIfBlank(input);

        //判断字符串位数与固定长度数目关系，如果字符串位数大于要求固定长度，则直接返回
        if (inputTrimed.length() >= length)
        {
            return inputTrimed;
        }

        //获取需要拼接的字节数组信息
        int filledLength = length - inputTrimed.length();
        char[] chars = new char[filledLength];
        //使用待填充字符对填充字符数组进行填充
        for (int i = 0; i < filledLength; i++)
        {
            chars[i] = filledChar;
        }

        //根据头填充还是尾填充返回结果
        return fillHead ? new String(chars) + inputTrimed : inputTrimed + new String(chars);
    }
   
    /**
     * 构建固定长度的字符串
     * @param sequenceValue 序列值
     * @param pattern 字符串格式
     * @return 固定长度的序列字符串
     */
    public static String buildFixedLength(long sequenceValue, String pattern)
    {
        //获取格式化的格式字符串信息
        String newPattern = StringUtils.emptyIfBlank(pattern);
       
        //使用字符串格式化进行格式化
        DecimalFormat decimalFormat = new DecimalFormat(newPattern);
       
        //返回格式化字符串
        return decimalFormat.format(sequenceValue);
    }
   
    /**
     * 判断是否为中文字符
     * @param charValue 字符值
     * @return 是否为中文字符
     */
    public static boolean isChineseChar(char charValue)
    {
        //获取字符对象
        Character.UnicodeBlock unicodeBlock = Character.UnicodeBlock.of(charValue);
       
        //返回中文字符
        return unicodeBlock == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
            || unicodeBlock == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
            || unicodeBlock == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
            || unicodeBlock == Character.UnicodeBlock.GENERAL_PUNCTUATION
            || unicodeBlock == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
            || unicodeBlock == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS;
    }
   
    /**
     * 获取字符串的字节长度
     * @param value 字符串
     * @return 字符串的字节长度：一个汉字的字节长度为2
     */
    public static int getStringByteLength(String value)
    {
        //判断取值是否为空
        return null == value ? 0 : value.getBytes().length;
    }
   
    /**
     * 字符串剔除特殊字符
     * @param input 输入字符串
     * @param rejectChar 剔除字符
     * @return 剔除后的字符串
     */
    public static String rejectHeadSpecialChar(String input, char rejectChar)
    {
        //判断输入字符串是否为空，为空则直接返回空
        if (StringUtils.isBlank(input))
        {
            return StringUtils.EMPTY;
        }
       
        //获取前后trim的字符串
        String inputTrim = input.trim();
       
        //获取输入字符串长度信息
        int inputTrimLength = inputTrim.length();
       
        //初始化特殊字符串标记位
        int index = 0;
       
        //循环检查字符
        for (; index < inputTrimLength; index++)
        {
            //判断是否不等于特殊字符串，如果是则推出
            if (rejectChar != inputTrim.charAt(index))
            {
                break;
            }
        }
       
        //截取配置固定长度信息
        return inputTrim.substring(index, inputTrimLength);
    }
}