dateUtil

package com.paic.lpms.common.util;

import java.security.InvalidParameterException;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.Format;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.paic.lpms.common.web.util.WebUtils;
import com.paic.pafa.app.integration.dao.PafaDAOException;
import com.paic.pafa.app.lwc.core.util.DevLog;


/**
 * 时间格式工具类
 *
 * @author yujiaxiang001
 * @version 1.0
 * @Date 2009-10-26
 */
public class DateUtil {

    //added by mazhao814, DateFormat Constants
    public static final String PATTERN_HOUR = "HH";

    public static final String PATTERN_MIN = "mm";

    public static final String PATTERN_MMddyyyy = "MM/dd/yyyy";

    public static final String PATTERN_yyyyMMddWithSlash = "yyyy/MM/dd";

    public static final String PATTERN_MMddyyyyHHmm = "MM/dd/yyyy HH:mm";

    public static final String PATTERN_yyyyMMddHHmm = "yyyy-MM-dd HH:mm";

    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";

    public static final String PATTERN_yyyyMMdd = "yyyy-MM-dd";
    
    public static final String PATTERN_yyyyMMddWithoutBlank = "yyyyMMdd";

    public static final String PATTERN_MMddyyyyHHmmss = "MM/dd/yyyy HH:mm:ss";

    public static final String PATTERN_yyyyMMddHHmmssWithSlash = "yyyy/MM/dd HH:mm:ss";

    public static final String PATTERN_MMddyyyyHHmmSSS="yyyyMMddHHmmss.SSS";
    
    public static final String PATTERN_MMddyyyyHHmmSSSWithoutSeperator ="yyyyMMddHHmmssSSS";

    public static final String PATTERN_yyyyMMddHHmmssWithoutSeperator ="yyyyMMddHHmmss";

    public static final DateFormat FORMAT_MMddyyyy = new SimpleDateFormat(PATTERN_MMddyyyy);

    public static final DateFormat FORMAT_MMddyyyyHHmm = new SimpleDateFormat(PATTERN_MMddyyyyHHmm);

    public static final DateFormat FORMAT_MMddyyyyHHmmss = new SimpleDateFormat(PATTERN_MMddyyyyHHmmss);

    public static final DateFormat FORMAT_HOUR = new SimpleDateFormat(PATTERN_HOUR);

    public static final DateFormat FORMAT_MIN = new SimpleDateFormat(PATTERN_MIN);

    public static final DateFormat FORMAT_MMddyyyyHHmmSSS = new SimpleDateFormat(PATTERN_MMddyyyyHHmmSSS);

    public static final DateFormat FORMAT_yyyyMMddHHmmssWithoutSeperator = new SimpleDateFormat(PATTERN_yyyyMMddHHmmssWithoutSeperator);

    public static final DateFormat FORMAT_yyyyMMddWithoutBlank = new SimpleDateFormat(PATTERN_yyyyMMddWithoutBlank);

    public static final DateFormat FORMAT_yyyyMMddHHmm = new SimpleDateFormat(PATTERN_yyyyMMddHHmm);

    public static final DateFormat FORMAT_yyyyMMddHHmmss_DEFAULT = new SimpleDateFormat(DEFAULT_DATE_FORMAT);

    public static final DateFormat FORMAT_yyyyMMdd = new SimpleDateFormat(PATTERN_yyyyMMdd);

    public static final DateFormat FORMAT_yyyyMMddHHmmssWithSlash = new SimpleDateFormat(PATTERN_yyyyMMddHHmmssWithSlash);

    public static final DateFormat FORMAT_yyyyMMddWithSlash = new SimpleDateFormat(PATTERN_yyyyMMddWithSlash);

    private final static Log logger = LogFactory.getLog(DateUtil.class);
    private static Calendar calendar = Calendar.getInstance();


    public static void main(String[] args) {
        System.out.println(compare("2013-05-30", DateUtil.boundaryValue()));
    }

    public static String format(Date value) {
        return format(value, DEFAULT_DATE_FORMAT);
    }

    /**
     * 格式化日期
     *
     * @param value   value
     * @param pattern pattern
     * @return String
     */
    public static String getString(Date value, String pattern) {
        if (value == null) {
            return "";
        }
        SimpleDateFormat vFormat = new SimpleDateFormat(pattern);
        return vFormat.format(value);
    }

    /**
     * 将日期转化为字符串
     *
     * @param value  日期值
     * @param format 日期格式,缺省为"yyyy-MM-dd HH:mm:ss"
     * @return 转化后的字符串
     */
    public static String format(Date value, String format) {
        if (value == null)
            return "";

        if (format == null || format.length() == 0)
            format = DEFAULT_DATE_FORMAT;

        DateFormat df = new SimpleDateFormat(format);
        String result = df.format(value);

        if (result.length() != format.length()) {
            DevLog.debug(result + " is not equals date format " + format);
        }

        return result;
    }

    /**
     * 补全日期字符串，如"2007-12-10"+"23:59:59"变为"2007-12-10 23:59:59"
     *
     * @param value
     * @param defValue
     * @return
     */
    public static String fill(String value, String defValue) {
        if (value == null || value.length() == 0)
            return value;

        if (defValue == null || defValue.length() == 0)
            return value;

        int diff = DEFAULT_DATE_FORMAT.length() - value.length();
        if (diff <= 0) {
            return value;
        } else {
            if (defValue.length() >= diff) {
                return value + defValue.substring(defValue.length() - diff);
            } else {
                return value + defValue;
            }
        }
    }

    public static Date format(String value) {
        return format(value, DEFAULT_DATE_FORMAT);
    }

    /**
     * 解析字符串为日期对象
     *
     * @param value  日期字符串
     * @param format 日期格式,缺省为"yyyy-MM-dd HH:mm:ss"
     * @return Date 转化后的日期值
     */
    public static Date format(String value, String format) {
        if (value == null || value.length() == 0)
            return null;
        if (format == null || format.length() == 0)
            format = DEFAULT_DATE_FORMAT;

        if (format.length() > value.length()) {
            format = format.substring(0, value.length());
        }

        Date result = null;
        SimpleDateFormat df = null;
        if (format != null && format.length() > 0) {
            df = new SimpleDateFormat(format);
            try {
                result = df.parse(value);
            } catch (ParseException pe) {
                DevLog.debug(value + " parse fail with date format " + format);
                result = null;
            }
            if (result != null)
                return result;
        }

        return result;
    }

    /**
     * 解析字符串为日期对象
     *
     * @param value 日期字符串 "YYYY-MM-DD"
     * @return Date 转化后的日期值
     * @throws ParseException
     * @author EX-ZHENGLAI001
     */
    public static String formatStr(String value) throws ParseException {
        if (value == null || value.length() == 0)
            return null;
        Date date = new SimpleDateFormat("yyyy-MM-dd").parse(value);
        String dateStr = new SimpleDateFormat("MM/dd/yyyy").format(date);
        return dateStr;
    }

    /**
     * 解析字符串为日期对象
     *
     * @param value 日期字符串 "MM/DD/YYYY"
     * @return Date 转化后的日期值
     * @throws ParseException
     * @author EX-ZHENGLAI001
     */
    public static String formats(String value) throws ParseException {
        if (value == null || value.length() == 0)
            return null;
        Date date = new SimpleDateFormat("MM/dd/yyyy").parse(value);
        String dateStr = new SimpleDateFormat("yyyy-MM-dd").format(date);
        return dateStr;
    }

    /**
     * Description 解析字符串为日期对象
     *
     * @param value 日期字符串
     * @return Date 转化后的日期值
     * @Copyright Copyright (c) 2012
     * @Company
     * @author EX-ZHENGLAI001
     * @CreateTime 2012-06-23 17:00:00
     */
    public static Date formatDate(String value) {
        if (value == null || value.length() == 0) {
            DevLog.debug(value + " parse fail with date value is null ");
            return null;
        }
        Date result = null;
        try {
            result = new Date(Timestamp.parse(value));
        } catch (Exception e) {
            DevLog.debug(value + " parse fail with date format ");
            logger.fatal(value + " parse fail with date format ", e);
        }
        return result;
    }

    /**
     * 给日期增加指定天数
     *
     * @param startDate 开始日期
     * @param day       增加天数
     * @return 增加天数后的日期
     */
    public static Date addDate(Date startDate, int day) {
        if (startDate == null)
            return null;
        calendar.setTime(startDate);
        calendar.add(Calendar.DATE, day);
        return calendar.getTime();

    }

    /**
     * 给时间增加指定小时
     *
     * @param startDate
     * @param hour
     * @return
     */
    public static Date addHour(Date startDate, int hour) {
        if (startDate == null)
            return null;
        calendar.setTime(startDate);
        calendar.add(Calendar.HOUR, hour);
        return calendar.getTime();
    }

    /**
     * 给时间增加指定分钟
     *
     * @param startDate
     * @param min
     * @return
     */
    public static Date addMin(Date startDate, int min) {
        if (startDate == null)
            return null;
        calendar.setTime(startDate);
        calendar.add(Calendar.MINUTE, min);
        return calendar.getTime();
    }

    /**
     * 获得当前日期的字符串，格式默认 YYYY-MM-DD
     *
     * @param datePattern
     * @return 根据输入格式要求的时间日期
     * @author ex_jinjie 2009/1/12
     */
    public static String getDateForFormat(String datePattern) {
        if (StringUtil.isNullOrBlank(datePattern)) {
            datePattern = "yyyy-MM-dd";
        }
        return new SimpleDateFormat(datePattern).format(Calendar.getInstance().getTime());
    }

    /**
     * Description:计算两个日期间的天数
     *
     * @param fromDate 起始日期
     * @param toDate   结束日期
     * @return Create Time:20081107
     * @throws ParseException
     * @author MIAOJIYONG001
     */
    public static long dateDiff(String fromDate, String toDate) throws ParseException {
        long days = 0;
        SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
        Date from = df.parse(fromDate);
        Date to = df.parse(toDate);
        days = (long) ((to.getTime() - from.getTime()) / (24 * 60 * 60 * 1000));
        return days;
    }

    public static long dateDiff(Date fromDate, Date toDate)
            throws ParseException {
        long days = 0;
        days = (long) ((toDate.getTime() - fromDate.getTime()) / (24 * 60 * 60 * 1000));
        return days;
    }

    /**
     * Description:计算两个日期间的天数 yyyy-MM-dd HH:mm:ss
     *
     * @param fromDate 起始日期
     * @param toDate   结束日期
     * @return Create Time:20081107
     * @throws ParseException
     * @author MIAOJIYONG001
     */
    public static long dateDiffAddHMS(String fromDate, String toDate) throws ParseException {
        long days = 0;
        Date from = FORMAT_yyyyMMddHHmmss_DEFAULT.parse(fromDate);
        Date to = FORMAT_yyyyMMddHHmmss_DEFAULT.parse(toDate);
        long tt = to.getTime() - from.getTime();
        int num = 24 * 60 * 60 * 1000;
        days = tt / num;
        if (tt % num > 0) {
            days++;
        }
        return days;
    }

    /**
     * 判断二个日期是否在间隔之内，如果在间隔之内，则返回真，否则则返回false 间隔时间以小时计;
     *
     * @param Date1
     * @param Date2
     * @param hours
     * @return
     */
    public static boolean judgeDate(Date Date1, Date Date2, int hours) {
        boolean res = false;
        if (Date1 == null || Date2 == null) {
            return res;
        }
        hours = hours * 60 * 60 * 1000;
        calendar.setTime(Date1);
        long date1InMill = calendar.getTimeInMillis();
        logger.debug("date1InMill:" + date1InMill);
        calendar.setTime(Date2);
        long date1InMil2 = calendar.getTimeInMillis();
        logger.debug("date1InMil2 - date1InMill:" + (date1InMil2 - date1InMill));
        if ((date1InMil2 - date1InMill) <= hours) {
            res = true;
        }

        return res;

    }

    /**
     * 判断二个日期是否在间隔之内，如果在间隔之内，则返回真，否则则返回false 间隔时间以小时计;
     *
     * @param Date1
     * @param Date2
     * @param hours
     * @return
     */
    public static boolean judgeDate(Date Date1, Date Date2, long hours) {
        boolean res = false;
        if (Date1 == null || Date2 == null) {
            return res;
        }
        hours = hours * 60 * 60 * 1000;
        calendar.setTime(Date1);
        long date1InMill = calendar.getTimeInMillis();
        logger.debug("date1InMill:" + date1InMill);
        calendar.setTime(Date2);
        long date1InMil2 = calendar.getTimeInMillis();
        logger.debug("date1InMil2 - date1InMill:" + (date1InMil2 - date1InMill));
        if ((date1InMil2 - date1InMill) <= hours) {
            res = true;
        }

        return res;

    }

    /**
     * 比较第一个时间是否比第二个时间新
     *
     * @param firstDate
     * @param secondDate
     * @param format     日期格式,缺省为"yyyy-MM-dd HH:mm:ss"
     * @return
     */
    public static boolean handlePairOfTime(Date firstDate, Date secondDate, String format) {
        if (format == null || format.length() == 0)
            format = DEFAULT_DATE_FORMAT;
        Format formatter = new SimpleDateFormat(format);
        String fDate = formatter.format(firstDate);
        String sDate = formatter.format(secondDate);
        Date newDate1 = null, newDate2 = null;
        try {
            newDate1 = (Date) formatter.parseObject(fDate);
            newDate2 = (Date) formatter.parseObject(sDate);
            if (newDate1.compareTo(newDate2) > 0) {
                return true;
            } else {
                return false;
            }
        } catch (ParseException fe) {
            DevLog.debug(fDate + " or " + sDate + " parse fail with date format.");
            return false;
        }
    }

    public static boolean handlePairOfDate(Date firstDate, Date secondDate) {
        Format formatter = new SimpleDateFormat("yyyy-MM-dd");
        String fDate = formatter.format(firstDate);
        String sDate = formatter.format(secondDate);
        Date newDate1 = null, newDate2 = null;
        try {
            newDate1 = (Date) formatter.parseObject(fDate);
            newDate2 = (Date) formatter.parseObject(sDate);
            if (newDate1.compareTo(newDate2) > 0) {
                return true;
            } else {
                return false;
            }
        } catch (ParseException fe) {
            DevLog.debug(fDate + " or " + sDate + " parse fail with date format.");
            return false;
        }
    }
    
    public static boolean handlePairOfDateToInsurance(Date firstDate, Date secondDate) {
        Format formatter = new SimpleDateFormat("yyyy-MM-dd");
        String fDate = formatter.format(firstDate);
        String sDate = formatter.format(secondDate);
        Date newDate1 = null, newDate2 = null;
        try {
            newDate1 = (Date) formatter.parseObject(fDate);
            newDate2 = (Date) formatter.parseObject(sDate);
            if (newDate1.compareTo(newDate2) >= 0) {
                return true;
            } else {
                return false;
            }
        } catch (ParseException fe) {
            DevLog.debug(fDate + " or " + sDate + " parse fail with date format.");
            return false;
        }
    }

    /**
     * 按指定的格式返回当前日期串
     *
     * @param pattern
     * @return
     */
    public static String getCustomDateStrs(String pattern) {
        Date calc = new Date();
        Format macher = new SimpleDateFormat(pattern);
        return macher.format(calc);
    }

    /**
     * 按指定的格式返日期串
     *
     * @param date
     * @param pattern
     * @return
     */
    public static String getCustomDateStrs(Date date, String pattern) {
        Format macher = new SimpleDateFormat(pattern);
        return macher.format(date);
    }

    /**
     * @param args
     */
/*    public static void main(String[] args) {
        Date time = format("2005-12-01  16:59:59", null);
        String str = format(time, null);
        DevLog.debug(str);
    }*/

    /**
     * 获取今天是星期几
     *
     * @return
     */
    public static int getWeekday() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        return calendar.get(Calendar.DAY_OF_WEEK);
    }

    public static int getWeekday(String date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(format(date));
        return calendar.get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 根据年月日得到一个合法日期，不合法逐年递增直至找到
     *
     * @param yearStr
     * @param monthStr
     * @param dayStr
     * @return
     */
    public static Date getValidBeginDateForYearCycle(String yearStr, String monthStr, String dayStr) {
        int day = Integer.parseInt(dayStr);
        Date today = getToday();
        Calendar calendar = Calendar.getInstance();
        Date validBeginDate = getEndDate(yearStr, monthStr, dayStr);
        calendar.setTime(validBeginDate);
        while (validBeginDate.before(today)) {
            validBeginDate = getEndDate(calendar.get(Calendar.YEAR) + 1, calendar
                    .get(Calendar.MONTH) + 1, day);
            calendar.setTime(validBeginDate);
        }
        while (calendar.get(Calendar.DATE) != day) {
            validBeginDate = getEndDate(calendar.get(Calendar.YEAR) + 1, calendar
                    .get(Calendar.MONTH) + 1, day);
            calendar.setTime(validBeginDate);
        }
        return validBeginDate;
    }

    /**
     * 根据年月日得到合法日期，如果该月无此日期，则取该月最后一天
     *
     * @param year
     * @param month
     * @param day
     * @return
     */
    public static Date getEndDate(int year, int month, int day) {
        return getEndDate(String.valueOf(year), String.valueOf(month), String.valueOf(day));
    }

    public static Date getEndDate(String yearStr, String monthStr, String dayStr) {
        int day = Integer.parseInt(dayStr);
        if (day < 0 || day > 31) {
            throw new InvalidParameterException("参数错误,设置提醒失败！");
        }
        Calendar calendar = Calendar.getInstance();
        Date beginDate = DateUtil.format(yearStr + "-" + monthStr + "-01");
        calendar.setTime(beginDate);
        int maxday = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        calendar.set(Calendar.DATE, maxday);
        if (calendar.get(Calendar.DATE) > day) {
            calendar.set(Calendar.DATE, day);
        }
        return calendar.getTime();
    }

    public static Date getToday() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 根据年月日得到一个合法日期，不合法逐月递增直至找到
     *
     * @param yearStr
     * @param monthStr
     * @param dayStr
     * @return
     */
    public static Date getValidBeginDateForMonthCycle(String yearStr, String monthStr, String dayStr) {
        int day = Integer.parseInt(dayStr);
        Date today = getToday();
        Calendar calendar = Calendar.getInstance();
        Date validBeginDate = getEndDate(yearStr, monthStr, dayStr);
        calendar.setTime(validBeginDate);
        while (validBeginDate.before(today)) {
            validBeginDate = getEndDate(calendar.get(Calendar.YEAR),
                    calendar.get(Calendar.MONTH) + 2, day);
            calendar.setTime(validBeginDate);
        }
        while (calendar.get(Calendar.DATE) != day) {
            validBeginDate = getEndDate(calendar.get(Calendar.YEAR),
                    calendar.get(Calendar.MONTH) + 2, day);
            calendar.setTime(validBeginDate);
        }
        return validBeginDate;
    }

    /**
     * 校验日期字符串是否合法
     *
     * @param date 日期字符串
     * @author EX-LIYONGSHENG001
     */
    public static boolean validateDate(String date) {
        int strYMDSP = 0;
        // 判断YYYYMMDD中的分隔符号 不是-报错
        if (!date.substring(4, 5).equals("-")) {
            return false;
        }
        String year = date.substring(0, 4);
        // 截去年份
        date = date.substring(5, date.length());
        // 获取月和日的分界
        for (int i = 0; i < date.length(); i++) {
            if (date.substring(i, i + 1).equals("-")) {
                strYMDSP = i;
                break;
            }
        }
        // 月日没有-分割报错
        if (strYMDSP < 1) {
            return false;
        }
        // 获取月
        String month = date.substring(0, strYMDSP);
        String day = date.substring(strYMDSP + 1, date.length());
        // 补零
        if (month.length() == 1) {
            month = "0" + month;
        }
        if (day.length() == 1) {
            day = "0" + day;
        }
        // 调用CheckyyyyMMdd函数判断yyyyMMdd格式的日期
        if (!checkyyyyMMdd(year + month + day)) {
            return false;
        }
        return true;
    }

    /**
     * 将不符合要求的字符串转换成前面补零的字符串
     *
     * @param date 源字符串
     * @author EX-LIYONGSHENG001
     */
    public static String leftPadDate(String date) {
        if (date.length() == 1) {
            return "0" + date;
        } else {
            return date;
        }
    }

    /**
     * 校验年月日是否合法
     */
    private static boolean checkyyyyMMdd(String dayString) {
        String digit = "0123456789";
        int[] dateLastList = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        // 不是8位
        if (dayString.length() != 8) {
            return false;
        }
        // 日期不是数字
        for (int i = 0; i < 8; i++) {
            if (digit.indexOf(dayString.charAt(i)) == -1) {
                return false;
            }
        }
        // 获取年月日
        int year = Integer.parseInt(dayString.substring(0, 4));
        int month = Integer.parseInt(dayString.substring(4, 6));
        int day = Integer.parseInt(dayString.substring(6, 8));
        // 年月日出界
        if (year > 2200 || year < 1900 || month > 12 || month < 1 || day > 31 || day < 1) {
            return false;
        }
        // 每月最后一天出界
        if (day > dateLastList[month - 1]) {
            return false;
        }
        // 判断闰年、平年的二月天数
        if (month == 2) {
            // 整百(如:1600, 2000)的闰年
            if ((year % 400) == 0) {
                if (day > 29) {
                    return false;
                }
            } else if ((year % 4) == 0 && (year % 100) != 0) {
                // 普通（1996， 2004）的闰年
                if (day > 29) {
                    return false;
                }
            } else {
                // 平年（如：1995,1997,2003,2005）
                if (day > 28) {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * 得到当天时间最大时刻，并将其转化为字符串
     */
    public static String getMaxTodayTimeString() {
        Date date = new Date();
        TimeZone timeZoneChina = TimeZone.getTimeZone("Asia/Shanghai");
        FORMAT_yyyyMMddHHmmss_DEFAULT.setTimeZone(timeZoneChina);
        String result = FORMAT_yyyyMMddHHmmss_DEFAULT.format(date);
        if (null != result && result.length() > 0) {
            result = result.substring(0, 11);
        }
        result += "23:59:59";
        return result;
    }

    /**
     * 该方法用于获取系统时间-364的临界值
     */
    public static String getStartTime() {
        // String startTime="2010-08-21";
        String before = ""; // startTime-365
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date time = new Date();
        format.format(time);
        before = format.format(DateUtil.addDate(time, -364));
        return before;
    }

    /**
     * 该方法用于获取系统时间-365的临界值
     */
    public static String boundaryValue() {
        // String startTime="2010-08-21";
        String before = ""; // startTime-365
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date time = new Date();
        format.format(time);
        before = format.format(DateUtil.addDate(time, -365));
        // System.out.println("系统-365时间："+before);
        return before;
    }

    /**
     * 给日期增加指定月数
     *
     * @param startDate 开始日期
     * @param month     增加月数
     * @return 增加月数后的日期
     */
    public static Date addMonth(Date startDate, int month) {
        if (startDate == null)
            return null;
        calendar.setTime(startDate);
        calendar.add(Calendar.MONTH, month);
        return calendar.getTime();

    }

    /**
     * 给日期增加指定天数
     *
     * @param day 增加天数
     * @return 增加天数后的日期的字符串表示形式
     */
    public static String boundaryValue(int day) {
        // String startTime="2010-08-21";
        String before = ""; // startTime-365
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date time = new Date();
        format.format(time);
        before = format.format(DateUtil.addDate(time, day));
        // System.out.println("系统-365时间："+before);
        return before;
    }

    public static String boundaryValue(String nowDay, int day) {
        // String startTime="2010-08-21";
        String before = ""; // startTime-365
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date time = format(nowDay);
        format.format(time);
        before = format.format(DateUtil.addDate(time, day));
        // System.out.println("系统-365时间："+before);
        return before;
    }

    /**
     * 给日期增加指定天数
     *
     * @param startTime 开始日期
     * @param day       增加天数
     * @return 增加天数后的日期的字符串表示形式
     */
    public static String boundaryValue(Date startTime, int day) {
        // String startTime="2010-08-21";
        String before = ""; // startTime-365
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        // Date time = new Date();
        format.format(startTime);
        before = format.format(DateUtil.addDate(startTime, day));
        // System.out.println("系统-365时间："+before);
        return before;
    }

    /**
     * 计算两个日期直接相差的天数
     *
     * @param endDate
     * @param startDate
     * @return
     */
    public static long getQuot(Date endDate, Date startDate) {
        long quot = 0;
        quot = endDate.getTime() - startDate.getTime();
        quot = quot / 1000 / 60 / 60 / 24;
        return quot;
    }

    /**
     * 计算两个日期直接相差的分钟数
     *
     * @param endDate
     * @param startDate
     * @return
     */
    public static long getQuotMin(Date endDate, Date startDate) {
        long quot = 0;
        quot = endDate.getTime() - startDate.getTime();
        quot = quot / 1000 / 60;
        return quot;
    }

    /**
     * 用于比较两个时间的前后
     *
     * @param time1 输入的开始时间，time2当前时间-365
     * @return String 1: time1大于time2  2:表示 time2大于 time1
     * @throws PafaDAOException
     * @throws ParseException
     * @throws ParseException
     */
    public static String compare(String time1, String time2) {
        DateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd");
        Date startTimes;
        String flag = "1";
        try {
            if (StrUtil.isEmpty(time1)) {
                flag = "2";
                return flag;
            }
            startTimes = dateformat.parse(time1);
            Date befores = dateformat.parse(time2);
            if (befores.getTime() < startTimes.getTime()) {
                flag = "1";
            } else {
                flag = "2";
            }
        } catch (ParseException e) {
            logger.fatal("", e);
        }
        return flag;
    }

    public static String compareFull(String time1, String time2) {
        Date startTimes;
        String flag = "1";
        try {
            if (StrUtil.isEmpty(time1)) {
                flag = "2";
                return flag;
            }
            startTimes = FORMAT_yyyyMMddHHmmss_DEFAULT.parse(time1);
            Date befores = FORMAT_yyyyMMddHHmmss_DEFAULT.parse(time2);
            if (befores.getTime() < startTimes.getTime()) {
                flag = "1";
            } else {
                flag = "2";
            }
        } catch (ParseException e) {
            logger.fatal("", e);
        }
        return flag;
    }

    /**
     * 万里通红包抽奖开始时间
     */
    private static Date _awardStartDate_test = null;//DateUtil.getEndDate(2013, 7, 18);


    /**
     * 万里通红包抽奖开始时间(第二波活动)
     */
    private static Date _awardStartDate_Second = null;//DateUtil.getEndDate(2013, 7, 18);
    /**
     * 抢红包活动 开始时间配置
     */
    private static Date _awardStartDate_redPacket = null;//DateUtil.getEndDate(2013, 7, 18);

    /**
     * 购爱星期三活动 开始时间配置
     */
    private static Date _shopLoveWedStartDate_Love = null;

    /**
     * 购爱星期三活动 结束时间配置
     */
    private static Date _shopLoveWedEndDate_Love = null;
    /**
     * 第二波活动默认开始时间为8月1日
     */
    private final static Date _awardStartDateSecond_default = DateUtil.getEndDate(2013, 8, 1);
    private static long time1 = 0l;
    private final static Date _awardStartDate = DateUtil.getEndDate(2013, 7, 18);
    /**
     * 抢红包第二波活动开始时间设置
     */
    private final static Date _redPacketAwardStartDate = DateUtil.getEndDate(2013, 8, 27);

    /**
     * 抢红包第二波活动结束时间设置
     */
    private final static Date _redPacketAwardEndDate = DateUtil.getEndDate(2013, 10, 5);

    /**
     * 购爱星期三活动开始时间设置
     */
    private final static Date _shopLoveWedStartDate = DateUtil.getEndDate(2013, 8, 3);

    /**
     * 购爱星期三活动结束时间设置
     */
    private final static Date _shopLoveWedEndDate = DateUtil.getEndDate(2013, 10, 10);

    /*第一波活动 开始时间配置*/
    public static Date getAwardStartDate() {
        /**10分钟更新一次配置*/
        if (_awardStartDate_test == null || ((System.currentTimeMillis() - time1) > 1000 * 60 * 10)) {
            String statdate = WebUtils.getListOfValue("RP", "startDate");
            if (!StrUtil.isEmpty(statdate)) {
                _awardStartDate_test = DateUtil.format(statdate);
            }
            time1 = System.currentTimeMillis();
        }
        if (_awardStartDate_test == null) {
            return _awardStartDate;
        } else {
            return _awardStartDate_test;
        }
    }

    /*第二波活动开始时间配置*/
    public static Date getAwardStartDateNew() {
        /**10分钟更新一次配置*/
        if (_awardStartDate_Second == null || ((System.currentTimeMillis() - time1) > 1000 * 60 * 10)) {
            String statdate = WebUtils.getListOfValue("RP", "startDateNew");
            if (!StrUtil.isEmpty(statdate)) {
                _awardStartDate_Second = DateUtil.format(statdate);
            }
            time1 = System.currentTimeMillis();
        }
        if (_awardStartDate_Second == null) {
            return _awardStartDateSecond_default;
        } else {
            return _awardStartDate_Second;
        }
    }

    /*抢红包活动 开始时间配置*/
    public static Date getRedPacketAwardStartDate() {
        /**10分钟更新一次配置*/
        if (_awardStartDate_redPacket == null || ((System.currentTimeMillis() - time1) > 1000 * 60 * 10)) {
            String statdate = WebUtils.getListOfValue("RP", "startRedPacketDate");
            if (!StrUtil.isEmpty(statdate)) {
                _awardStartDate_redPacket = DateUtil.format(statdate);
            }
            time1 = System.currentTimeMillis();
        }
        if (_awardStartDate_redPacket == null) {
            return _redPacketAwardStartDate;
        } else {
            return _awardStartDate_redPacket;
        }
    }

    /*抢红包活动 结束时间配置*/
    public static Date getRedPacketAwardEndDate() {
        /**10分钟更新一次配置*/
        if (_awardStartDate_redPacket == null || ((System.currentTimeMillis() - time1) > 1000 * 60 * 10)) {
            String statdate = WebUtils.getListOfValue("RP", "endRedPacketDate");
            if (!StrUtil.isEmpty(statdate)) {
                _awardStartDate_redPacket = DateUtil.format(statdate);
            }
            time1 = System.currentTimeMillis();
        }
        if (_awardStartDate_redPacket == null) {
            return _redPacketAwardEndDate;
        } else {
            return _awardStartDate_redPacket;
        }
    }

    /*购爱星期三活动 开始时间配置*/
    public static Date getShopLoveWedStartDate() {
        /**10分钟更新一次配置*/
        if (_shopLoveWedStartDate_Love == null || ((System.currentTimeMillis() - time1) > 1000 * 60 * 10)) {
            String statdate = WebUtils.getListOfValue("RP", "startShopLoveWedDate");
            if (!StrUtil.isEmpty(statdate)) {
                _shopLoveWedStartDate_Love = DateUtil.format(statdate);
            }
            time1 = System.currentTimeMillis();
        }
        if (_shopLoveWedStartDate_Love == null) {
            return _shopLoveWedStartDate;
        } else {
            return _shopLoveWedStartDate_Love;
        }
    }

    /*购爱星期三活动 结束时间配置*/
    public static Date getShopLoveWedEndDate() {
        /**10分钟更新一次配置*/
        if (_shopLoveWedEndDate_Love == null || ((System.currentTimeMillis() - time1) > 1000 * 60 * 10)) {
            String statdate = WebUtils.getListOfValue("RP", "endShopLoveWedDate");
            if (!StrUtil.isEmpty(statdate)) {
                _shopLoveWedEndDate_Love = DateUtil.format(statdate);
            }
            time1 = System.currentTimeMillis();
        }
        if (_shopLoveWedEndDate_Love == null) {
            return _shopLoveWedEndDate;
        } else {
            return _shopLoveWedEndDate_Love;
        }
    }

    /**
     * 获得当前日期的字符串，格式参数 YYYY年MM月DD日
     *
     * @return
     */
    public static String getDate(String datePattern) {
        return new SimpleDateFormat(datePattern).format(Calendar.getInstance().getTime());
    }

    /**
     * 获得当前日期的字符串，格式示例 YYYYMMDD
     *
     * @return
     */
    public static String getDate() {
        String datePattern = "yyyyMMdd";
        return new SimpleDateFormat(datePattern).format(Calendar.getInstance().getTime());
    }

    /**
     * 获取当前操作系统的时间
     *
     * @return 当前操作系统的时间
     */
    public static String getTime() {
        String timePattern = "HHmmss";
        return new SimpleDateFormat(timePattern).format(Calendar.getInstance().getTime());
    }
    
    /**
     * 将字符串解析为时间格式
     * @param date
     * @param df
     * @return
     * @throws ParseException
     */
    public static Date parse(String date, DateFormat df) throws ParseException {
        return df.parse(date);
    }
    
    /**
     * 将字符串解析为时间格式
     * @param date, 格式为'yyyy-MM-dd HH:mm:ss'
     * @return
     * @throws ParseException
     */
    public static Date parse(String date) throws ParseException {
        return FORMAT_yyyyMMddHHmmss_DEFAULT.parse(date);
    }
    /**
     * 获取每周1-7日期（周一为每周第一天日期格式为：yyyy-MM-dd）
     * @param value 周一至周日值为1-7
     * @return
     */
    public static String getDayOfWeek(int value){
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        switch (value) {
        case 1:
            calendar.set(calendar.DAY_OF_WEEK, Calendar.MONDAY);
            break;
        case 2:
            calendar.set(calendar.DAY_OF_WEEK, Calendar.TUESDAY);
            break;
        case 3:
            calendar.set(calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
            break;
        case 4:
            calendar.set(calendar.DAY_OF_WEEK, Calendar.THURSDAY);
            break;
        case 5:
            calendar.set(calendar.DAY_OF_WEEK, Calendar.FRIDAY);
            break;
        case 6:
            calendar.set(calendar.DAY_OF_WEEK, Calendar.SATURDAY);
            break;
        default:
            calendar.set(calendar.DAY_OF_WEEK, Calendar.SUNDAY);
            break;
        }
        return FORMAT_yyyyMMdd.format(calendar.getTime());
    }
    /**
     * 获取该月第一天日期（格式：yyyy-MM-dd）
     * @return
     */
    public static String getFirstayOfMonth(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-01");
        return sdf.format(new Date());
    }

    /**
     * 得到N天后的日期
     * @param num
     * @return
     */
    public static String getDate(int num) {
        long time = System.currentTimeMillis() + (1000L * 60 * 60 * 24 * num);
        String pattern = "yyyy-MM-dd";
        Date date = new Date();
        if (time > 0) {
            date.setTime(time);
        }
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        return format.format(date);
    }
    
}