凯睿看世界
凯睿看世界

日期工具类DateUtils

常用方法

获取当前日期时间

getYear :获取任意时间的年
getMonth :获取任意时间的月
getDay :获取任意时间的天
getHour :获取任意时间的小时,12 小时制
getHour2 :获取任意时间的小时,24 小时制
getMinute :获取任意时间的分钟
getSecond :获取任意时间的秒
getBeforeDate :获取前一天日期
getTomorrowDate ;获取明天的日期

getNowString : 获取当前日期 String 类型,默认返回格式2019-05-17 18:48:24,可自定义返回样式
getNowDate :获取当前日期 Date 类型
getNowMills :获取当前时间的时间戳(毫秒)
getNowY :获取当前年
getNowMonth :获取当前月
getNowDay :获取当前日
getNowWeek :获取当前日期是该周的第几天,周日是第一天返回 1,周六最后一天返回 7
getNowHour :获取当前日期的小时
getNowMinute :获取当前日期的分
getNowSecond :获取当前日期的秒
getDaysOfMonth :根据传入的年份和月份，判断当前月有多少天
getLastDaysOfMonth 根据传入的年份和月份，获取上一个月有多少天

判断相关

isLeapYear :是否是闰年
isTomorrow :是否是明天
isSameDay :判断两个时间是否是同一天
isSameWeekDates :判断两个时间是否在同一周
isSameDay :检查两个Calendar对象是否是同一天
checkIsActiveDate :判断是否是有效日期
dateCompare :比较两个日期大小
checkDateCompare :判断前后日期对比
checkDateFromTo :日期比较， 后面日期比前面的日期大

格式转换相关

string2Millis:

  1. 完整的时间使用 string2Millis("2019-05-17 18:34:16") 结果--->1558089256000
  2. 不完整时间使用 string2Millis("2019-05-17",PATTEN_YMD) 结果--->1558022400000(相当于2019-05-17 00:00:00)
    string2Millis :String 转时间戳(13 位,毫秒)
    millis2String :时间戳转 String 类型

string2Date :String 类型转 Date
date2String :Date 类型转 String
millis2Date :毫秒时间戳转 Date
date2Millis :Date 转时间戳

calendar2Date :将Calendar对象转换为Date对象
date2Calendar :将Date对象转换为Calendar对象

其他

getTimeSpan :获取两个时间的时间差( 例如比较相差多少秒: getTimeSpan("2019-05-17 18:34:16","2019-05-17 18:35:16",SEC) 结果--> -60)
getFitTimeSpan :获取两个时间的时间差,可返回相差天数,小时,分钟等
getTimeSpanByNow :获取时间和当前日期的差值
getFriendlyTimeSpanByNow :获取时间与当前时间的时间差
getChineseWeek :获取汉语星期几
getUSWeek :获取英文的星期
getChineseZodiac :获取生肖
getZodiac :获取星座
getWeekFormDate :获得一个日期所在的周的星期几的日期，如要找出2002年2月3日所在周的星期一是几号

getEDate :返回美国时间格式 26 Apr 2006
getEndDateOfMonth :获取一个月的最后一天
getNextDay :得到一个时间延后或前移几天的时间
getPreTime :时间前推或后推分钟
getUserDate :返回想要的时间样式
getCalendar :获取 Calendar
computerDuration :计算时长
between :判断srcDate时间是否在startDate和endDate之间

addYears :在date时间基础上增加amount年,原date不变,获取后几年或前几年日期
addMonth :日期加月
addDay :日期加日,得到新日期
addHour :日期加小时
addMinute :日期加分钟
addSecond :日期加秒

setYears :对date对象的年份字段设置value值，返回一个新的date对象，原date不变
setMonths :对date对象的月字段设置value值，返回一个新的date对象，原date不变
setDay :对date对象的天字段设置value值，返回一个新的date对象，原date不变
setHours :对date对象的小时字段设置value值，返回一个新的date对象，原date不变
setMinute :对date对象的分钟字段设置value值，返回一个新的date对象，原date不变
setSecond ;对date对象的秒字段设置value值，返回一个新的date对象，原date不变

thirtyDaysBeforeSpecifiedDate :获取指定日期的前30天的日期
thirtyDaysBeforeNow :获取当前日期前30天的日期
getBeforeMonth :获取当前时间的上一个月的年月
getLastDayOfMonth :返回某月的最后一天
getFirstDayOfMonth ;返回某月的第一天
getThisMonthLastDay :获取本月最后一天
getThisMonthFirstDay ;获取本月第一天
getNextWeekMonday :获取下周一日期
secondToTime :时间戳秒,返回日时分秒

dayDiff :计算两个日期之间间隔天数
daysBetween :计算两个日期之间间隔天数
getThisWeekMonday0 :本周一凌晨
getThisWeekMonday :本周一
geLastWeekMonday :上周一
getFirstTime :获取当天的最早时间00:00:00
getLatestTime :获取当天的最晚时间23:59:59
getTomorrowEnding :获得明日23点59分59秒的时间戳
getTomorrowMorning :获得明日0点0分0秒的时间戳


/**
 * @author kiwilss
 */
public class DateUtils {

    //毫秒
    public static final int MSEC = 1;
    //秒
    public static final int SEC = 1000;
    //分
    public static final int MIN = 60000;
    //时
    public static final int HOUR = 3600000;
    //天
    public static final int DAY = 86400000;
    /**
     * 默认格式
     */
    private static final DateFormat DEFAULT_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     * 日期时间 格式yyyy-MM-dd HH:mm:ss
     */
    public static String PATTEN_YMDSFM = "yyyy-MM-dd HH:mm:ss";

    public static String PATTEN_YMDSF = "yyyy-MM-dd HH:mm";
    public static String PATTEN_YMDS = "yyyy-MM-dd HH";
    /**
     * 日期格式yyyy-MM-dd
     */
    public static String PATTEN_YMD = "yyyy-MM-dd";
    /**
     * 日期格式yyyy年MM月dd日
     */
    public static String PATTEN_YMD_CN = "yyyy年MM月dd日";

    /**
     * 日期格式 时分秒
     */
    public static final String PATTEN_HFM = "HH:mm:ss";
    /**
     * 日期格式 时
     */
    public static final String PATTEN_H = "HH";
    /**
     * 日期格式 分
     */
    public static final String PATTEN_M = "mm";

    private static final String[] CHINESE_ZODIAC =
            {"猴", "鸡", "狗", "猪", "鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊"};
    private static final String[] ZODIAC = {
            "水瓶座", "双鱼座", "白羊座", "金牛座", "双子座", "巨蟹座",
            "狮子座", "处女座", "天秤座", "天蝎座", "射手座", "魔羯座"
    };
    private static final int[] ZODIAC_FLAGS = {20, 19, 21, 21, 21, 22, 23, 23, 23, 24, 23, 22};

    /**
     * 默认的日期间隔符
     */
    public static String       DEFAULT_SEPERATOR     = "-";
    /**
     * 日期验证复杂正则
     */
    public static String       DATE_REG              = "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})(((0[13578]|1[02])(0[1-9]|[12][0-9]|3[01]))|((0[469]|11)(0[1-9]|[12][0-9]|30))|(02(0[1-9]|[1][0-9]|2[0-9])))";

    /**
     * 日期验证简单正则
     */
    private static String      DATE_REG_SIMPLE       = "^\\d{4}-\\d{2}-\\d{2}$";
    /**
     * 大于等于
     */
    public static final String COMPARE_TYPE_GTE      = "GTE";
    /**
     * 大于
     */
    public static final String COMPARE_TYPE_GT       = "GT";


    public static void main(String[] args) {
        System.out.println(secondToTime(120));

        System.out.println(date2String(setMonths(getNowDate(),5)));
        System.out.println(addMonth("2019-05-22",PATTEN_YMD,5));

        System.out.println(getBeforeDate(PATTEN_YMD));
        System.out.println(getTomorrowDate(PATTEN_YMD));

        System.out.println(addYears(getNowDate(),3));

        System.out.println(isTomorrow("2019-05-22 23:34:16"));
        System.out.println(isTomorrow("2019-05-23 23:34:16"));

        System.out.println(isSameDay("2019-05-22 23:34:16","2019-05-22 11:34:16"));
        System.out.println(isSameDay("2019-05-22","2019-06-22",PATTEN_YMD));
        System.out.println(isSameDay(1558022400000L,1558101600000L));

        System.out.println(millis2String(1558022400000L));
        System.out.println(millis2String(1558022400000L,PATTEN_YMD));

        System.out.println(string2Millis("2019-05-22 23:34:16"));
        System.out.println(string2Millis("2019-05-22",PATTEN_YMD));

        System.out.println("------------------------------------");
        System.out.println(getYear("2019-05-22 23:34:16"));
        System.out.println(getYear("2019-05-22",PATTEN_YMD));

        System.out.println(getMonth("2019-05-22 23:34:16"));
        System.out.println(getMonth("2019-05-22", PATTEN_YMD));

        System.out.println(getDay("2019-05-22 23:34:16"));
        System.out.println(getHour("2019-05-22 23:34:16"));
        System.out.println(getMinute("2019-05-22 23:34:16"));
        System.out.println(getSecond("2019-05-22 23:34:16"));

        System.out.println("------------------------------------");
        System.out.println(between("2019-05-22 23:34:16","2019-05-21 23:34:16","2019-05-24 23:34:16"));
        System.out.println(between("2019-05-22","2019-05-21","2019-05-24",PATTEN_YMD));

        System.out.println(computerDuration(120000));

        System.out.println(getUserDate(PATTEN_YMD));
        System.out.println(getUserDate(PATTEN_YMDSFM));
        System.out.println(getUserDate(PATTEN_YMDSF));
        System.out.println(getUserDate(PATTEN_H));


        System.out.println(getPreTime("2019-05-22 23:34:16", "20"));

        System.out.println(getNextDay("2019-05-22 23:34:16", "2"));
        System.out.println(getNextDay("2019-05-22 23:34:16", "12"));

        System.out.println(getEndDateOfMonth("2019-05-22 23:34:16"));
        System.out.println(getEndDateOfMonth("2019-05-22"));
        System.out.println(getEDate("2019-05-22"));

        System.out.println(isSameWeekDates("2019-05-22 23:34:16", "2019-05-23 23:34:16"));
        System.out.println(isSameWeekDates("2019-05-22 23:34:16", "2019-05-28 23:34:16"));
        System.out.println(isSameWeekDates("2019-05-22", PATTEN_YMD, "2019-05-28", PATTEN_YMD));

        System.out.println(getSeqWeek("2019-01-10 23:34:16"));

        System.out.println(getWeekFormDate("2019-05-17 23:34:16", 2));
        System.out.println(getWeekFormDate("2019-05-17", PATTEN_YMD, 2));
        System.out.println(getWeekFormDate("2019-05-17", PATTEN_YMD, 2, PATTEN_YMD));

        System.out.println(getUSWeek(getNowDate()));
        //获取星期几
        System.out.println(getChineseWeek(getNowDate()));
        //获取星期几,没有时分秒,时间和后面的格式要对应
        System.out.println(getChineseWeek("2019-05-17", PATTEN_YMD));
        //与当前时间的时间差
        System.out.println(getTimeSpanByNow("2019-05-18 23:34:16", HOUR));//---->24
        System.out.println(getTimeSpanByNow("2019-05-18 23:34:16", DAY));//---->1(超过 24 小时算 1 天)
        System.out.println(getTimeSpanByNow("2019-05-18", PATTEN_YMD, DAY));//----->1

        //比较两个时间差
        System.out.println("fit time span-->" + getFitTimeSpan("2019-05-17 18:34:16", "2019-05-10 18:35:16", 5));
        System.out.println(getFitTimeSpan("2019-05-17 18:34:16", "2019-05-10 18:35:16", DEFAULT_FORMAT, 1));

        System.out.println(getTimeSpan("2019-05-17 18:34:16", "2019-05-10 18:35:16", DAY));
        System.out.println(getTimeSpan("2019-05-17", "2019-05-10", PATTEN_YMD, DAY));

        //millis-11位,秒;13 位,毫秒-->string
        //string--->millis     结果--->1558089256000
        System.out.println(string2Millis("2019-05-17 18:34:16"));
        //没有时分秒,后面的类型要对应,结果--->  1558022400000(相当于2019-05-17 00:00:00)
        System.out.println(string2Millis("2019-05-17", PATTEN_YMD));

        //string ----> date
        System.out.println(string2Date("2019-05-17 18:34:16"));
        //转换后默认时分秒是00:00:00
        System.out.println(string2Date("2019-05-17 18:34:16", PATTEN_YMD));
        System.out.println(string2Date("2019-05-17", PATTEN_YMD));

        //date ---> string  年月日时分秒
        System.out.println(date2String(new Date()));
        //date ---> string  年月日
        System.out.println(date2String(new Date(), PATTEN_YMD));

        //获取当前的时间
        System.out.println("当前日期--->" + getNowString());
        System.out.println(getNowString(PATTEN_YMD));
        System.out.println(getNowString(PATTEN_YMD_CN));

        //获取当前的时分秒
        System.out.println(getNowString(PATTEN_HFM));
        //获取档期的小时
        System.out.println(getNowString(PATTEN_H));
        //获取当前分钟
        System.out.println(getNowString(PATTEN_M));

        //获取当前年,月,日,星期,小时,分钟,秒
        System.out.println(getNowY() + "年---" + getNowMonth() + "月--" + getNowDay() + "日--周" + getNowWeek() + "---"
                + getNowHour() + "时--" + getNowMinute() + "分---" + getNowSecond() + "秒");

        System.out.println(getLastDaysOfMonth(2019, 5));
    }


    /**
     * 获得明日0点0分0秒的时间戳
     *
     * @author xuxiaowen
     * @date 2019/03/29
     * @return
     */
    public static int getTomorrowMorning() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, 1);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return (int) (cal.getTimeInMillis() / 1000);

    }

    /**
     * 获得明日23点59分59秒的时间戳
     *
     * @return
     */
    public static int getTomorrowEnding() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, 1);
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.MILLISECOND, 0);
        return (int) (cal.getTimeInMillis() / 1000);
    }

    /**
     *
     * 获取当天的最晚时间23:59:59
     *
     * @author zsl-2017年4月28日
     *
     * @param date
     *            日期
     * @param //pattern
     *            格式
     * @return
     */
    public static Date getLatestTime(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        return calendar.getTime();
    }

    /**
     *
     * 获取当天的最早时间00:00:00
     *
     * @author zsl-2017年4月28日
     *
     * @param date
     *            日期
     * @param //pattern
     *            格式
     * @return
     */
    public static Date getFirstTime(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 00);
        calendar.set(Calendar.MINUTE, 00);
        calendar.set(Calendar.SECOND, 00);
        return calendar.getTime();
    }

    /**
     *
     * @author:nicholas
     * @date:2018年1月6日下午4:33:43
     * @desc:上周一
     * @param date
     * @return
     */
    public static Date geLastWeekMonday(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getThisWeekMonday(date));
        cal.add(Calendar.DATE, -7);
        return cal.getTime();
    }

    /**
     *
     * @author:nicholas
     * @date:2018年1月6日下午4:33:43
     * @desc:本周一
     * @param date
     * @return
     */
    public static Date getThisWeekMonday(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        // 获得当前日期是一个星期的第几天
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        return cal.getTime();
    }

    /**
     * 本周一凌晨
     *
     * @author zsl-2019年4月8日
     * @return
     */
    public static Date getThisWeekMonday0(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        // 获得当前日期是一个星期的第几天
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        return cal.getTime();
    }

    /**
     * 计算两个日期之间间隔天数
     *
     * @author xuxiaowen
     * @date 2018/8/30
     * @param startTime
     * @param endTime
     * @return
     * @throws ParseException
     */
    public static int daysBetween(Date startTime, Date endTime) {
        try {
            Calendar cal = Calendar.getInstance();
            cal.setTime(startTime);
            long time1 = cal.getTimeInMillis();
            cal.setTime(endTime);
            long time2 = cal.getTimeInMillis();
            long between_days = (time2 - time1) / (1000 * 3600 * 24);
            return Integer.parseInt(String.valueOf(between_days));
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 计算两个日期之间间隔天数
     *
     * @author xuxiaowen
     * @date 2018/8/30
     *
     * @param startTimeStr
     * @param endTimeStr
     * @param format
     * @return
     */
    public static long dayDiff(String startTimeStr, String endTimeStr, String format) {
        SimpleDateFormat formater = new SimpleDateFormat(format);
        long diff = 0L;
        try {
            long startTime = formater.parse(startTimeStr).getTime();
            long endTime = formater.parse(endTimeStr).getTime();
            diff = (endTime - startTime) / (1000 * 60 * 60 * 24);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return diff;
    }

    /**
     * 返回日时分秒
     *
     * @author:nicholas
     * @date:2018年9月29日上午11:02:02
     * @desc:
     * @param second
     * @return
     */
    public static String secondToTime(long second) {//时间戳是秒
        long days = second / 86400;// 转换天数
        second = second % 86400;// 剩余秒数
        long hours = second / 3600;// 转换小时数
        second = second % 3600;// 剩余秒数
        long minutes = second / 60;// 转换分钟
        second = second % 60;// 剩余秒数
        if (0 < days) {
            return days + " " + hours + ":" + minutes + ":" + second;
        } else {
            return hours + ":" + minutes + ":" + second;
        }
    }



    /**
     *
     * @author:nicholas
     * @date:2018年1月6日下午4:33:43
     * @desc:下周一
     * @param date
     * @return
     */
    public static Date getNextWeekMonday(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getThisWeekMonday(date));
        cal.add(Calendar.DATE, 7);
        return cal.getTime();
    }

    /**
     *
     * @author:nicholas
     * @date:2018年1月8日下午3:18:57
     * @desc:获取本月第一天
     * @return
     */
    public static Date getThisMonthFirstDay() {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        // 获取当前月第一天：
        Calendar c = Calendar.getInstance();
        c.add(Calendar.MONTH, 0);
        c.set(Calendar.DAY_OF_MONTH, 1);// 设置为1号,当前日期既为本月第一天
        String first = format.format(c.getTime());

        format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date firstDay = null;
        try {
            first = first + " 00:00:00";
            firstDay = format.parse(first);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return firstDay;
    }

    /**
     * 获取本月最后一天
     *
     * @author zsl-2019年4月2日
     * @return
     */
    public static Date getThisMonthLastDay() {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        // 获取当前月最后一天：
        Calendar c = Calendar.getInstance();
        c.add(Calendar.MONTH, 0);
        c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
        String first = format.format(c.getTime());

        format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date firstDay = null;
        try {
            first = first + " 23:59:59";
            firstDay = format.parse(first);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return firstDay;
    }


    /**???
     * 获取当前日期最后时间-到秒结束
     *
     * @author xuxiaowen
     * @date 2018/8/17
     *
     * @param date
     * @return
     */
    public static Date initEndTime(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    public static Date initializeEndTime(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar.getTime();
    }

    public static Date initializeEndSecond(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 日期比较， 后面日期比前面的日期大
     *
     * @param dateFrom
     *            开始日期
     * @param dateEnd
     *            结束日期
     * @return boolean 比较结果
     */
    public static boolean checkDateFromTo(String dateFrom, String dateEnd) {
        if (checkDateCompare(dateFrom, dateEnd, COMPARE_TYPE_GTE)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断前后日期对比。 如果后面的日期大于前面的日期， 返回true。 否则返回false。
     *
     * @param dateFromStr
     *            开始日期
     * @param dateEndStr
     *            结束日期
     * @return boolean 比较结果
     */
    private static boolean checkDateCompare(String dateFromStr, String dateEndStr, String compareType) {
        if (!checkIsActiveDate(dateFromStr) || !checkIsActiveDate(dateEndStr)) {
            return false;
        } else {
            Date dateFrom = string2Date(dateFromStr, PATTEN_YMD);
            Date dateEnd = string2Date(dateEndStr, PATTEN_YMD);

            if (COMPARE_TYPE_GT.equals(compareType)) {
                // 大于
                if (dateFrom.before(dateEnd)) {
                    return true;
                }
            } else if (COMPARE_TYPE_GTE.equals(compareType)) {
                // 大于等于
                if (!dateEnd.before(dateFrom)) {
                    return true;
                }
            } else if (COMPARE_TYPE_GTE.equals(compareType)) {
                // 不等于
                if (!isEqual(dateFromStr, dateEndStr)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 比较两个日期大小
     *
     * @param startDate
     *            开始日期
     * @param endDate
     *            结束日期
     * @return 开始日期早于结束日期，返回true。否则返回false。相等，返回false
     */
    public static boolean dateCompare(Date startDate, Date endDate) {
        if (startDate.before(endDate)) {
            return true;
        }
        return false;
    }

    /**
     * 判断是否是有效日期
     *
     * @param date
     *            判断日期
     * @return 是否有效日期
     */
    public static boolean checkIsActiveDate(String date) {
        // 先验证基本格式是否正确
        if (!matches(date, DATE_REG_SIMPLE)) {
            return false;
        }
        // 验证复杂格式是否正确
        if (isNotEmpty(date) && date.contains(DEFAULT_SEPERATOR)) {
            String dateNoSeprator = date.replaceAll(DEFAULT_SEPERATOR, "");
            return matches(dateNoSeprator, DATE_REG);
        }
        return false;
    }


    /**
     * 判断两个String 是否相等， 如果都是null 也表示相等
     *
     * @param s1
     * @param s2
     * @return boolean
     */
    public static boolean isEqual(String s1, String s2) {
        if (s1 == null) {
            s1 = "";
        }
        if (s2 == null) {
            s2 = "";
        }
        return (s1.equals(s2));
    }

    /**
     * 判断是否不为空，不空返回true
     *
     * @param str
     * @return boolean
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }
    /**
     * 正则表达式匹配

     *
     * @param value
     * @param regexp
     * @return boolean
     */
    public static boolean matches(String value, String regexp) {
        if (isEmpty(value) || isEmpty(regexp)) {
            return false;
        } else {
            return value.matches(regexp);
        }
    }
    /**
     * 判断是否为空
     *
     * @param str
     * @return boolean
     */
    public static boolean isEmpty(String str) {
        if ("".equals(nvl(str))) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 处理String null 如果是null 返回空字符串，否则返回trim后的String
     *
     * @param value
     * @return String
     */
    public static String nvl(String value) {
        if (value == null) {
            return "";
        } else {
            return value.trim();
        }
    }
    /**
     * 返回某月的第一天
     *
     * @param year
     *            年
     * @param month
     *            月
     * @return 某月的第一天
     */
    public static Date getFirstDayOfMonth(String year, String month) {
        // 验证空
        if (isEmpty(year) || isEmpty(month)) {
            return null;
        }
        // 验证年
        if (!matches(year, "\\d{4}")) {
            return null;
        }
        // 验证月
        int monthValue = Integer.parseInt(month);
        if (monthValue > 12 || monthValue < 1) {
            return null;
        }
        // 改成 yyyy-MM-dd格式
        StringBuilder sb = new StringBuilder();
        sb.append(year);
        sb.append(DEFAULT_SEPERATOR);
        sb.append(month);
        sb.append(DEFAULT_SEPERATOR);
        sb.append("01");
        return string2Date(sb.toString(), PATTEN_YMD);
    }

    /**
     * 返回某月的最后一天
     *
     * @param year
     *            年
     * @param month
     *            月
     * @return 某月的最后一天
     */
    public static Date getLastDayOfMonth(String year, String month) {
        // 验证空
        if (isEmpty(year) || isEmpty(month)) {
            return null;
        }
        // 验证年
        if (!matches(year, "\\d{4}")) {
            return null;
        }
        // 验证月
        int monthValue = Integer.parseInt(month);
        if (monthValue > 12 || monthValue < 1) {
            return null;
        }
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, Integer.parseInt(year));
        cal.set(Calendar.MONTH, monthValue - 1);
        cal.set(Calendar.DATE, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        return cal.getTime();
    }

    /**
     * 获取当前时间的上一个月的年月
     *
     * @param date
     * @param pattern
     * @return
     */
    public static String getBeforeMonth(Date date, String pattern) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MONTH, -1);
        return date2String(cal.getTime(), pattern);
    }

    /**
     * 获取当前日期前30天的日期
     *
     * @param fm
     *            日期格式
     * @return 当前日期前三十天的日期
     * @throws //SystemException
     *             转换异常，抛出系统异常
     */
    public static String thirtyDaysBeforeNow(String fm) {
        String result;
        Calendar date = Calendar.getInstance();
        date.add(Calendar.DAY_OF_MONTH, -30);
        Format format = new SimpleDateFormat(fm);
        result = format.format(date.getTime());
        return result;
    }

    /**
     * 获取指定日期的前30天的日期
     *
     * @param startDate
     *            指定日期
     * @param fm
     *            格式
     * @return 指定日期前30天的日期
     * @throws //SystemException
     *             转换异常，抛出系统异常
     */
    public static String thirtyDaysBeforeSpecifiedDate(Date startDate, String fm) {
        String result;
        Calendar date = Calendar.getInstance();
        date.setTime(startDate);
        date.add(Calendar.DAY_OF_MONTH, -30);
        Format format = new SimpleDateFormat(fm);
        result = format.format(date.getTime());
        return result;
    }

    /**
     * 获取前一天日期
     * @para
     * @return 前一天 日期
     * @throws //SystemException
     *             转换异常，抛出系统异常
     */
    public static String getBeforeDate(String patten) {
        String result;
        Calendar date = Calendar.getInstance();
        date.add(Calendar.DAY_OF_MONTH, -1);
        Format format = new SimpleDateFormat(patten);
        result = format.format(date.getTime());
        return result;
    }

    /**获取明天的日期
     * @param patten
     * @return
     */
    public static String getTomorrowDate(String patten){
        String result;
        Calendar date = Calendar.getInstance();
        date.add(Calendar.DAY_OF_MONTH, 1);
        Format format = new SimpleDateFormat(patten);
        result = format.format(date.getTime());
        return result;
    }

    /**
     * 对date对象的年份字段设置value值，返回一个新的date对象，原date不变
     *
     * @param date  需要设置的date
     * @param value 需要设置的年份
     * @return 设置年份字段后返回的新的Date对象
     */
    private static Date setYears( Date date, int value) {
        return set(date, Calendar.YEAR, value);
    }

    /**
     * 对date对象的月字段设置value值，返回一个新的date对象，原date不变
     *
     * @param date  需要设置的date
     * @param value 需要设置的月
     * @return 设置月字段后返回的新的Date对象
     */
    private static Date setMonths(Date date, int value) {
        return set(date, Calendar.MONTH, value);
    }

    /**
     * 对date对象的天字段设置value值，返回一个新的date对象，原date不变
     *
     * @param date  需要设置的date
     * @param value 需要设置的天
     * @return 设置天字段后返回的新的Date对象
     */
    private static Date setDays( Date date, int value) {
        return set(date, Calendar.DAY_OF_MONTH, value);
    }

    /**
     * 对date对象的小时字段设置value值，返回一个新的date对象，原date不变
     *
     * @param date  需要设置的date
     * @param value 需要设置的小时
     * @return 设置小时字段后返回的新的Date对象
     */
    private static Date setHours( Date date, int value) {
        return set(date, Calendar.HOUR_OF_DAY, value);
    }

    /**
     * 对date对象的分钟字段设置value值，返回一个新的date对象，原date不变
     *
     * @param date  需要设置的date
     * @param value 需要设置的分钟
     * @return 设置分钟字段后返回的新的Date对象
     */
    private static Date setMinutes( Date date, int value) {
        return set(date, Calendar.MINUTE, value);
    }

    /**
     * 对date对象的秒字段设置value值，返回一个新的date对象，原date不变
     *
     * @param date  需要设置的date
     * @param value 需要设置的秒值
     * @return 设置秒字段后返回的新的Date对象
     */
    private static Date setSeconds( Date date, int value) {
        return set(date, Calendar.SECOND, value);
    }

    /**
     * 对date对象的毫秒值字段设置value值，返回一个新的date对象，原date不变
     *
     * @param date  需要设置的date
     * @param value 需要设置的毫秒值
     * @return 设置毫秒值字段后返回的新的Date对象
     */
    private static Date setMilliseconds( Date date, int value) {
        return set(date, Calendar.MILLISECOND, value);
    }

    /**
     * 对date对象的calendarField字段设置value值，返回一个新的date对象，原date不变
     *
     * @param date          需要设置的date
     * @param calendarField Calendar字段
     * @param value         calendarField字段需要设置的值
     * @return 设置calendarField字段后返回的新的Date对象
     */
    private static Date set(Date date, int calendarField, int value) {
        if (null == date) {
            throw new IllegalArgumentException("The date must not be null");
        }
        Calendar calendar = getCalendar();
        calendar.setTime(date);
        calendar.set(calendarField, value);
        return calendar.getTime();
    }
    private static String set2(Date date, int calendarField, int value) {
        return date2String(set(date,calendarField,value));
    }


    /**
     * 在date时间基础上增加amount年,原date不变
     *
     * @param date   需要增加amount年的date时间
     * @param amount 增加amount年
     * @return 增加amount年后的date时间
     */
    public static Date addYears(Date date, int amount) {
        return add(date, amount);
    }

    public static String addYears(String time, int amount){//默认时间格式
        Date date = addYears(string2Date(time), amount);
        return date2String(date);
    }
    public static String addYears(String time, String patten, int amount){//自定义时间格式
        Date date = addYears(string2Date(time,patten), amount);
        return date2String(date);
    }
        /**
     * 增加date，返回一个新的date对象，原date不变
     *
     * @param date          需要增加的date
     * @param amount        增加的总数，可以是负的
     * @return 增加后的新的date对象
     */
    private static Date add(Date date, int amount) {
        if (null == date) {
            throw new IllegalArgumentException("The date must not be null");
        }
        Calendar calendar = getCalendar();
        calendar.setTime(date);
        calendar.add(Calendar.YEAR, amount);
        return calendar.getTime();
    }

    /**
     * 日期加月
     *
     * @param date
     *            日期
     * @param spans
     *            增加数量
     * @return 加月后的日期
     */
    public static Date addMonth(Date date, int spans) {
        return addDate(date, Calendar.MONTH, spans);
    }

    public static String addMonth(String time,int spans){//默认时间格式
        return date2String(addMonth(string2Date(time),spans));
    }
    public static String addMonth(String time, String patten, int spans){//自定义样式,返回样式相同
        return date2String(addMonth(string2Date(time,patten),spans),patten);
    }

    /**
     * 日期加天
     *
     * @param date
     *            日期
     * @param spans
     *            增加数量
     * @return 加天后的日期
     */
    public static Date addDay(Date date, int spans) {
        return addDate(date, Calendar.DAY_OF_MONTH, spans);
    }

    public static String addDay(String time, int spans){//默认时间格式
        return date2String(addDay(string2Date(time),spans));
    }
    public static String addDay(String time, String patten, int spans){//自定义格式
        return date2String(addDay(string2Date(time, patten),spans), patten);
    }

    /**
     * 日期加小时
     *
     * @param date
     *            日期
     * @param spans
     *            增加数量
     * @return 加小时后的日期
     */
    public static Date addHour(Date date, int spans) {
        return addDate(date, Calendar.HOUR_OF_DAY, spans);
    }

    public static String addHour(String time, int spans){//默认格式
        return date2String(addHour(string2Date(time),spans));
    }

    public static String addHour(String time, String patten, int spans){//自定义格式
        return date2String(addHour(string2Date(time,patten),spans),patten);
    }

    /**
     * 日期加分钟
     *
     * @param date
     *            日期
     * @param spans
     *            增加数量
     * @return 加分钟后的日期
     */
    public static Date addMinute(Date date, int spans) {
        return addDate(date, Calendar.MINUTE, spans);
    }

    public static String addMinute(String time, int spans){//默认格式
        return date2String(addMinute(string2Date(time),spans));
    }

    public static String addMinute(String time, String patten, int spans){//自定义格式
        return date2String(addMinute(string2Date(time,patten),spans),patten);
    }

    /**
     * 日期加秒
     *
     * @param date
     *            日期
     * @param spans
     *            增加数量
     * @return 加秒后的日期
     */
    public static Date addSecond(Date date, int spans) {
        return addDate(date, Calendar.SECOND, spans);
    }
    /**
     * 日期加法计算
     *
     * @param date
     *            日期
     * @param type
     *            增加类型
     * @param spans
     *            增加数量
     * @return 加法计算后的日期
     */
    public static Date addDate(Date date, int type, int spans) {
        Calendar inputCalendar = Calendar.getInstance();
        inputCalendar.setTime(date);
        inputCalendar.add(type, spans);
        return inputCalendar.getTime();
    }
    /**
     * 判断一个时间是不是明天
     * @param date 需要判断的时间
     * @return true明天，false不是
     */
    public static boolean isTomorrow(Date date) {
        Calendar calendar1 = getCalendar();
        calendar1.setTime(date);

        Calendar calendar2 = getCalendar();
        calendar2.add(Calendar.DAY_OF_MONTH, 1);
        return isSameDay(calendar1, calendar2);
    }

    public static boolean isTomorrow(String time){
        return isTomorrow(string2Date(time));
    }
    public static boolean isTomorrow(String time, String patten){
        return isTomorrow(string2Date(time,patten));
    }
    public static boolean isTomorrow(long time){
        return isTomorrow(millis2Date(time));
    }

    /**获取 Calendar
     * @return
     */
    public static Calendar getCalendar() {
        return Calendar.getInstance();
    }

    /**获取任意时间的年
     * @param time
     * @return
     */
    public static int getYear(String time){//默认时间格式
        return getYear(string2Date(time));
    }
    //其他时间格式
    public static int getYear(String time, String patten){
        return getYear(string2Date(time,patten));
    }
    public static int getYear(long time){
        return getYear(millis2Date(time));
    }

    public static int getYear(Date date){
        Calendar calendar = getCalendar();
         calendar.setTime(date);
         return calendar.get(Calendar.YEAR) ;
    }

    /**获取任意时间月份
     * @param
     * @return
     */
    public static int getMonth(String time){//默认时间格式
        return getMonth(string2Date(time));
    }

    public static int getMonth(String time, String patten){//任意时间格式
        return getMonth(string2Date(time,patten));
    }
    public static int getMonth(long time){
        return getMonth(millis2Date(time));
    }

    public static int getMonth(Date date){
        Calendar calendar = getCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.MONTH) + 1;
    }

    /**获取任意时间的天
     * @param time
     * @return
     */
    public static int getDay(String time){//默认时间格式
        return getDay(string2Date(time));
    }
    public static int getDay(String time, String patten){//自定义时间格式
        return getDay(string2Date(time,patten));
    }
    public static int getDay(long time){//默认年月日时分秒
        return getDay(millis2Date(time));
    }

    public static int getDay(Date date){
        Calendar calendar = getCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.DATE);
    }

    /**获取任意时间的小时,12 小时制
     * @param date
     * @return
     */
    public static int getHour(Date date){
        Calendar calendar = getCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.HOUR);
    }

    /**获取任意时间的小时,24 小时制
     * @param date
     * @return
     */
    public static int getHour2(Date date){
        Calendar calendar = getCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.HOUR_OF_DAY);
    }

    /**获取时间的小时,默认时间格式,默认是获取 24 小时制
     * @param time
     * @return
     */
    public static int getHour(String time){
      return getHour(time,true);
    }

    /**获取时间的小时,默认时间格式
     * @param time
     * @param is24
     * @return
     */
    public static int getHour(String time, boolean is24){
      return getHour(time,PATTEN_YMDSFM,is24);
    }

    /**获取时间的小时,自定义时间格式,至少要到小时
     * @param time
     * @param patten
     * @param is24
     * @return
     */
    public static int getHour(String time, String patten, boolean is24){
        Date date = string2Date(time,patten);
        if (is24){
            return getHour2(date);
        }else {
            return getHour(date);
        }
    }

    public static int getHour(long time,boolean is24){
        if (is24){
            return getHour2(millis2Date(time));
        }else {
            return getHour(millis2Date(time));
        }
    }

    /**获取日期的分钟
     * @param date
     * @return
     */
    public static int getMinute(Date date){
        Calendar calendar = getCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.MINUTE);
    }

    /**获取时间的分钟,默认时间格式
     * @param time
     * @return
     */
    public static int getMinute(String time){
        return getMinute(string2Date(time));
    }

    public static int getMinute(long time){
        return getMinute(millis2Date(time));
    }

    /**获取日期的秒
     * @param date
     * @return
     */
    public static int getSecond(Date date){
        Calendar calendar = getCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.SECOND);
    }
    public static int getSecond(String time){
        return getSecond(string2Date(time));
    }
    public static int getSecond(long time){
        return getSecond(millis2Date(time));
    }

    /**
     * 检查两个Calendar对象是否是同一天，忽略时间
     *
     * @param calendar1 first Calendar
     * @param calendar2 second Calendar
     * @return true：同一天，false不是同一天
     */
    public static boolean isSameDay( Calendar calendar1,  Calendar calendar2) {
        if (null == calendar1 || null == calendar2) {
            throw new IllegalArgumentException("The date must not be null");
        }
        return calendar1.get(Calendar.ERA) == calendar2.get(Calendar.ERA) &&
                calendar1.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR) &&
                calendar1.get(Calendar.DAY_OF_YEAR) == calendar2.get(Calendar.DAY_OF_YEAR);
    }

        /**
     * 检查两个Date对象是否是同一天
     *
     * @param date1 first Date
     * @param date2 second Date
     * @return true：同一天，false不是同一天
     */
    public static boolean isSameDay(Date date1, Date date2) {
        if (null == date1 || null == date2) {
            throw new IllegalArgumentException("The date must not be null");
        }
        Calendar calendar1 = getCalendar();
        calendar1.setTime(date1);

        Calendar calendar2 = getCalendar();
        calendar2.setTime(date2);

        return isSameDay(calendar1, calendar2);
    }

    public static boolean isSameDay(String time1, String time2){//默认时间格式
        return isSameDay(string2Date(time1),string2Date(time2));
    }

    public static boolean isSameDay(String time1, String time2, String patten){//自定义时间格式
        return isSameDay(string2Date(time1,patten),string2Date(time2,patten));
    }

    public static boolean isSameDay(long time1,long time2){
        return isSameDay(millis2Date(time1),millis2Date(time2));
    }


    /**
     * 判断srcDate时间是否在startDate和endDate之间
     *
     * @param srcDate   需要判断的时间
     * @param startDate 开始时间
     * @param endDate   结束时间
     * @return true：srcDate时间在startDate和endDate之间，false：srcDate时间不在startDate和endDate之间
     */
    public static boolean between(Date srcDate,  Date startDate, Date endDate) {
        if (startDate.after(srcDate)) {
            return false;
        } else if (endDate.before(srcDate)) {
            return false;
        }
        return true;
    }

    public static boolean between(String srcDate,  String startDate, String endDate) {//三个时间,都是默认时间格式
        Date src = string2Date(srcDate);
        Date start = string2Date(startDate);
        Date end = string2Date(endDate);
        if (start.after(src)) {
            return false;
        } else if (end.before(src)) {
            return false;
        }
        return true;
    }

    public static boolean between(String srcDate,  String startDate, String endDate,String patten) {//三个时间时间格式要一样
        Date src = string2Date(srcDate,patten);
        Date start = string2Date(startDate,patten);
        Date end = string2Date(endDate,patten);
        if (start.after(src)) {
            return false;
        } else if (end.before(src)) {
            return false;
        }
        return true;
    }

        /**
     * 将Calendar对象转换为Date对象
     *
     * @param calendar 需要转换的Calendar对象
     * @return 转换后的Date对象
     */
    public static Date calendar2Date(Calendar calendar) {
        return calendar.getTime();
    }

    /**
     * //     * 将Date对象转换为Calendar对象
     * //     *
     * //     * @param date     需要转换的Date对象
     * //     * @param timeZone 时区
     * //     * @return 转换后的Calendar对象
     * //
     */
    public static Calendar date2Calendar(Date date, TimeZone timeZone) {
        Calendar calendar;
        if (null == timeZone) {
            calendar = Calendar.getInstance();
        } else {
            calendar = Calendar.getInstance(timeZone);
        }
        calendar.setTime(date);
        return calendar;
    }

    public static Calendar date2Calendar(Date date) {
        return date2Calendar(date, null);
    }


    /**
     * 计算时长
     *
     * @param duration 时长毫秒值
     * @return 时长
     */
    public static String computerDuration(long duration) {
        if (0 > duration) {
            return "0";
        }
        duration /= 1000;
        long day = duration / (24 * 60 * 60);
        long hour = duration / (60 * 60) % 24;
        long minute = duration / 60 % 60;
        long second = duration % 60;
        StringBuilder sb = new StringBuilder();
        if (day >= 1) {
            sb.append(day).append("天");
        }
        if (hour >= 1) {
            sb.append(hour).append("小时");
        }
        if (minute >= 1) {
            sb.append(minute).append("分钟");
        }
//        if (second >= 1) {
//            sb.append(second).append("秒");
//        }
        if (sb.length() <= 0) {
            sb.append("0分钟");
        }
        return sb.toString();
    }





    /**
     * 根据用户传入的时间表示格式，
     * 返回当前时间的格式 如果是yyyyMMdd，注意字母y不能大写。
     *
     * @param //yyyyMMddhhmmss
     * @return
     */

    public static String getUserDate(String patten) {//当前时间
        return getUserDate(getNowDate(), patten);
    }

    public static String getUserDate(Date time, String patten) {//任意时间
        SimpleDateFormat formatter = new SimpleDateFormat(patten);
        String dateString = formatter.format(time);
        return dateString;
    }

    public static String getUserDate(String time, String patten) {//任意时间,时间格式
        SimpleDateFormat formatter = new SimpleDateFormat(patten);
        return formatter.format(string2Date(time));
    }

    public static String getUserDate(long time, String patten) {//任意时间,时间格式
        SimpleDateFormat format = getDateParser(patten);
        return format.format(millis2Date(time));
    }

    /**
     * 时间前推或后推分钟,其中JJ表示分钟.
     */
    public static String getPreTime(String time, String jj) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String mydate1 = "";
        try {
            Date date1 = format.parse(time);
            long Time = (date1.getTime() / 1000) + Integer.parseInt(jj) * 60;
            date1.setTime(Time * 1000);
            mydate1 = format.format(date1);
        } catch (Exception e) {

        }
        return mydate1;
    }

    public static String getPreTime(String time, int jj) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String mydate1 = "";
        try {
            Date date1 = format.parse(time);
            long Time = (date1.getTime() / 1000) + jj * 60;
            date1.setTime(Time * 1000);
            mydate1 = format.format(date1);
        } catch (Exception e) {

        }
        return mydate1;
    }

    public static String getPreTime(Date time, int jj) {
        return getPreTime(date2String(time), jj);
    }

    public static String getPreTime(long time, int jj) {
        return getPreTime(millis2String(time), jj);
    }

    /**
     * 得到一个时间延后或前移几天的时间,nowdate为时间,delay为前移或后延的天数
     */
    public static String getNextDay(String nowdate, String delay) {//默认时间格式
        return getNextDay(nowdate, PATTEN_YMDSFM, delay);
    }

    public static String getNextDay(String nowdate, int delay) {//yyyy-MM-dd时间格式
        return getNextDay(nowdate, PATTEN_YMD, delay);
    }

    public static String getNextDay(Date date, int delay) {
        return getNextDay(date2String(date), PATTEN_YMDSFM, delay);
    }

    public static String getNextDay(long date, int delay) {
        return getNextDay(millis2String(date), PATTEN_YMDSFM, delay);
    }

    public static String getNextDay(String nowdate, String patten, String delay) {
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            String mdate = "";
            Date d = string2Date(nowdate, patten);
            assert d != null;
            long myTime = (d.getTime() / 1000) + Integer.parseInt(delay) * 24 * 60 * 60;
            d.setTime(myTime * 1000);
            mdate = format.format(d);
            return mdate;
        } catch (Exception e) {
            return "";
        }
    }

    public static String getNextDay(String nowdate, String patten, int delay) {
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            String mdate = "";
            Date d = string2Date(nowdate, patten);
            assert d != null;
            long myTime = (d.getTime() / 1000) + delay * 24 * 60 * 60;
            d.setTime(myTime * 1000);
            mdate = format.format(d);
            return mdate;
        } catch (Exception e) {
            return "";
        }
    }


    /**
     * 获取一个月的最后一天
     *
     * @param dat
     * @return
     */
    public static String getEndDateOfMonth(String dat) {// yyyy-MM-dd
        String str = dat.substring(0, 8);
        String month = dat.substring(5, 7);
        int mon = Integer.parseInt(month);
        if (mon == 1 || mon == 3 || mon == 5
                || mon == 7 || mon == 8 || mon == 10 || mon == 12) {
            str += "31";
        } else if (mon == 4 || mon == 6 || mon == 9 || mon == 11) {
            str += "30";
        } else {
            if (isLeapYear(dat)) {
                str += "29";
            } else {
                str += "28";
            }
        }
        return str;
    }

    public static String getEndDateOfMonth(Date dat) {
        return getEndDateOfMonth(date2String(dat));
    }

    public static String getEndDateOfMonth(long dat) {
        return getEndDateOfMonth(millis2String(dat));
    }

    /**
     * 返回美国时间格式 26 Apr 2006
     *
     * @param str
     * @return
     */
    public static String getEDate(String str) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        ParsePosition pos = new ParsePosition(0);
        Date strtodate = formatter.parse(str, pos);
        String j = strtodate.toString();
        String[] k = j.split(" ");
        return k[2] + k[1].toUpperCase() + k[5].substring(2, 4);
    }


    /**
     * 判断二个时间是否在同一个周
     *
     * @param date1
     * @param date2
     * @return
     */
    public static boolean isSameWeekDates(Date date1, Date date2) {
        Calendar cal1 = Calendar.getInstance();
        Calendar cal2 = Calendar.getInstance();
        cal1.setTime(date1);
        cal2.setTime(date2);
        int subYear = cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR);
        if (0 == subYear) {
            if (cal1.get(Calendar.WEEK_OF_YEAR) ==
                    cal2.get(Calendar.WEEK_OF_YEAR)) {
                return true;
            }
        } else if (1 == subYear && 11 ==
                cal2.get(Calendar.MONTH)) {
            // 如果12月的最后一周横跨来年第一周的话则最后一周即算做来年的第一周
            if (cal1.get(Calendar.WEEK_OF_YEAR) ==
                    cal2.get(Calendar.WEEK_OF_YEAR)) {
                return true;
            }
        } else if (-1 == subYear && 11 == cal1.get(Calendar.MONTH)) {
            if (cal1.get(Calendar.WEEK_OF_YEAR) ==
                    cal2.get(Calendar.WEEK_OF_YEAR)) {
                return true;
            }
        }
        return false;
    }

    public static boolean isSameWeekDates(String date1, String date2) {
        return isSameWeekDates(string2Date(date1), string2Date(date2));
    }

    /**
     * 判断二个时间是否在同一个周,两个时间类型可自定义
     */
    public static boolean isSameWeekDates(String date1, String patten1, String date2, String patten2) {
        return isSameWeekDates(string2Date(date1, patten1), string2Date(date2, patten2));
    }

    /**
     * 判断二个时间是否在同一个周,两个时间类型一样
     */
    public static boolean isSameWeekDates(String date1, String date2, String patten) {
        return isSameWeekDates(string2Date(date1, patten), string2Date(date2, patten));
    }

    /**
     * 判断二个时间是否在同一个周
     */
    public static boolean isSameWeekDates(long date1, long date2) {
        return isSameWeekDates(millis2Date(date1), millis2Date(date2));
    }

    /**
     * 根据日期,获得是本年第几周
     *
     * @return
     */
    public static int getSeqWeek(String time) {
        return getSeqWeek(time, PATTEN_YMDSFM);
    }

    public static int getSeqWeek() {//当前时间
        return getSeqWeek(getNowString(), PATTEN_YMDSFM);
    }

    public static int getSeqWeek(Date date) {
        return getSeqWeek(date2String(date), PATTEN_YMDSFM);
    }

    public static int getSeqWeek(long millis) {
        return getSeqWeek(millis2String(millis), PATTEN_YMDSFM);
    }

    public static int getSeqWeek(String time, String patten) {
        Calendar calendar = Calendar.getInstance();
        Date date = string2Date(time, patten);
        assert date != null;
        calendar.setTime(date);
        return calendar.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获得一个日期所在的周的星期几的日期，如要找出2002年2月3日所在周的星期一是几号
     *
     * @param sdate 默认时间格式,返回的也是默认格式
     * @param num
     * @return
     */
    public static String getWeekFormDate(String sdate, int num) {
        return getWeekFormDate(sdate, PATTEN_YMDSFM, num, PATTEN_YMDSFM);
    }

    public static String getWeekFormDate(String sdate, String patten, int num) {
        return getWeekFormDate(sdate, patten, num, PATTEN_YMDSFM);
    }

    public static String getWeekFormDate(Date sdate, int num) {
        return getWeekFormDate(date2String(sdate), PATTEN_YMDSFM, num, PATTEN_YMDSFM);
    }

    public static String getWeekFormDate(long sdate, int num) {
        return getWeekFormDate(millis2String(sdate), PATTEN_YMDSFM, num, PATTEN_YMDSFM);
    }

    public static String getWeekFormDate(String sdate, String patten, int num, String valuePatten) {
        Date dd = string2Date(sdate, patten);
        Calendar c = Calendar.getInstance();
        assert dd != null;
        c.setTime(dd);
        switch (num) {
            case 1:
// 返回星期一所在的日期
                c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
                break;
            case 2:
// 返回星期二所在的日期
                c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
                break;
            case 3:
// 返回星期三所在的日期
                c.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
                break;
            case 4:
// 返回星期四所在的日期
                c.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
                break;
            case 5:
// 返回星期五所在的日期
                c.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
                break;
            case 6:
// 返回星期六所在的日期
                c.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
                break;
            case 0:
// 返回星期日所在的日期
                c.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
                break;
            default:
        }
        return new SimpleDateFormat(valuePatten).format(c.getTime());
    }


    /**
     * 获取星座
     *
     * @param time
     * @return
     */
    public static String getZodiac(final String time) {
        return getZodiac(string2Date(time, DEFAULT_FORMAT));
    }

    public static String getZodiac(final String time, final DateFormat format) {
        return getZodiac(string2Date(time, format));
    }

    public static String getZodiac(final String time, final String patten) {
        return getZodiac(string2Date(time, patten));
    }

    public static String getZodiac(final Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int month = cal.get(Calendar.MONTH) + 1;
        int day = cal.get(Calendar.DAY_OF_MONTH);
        return getZodiac(month, day);
    }

    public static String getZodiac(final long millis) {
        return getZodiac(millis2Date(millis));
    }

    public static String getZodiac(final int month, final int day) {
        return ZODIAC[day >= ZODIAC_FLAGS[month - 1]
                ? month - 1
                : (month + 10) % 12];
    }

    /**
     * 获取生肖
     *
     * @param time
     * @return
     */
    public static String getChineseZodiac(final String time) {
        return getChineseZodiac(string2Date(time, DEFAULT_FORMAT));
    }

    public static String getChineseZodiac(final String time, final String patten) {
        return getChineseZodiac(string2Date(time, patten));
    }

    public static String getChineseZodiac(final String time, final DateFormat format) {
        return getChineseZodiac(string2Date(time, format));
    }

    public static String getChineseZodiac(final Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return CHINESE_ZODIAC[cal.get(Calendar.YEAR) % 12];
    }

    public static String getChineseZodiac(final int year) {
        return CHINESE_ZODIAC[year % 12];
    }

    /**
     * 获取英语的星期
     *
     * @param time
     * @return
     */
    public static String getUSWeek(final String time) {
        return getUSWeek(string2Date(time, DEFAULT_FORMAT));
    }

    public static String getUSWeek(final String time, String patten) {
        return getUSWeek(string2Date(time, getDateParser(patten)));
    }

    public static String getUSWeek(final String time, final DateFormat format) {
        return getUSWeek(string2Date(time, format));
    }

    public static String getUSWeek(final Date date) {
        return new SimpleDateFormat("EEEE", Locale.US).format(date);
    }

    public static String getUSWeek(final long millis) {
        return getUSWeek(new Date(millis));
    }


    /**
     * 获取星期几
     *
     * @param time
     * @return
     */
    public static String getChineseWeek(final String time) {
        return getChineseWeek(string2Date(time, DEFAULT_FORMAT));
    }

    public static String getChineseWeek(final String time, String patten) {
        return getChineseWeek(string2Date(time, getDateParser(patten)));
    }

    public static String getChineseWeek(final Date date) {
        return new SimpleDateFormat("E", Locale.CHINA).format(date);
    }

    public static String getChineseWeek(final long millis) {
        return getChineseWeek(new Date(millis));
    }

    /**
     * 获取友好型与当前时间的差
     *
     * @param time The formatted time string.
     * @return the friendly time span by now
     * 
    
     * 
  • 如果小于 1 秒钟内，显示刚刚
    • 
     * 
  • 如果在 1 分钟内，显示 XXX秒前
    • 
     * 
  • 如果在 1 小时内，显示 XXX分钟前
    • 
     * 
  • 如果在 1 小时外的今天内，显示今天15:32
    • 
     * 
  • 如果是昨天的，显示昨天15:32
    • 
     * 
  • 其余显示，2016-10-15
    • 
     * 
  • 时间不合法的情况全部日期和时间信息，如星期六 十月 27 14:21:20 CST 2007
    • 
     * 

     */
    public static String getFriendlyTimeSpanByNow(final String time) {
        return getFriendlyTimeSpanByNow(time, DEFAULT_FORMAT);
    }

    public static String getFriendlyTimeSpanByNow(final String time,
                                                  final String patten) {
        return getFriendlyTimeSpanByNow(string2Millis(time, patten));
    }

    public static String getFriendlyTimeSpanByNow(final String time,
                                                  final DateFormat format) {
        return getFriendlyTimeSpanByNow(string2Millis(time, format));
    }

    public static String getFriendlyTimeSpanByNow(final Date date) {
        return getFriendlyTimeSpanByNow(date.getTime());
    }

    /**
     * Return the friendly time span by now.
     *
     * @param millis The milliseconds.
     * @return the friendly time span by now
     * 
    
     * 
  • 如果小于 1 秒钟内，显示刚刚
    • 
     * 
  • 如果在 1 分钟内，显示 XXX秒前
    • 
     * 
  • 如果在 1 小时内，显示 XXX分钟前
    • 
     * 
  • 如果在 1 小时外的今天内，显示今天15:32
    • 
     * 
  • 如果是昨天的，显示昨天15:32
    • 
     * 
  • 其余显示，2016-10-15
    • 
     * 
  • 时间不合法的情况全部日期和时间信息，如星期六 十月 27 14:21:20 CST 2007
    • 
     * 

     */
    public static String getFriendlyTimeSpanByNow(final long millis) {
        long now = System.currentTimeMillis();
        long span = now - millis;
        if (span < 0)
        // U can read http://www.apihome.cn/api/java/Formatter.html to understand it.
        {
            return String.format("%tc", millis);
        }
        if (span < 1000) {
            return "刚刚";
        } else if (span < MIN) {
            return String.format(Locale.getDefault(), "%d秒前", span / SEC);
        } else if (span < HOUR) {
            return String.format(Locale.getDefault(), "%d分钟前", span / MIN);
        }
        // 获取当天 00:00
        long wee = getWeeOfToday();
        if (millis >= wee) {
            return String.format("今天%tR", millis);
        } else if (millis >= wee - DAY) {
            return String.format("昨天%tR", millis);
        } else {
            return String.format("%tF", millis);
        }
    }

    /**
     * 获取合适型与当前时间的差
     *
     * @param time
     * @param precision 
  • precision = 0，返回 null
    • 
     *                  *                  
  • precision = 1，返回天
    • 
     *                  *                  
  • precision = 2，返回天和小时
    • 
     *                  *                  
  • precision = 3，返回天、小时和分钟
    • 
     *                  *                  
  • precision = 4，返回天、小时、分钟和秒
    • 
     *                  *                  
  • precision >= 5，返回天、小时、分钟、秒和毫秒
     * @return
     */
    public static String getFitTimeSpanByNow(final String time, final int precision) {
        return getFitTimeSpan(time, getNowString(), DEFAULT_FORMAT, precision);
    }

    public static String getFitTimeSpanByNow(final String time,
                                             final DateFormat format,
                                             final int precision) {
        return getFitTimeSpan(time, getNowString(format), format, precision);
    }

    public static String getFitTimeSpanByNow(final String time,
                                             final String patten,
                                             final int precision) {
        SimpleDateFormat format = getDateParser(patten);
        return getFitTimeSpan(time, getNowString(format), format, precision);
    }

    public static String getFitTimeSpanByNow(final Date date, final int precision) {
        return getFitTimeSpan(date, getNowDate(), precision);
    }

    public static String getFitTimeSpanByNow(final long millis, final int precision) {
        return getFitTimeSpan(millis, System.currentTimeMillis(), precision);
    }

    /**
     * 获取时间和当前时间的时间差,时间格式默认(更精确)
     *
     * @param time
     * @param unit
     * @return
     */
    public static long getTimeSpanByNow(final String time, final int unit) {
        return getTimeSpan(time, getNowString(), unit);
    }

    /**
     * (有时分秒更精确)
     *
     * @param time
     * @param patten
     * @param unit
     * @return
     */
    public static long getTimeSpanByNow(final String time,
                                        final String patten,
                                        final int unit) {
        SimpleDateFormat format = getDateParser(patten);
        return getTimeSpan(time, getNowString(format), format, unit);
    }


    /**比较两个时间,返回想要的值
     * @param time1
     * @param time2
     * @param precision
  • precision = 0，返回 null
    • 
     *      *                  
  • precision = 1，返回天
    • 
     *      *                  
  • precision = 2，返回天和小时
    • 
     *      *                  
  • precision = 3，返回天、小时和分钟
    • 
     *      *                  
  • precision = 4，返回天、小时、分钟和秒
    • 
     *      *                  
  • precision >= 5，返回天、小时、分钟、秒和毫秒
    • 
     * @return
     */
    /**
     * 默认时间格式
     */
    public static String getFitTimeSpan(final String time1, final String time2, final int precision) {
        long delta = string2Millis(time1, DEFAULT_FORMAT) - string2Millis(time2, DEFAULT_FORMAT);
        return millis2FitTimeSpan(delta, precision);
    }

    public static String getFitTimeSpan(final String time1, final String time2, String patten, final int precision) {
        SimpleDateFormat format = getDateParser(patten);
        long delta = string2Millis(time1, format) - string2Millis(time2, format);
        return millis2FitTimeSpan(delta, precision);
    }

    public static String getFitTimeSpan(final String time1, final String time2, DateFormat format, final int precision) {
        long delta = string2Millis(time1, format) - string2Millis(time2, format);
        return millis2FitTimeSpan(delta, precision);
    }

    public static String getFitTimeSpan(final Date date1, final Date date2, final int precision) {
        return millis2FitTimeSpan(date2Millis(date1) - date2Millis(date2), precision);
    }

    /**
     * 13 位时间戳
     *
     * @param millis1
     * @param millis2
     * @param precision
     * @return
     */
    public static String getFitTimeSpan(final long millis1,
                                        final long millis2,
                                        final int precision) {
        return millis2FitTimeSpan(millis1 - millis2, precision);
    }

    private static String millis2FitTimeSpan(long millis, int precision) {
        if (precision <= 0) {
            return null;
        }
        precision = Math.min(precision, 5);
        String[] units = {"天", "小时", "分钟", "秒", "毫秒"};
        if (millis == 0) {
            return 0 + units[precision - 1];
        }
        StringBuilder sb = new StringBuilder();
        if (millis < 0) {
            sb.append("-");
            millis = -millis;
        }
        int[] unitLen = {86400000, 3600000, 60000, 1000, 1};
        for (int i = 0; i < precision; i++) {
            if (millis >= unitLen[i]) {
                long mode = millis / unitLen[i];
                millis -= mode * unitLen[i];
                sb.append(mode).append(units[i]);
            }
        }
        return sb.toString();
    }

    /**
     * 比较两个时间的时间差
     *
     * @param time1
     * @param time2
     * @param unit
     * @return
     */
    public static long getTimeSpan(String time1, String time2, int unit) {
        return getTimeSpan(time1, time2, DEFAULT_FORMAT, unit);
    }

    public static long getTimeSpan(String time1, String time2, String patten, int unit) {
        return getTimeSpan(time1, time2, getDateParser(patten), unit);
    }

    public static long getTimeSpan(Date date1, Date date2, int unit) {
        return millis2TimeSpan(date2Millis(date1) - date2Millis(date2), unit);
    }

    public static long getTimeSpan(long millis1, long millis2, int unit) {
        return millis2TimeSpan(millis1 - millis2, unit);
    }

    public static long getTimeSpan(String time1, String time2, DateFormat format, int unit) {
        return millis2TimeSpan(string2Millis(time1, format) - string2Millis(time2, format), unit);
    }

    private static long millis2TimeSpan(long millis, int unit) {
        return millis / unit;
    }

    /**
     * 判断是否是今天
     *
     * @param time
     * @return
     */
    public static boolean isToday(String time) {
        return isToday(string2Millis(time, DEFAULT_FORMAT));
    }

    public static boolean isToday(final long millis) {
        long wee = getWeeOfToday();
        return millis >= wee && millis < wee + DAY;
    }

    private static long getWeeOfToday() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTimeInMillis();
    }

    public static boolean isToday(Date date) {
        return isToday(date.getTime());
    }

    /**
     * 获取SimpleDateFormat
     *
     * @param pattern
     * @return
     */
    private static SimpleDateFormat getDateParser(String pattern) {
        return new SimpleDateFormat(pattern);
    }

    public static long string2Millis(String time) {
        return string2Millis(time, DEFAULT_FORMAT);
    }

    public static long string2Millis(String time, String patten) {
        try {
            return getDateParser(patten).parse(time).getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return -1;
    }

    public static long string2Millis(String time, DateFormat format) {
        try {
            return format.parse(time).getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 时间戳转外 String 类型日期
     *
     * @param millis
     * @return
     */
    public static String millis2String(long millis) {
        return millis2String(millis, DEFAULT_FORMAT);
    }

    public static String millis2String(long millis, DateFormat format) {
        return format.format(new Date(millis));
    }

    public static String millis2String(long millis, String pattern) {
        return millis2String(millis, getDateParser(pattern));
    }

    /**
     * string类型时间转为 date 类型
     *
     * @param time
     * @return
     */
    public static Date string2Date(String time) {
        return string2Date(time, DEFAULT_FORMAT);
    }

    public static Date string2Date(String time, String pattern) {
        try {
            return getDateParser(pattern).parse(time);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Date string2Date(String time, DateFormat format) {
        try {
            return format.parse(time);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * date 转成 string
     *
     * @param date
     * @return
     */
    public static String date2String(Date date) {
        return date2String(date, DEFAULT_FORMAT);
    }

    public static String date2String(Date date, DateFormat format) {
        return format.format(date);
    }

    /**
     * 返回自定义String类型时间
     */
    public static String date2String(Date date, String pattern) {
        return getDateParser(pattern).format(date);
    }

    /**
     * 时间戳毫秒转成 Date
     *
     * @param millis
     * @return
     */
    public static Date millis2Date(long millis) {
        return new Date(millis);
    }

    /**
     * date 转时间戳
     *
     * @param date
     * @return
     */
    public static long date2Millis(Date date) {
        return date.getTime();
    }

    /**
     * 根据传入的年份和月份，获取上一个月有多少天
     *
     * @param year
     * @param month
     * @return
     */
    public static int getLastDaysOfMonth(int year, int month) {
        int lastDaysOfMonth = 0;
        if (month == 1) {
            lastDaysOfMonth = getDaysOfMonth(year - 1, 12);
        } else {
            lastDaysOfMonth = getDaysOfMonth(year, month - 1);
        }
        return lastDaysOfMonth;
    }


    /**
     * 判断是否为闰年
     *
     * @param
     * @return
     */
    public static boolean isLeapYear(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int year = cal.get(Calendar.YEAR);
        return isLeapYear(year);
    }

    public static boolean isLeapYear(int year) {
        return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
    }

    public static boolean isLeapYear(long millis) {
        return isLeapYear(millis2Date(millis));
    }

    /**
     * 判断是否润年,默认格式
     */
    public static boolean isLeapYear(String time) {
        Date date = string2Date(time);
        return isLeapYear(date);
    }

    /**
     * 判断是否润年,自定义格式
     */
    public static boolean isLeapYear(String time, String patten) {
        Date date = string2Date(time, patten);
        return isLeapYear(date);
    }


    /**
     * 根据传入的年份和月份，判断当前月有多少天
     *
     * @param year
     * @param month
     * @return
     */
    public static int getDaysOfMonth(int year, int month) {
        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                return 31;
            case 2:
                if (isLeapYear(year)) {
                    return 29;
                } else {
                    return 28;
                }
            case 4:
            case 6:
            case 9:
            case 11:
                return 30;
            default:
        }
        return -1;
    }


    /**
     * 获取当前年份
     *
     * @return
     */
    public static String getNowY() {
        return String.valueOf(Calendar.getInstance().get(Calendar.YEAR));
    }

    public static int getNowY2() {
        return Calendar.getInstance().get(Calendar.YEAR);
    }

    /**
     * 获取当前月份
     *
     * @return
     */
    public static int getNowMonth() {
        return Calendar.getInstance().get(Calendar.MONTH) + 1;
    }

    /**
     * 获取当前日期是该月的第几天
     *
     * @return
     */
    public static int getNowDay() {
        return Calendar.getInstance().get(Calendar.DAY_OF_MONTH);
    }

    /**
     * 获取当前日期是该周的第几天,周日是第一天返回 1,周六最后一天返回 7
     *
     * @return
     */
    public static int getNowWeek() {
        return Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
    }


    /**
     * 获取当前时间 Date 类型
     *
     * @return
     */
    public static Date getNowDate() {
        return new Date();
    }

    /**
     * 获取当前是几点,二十四小时制
     */
    public static int getNowHour() {
        return Calendar.getInstance().get(Calendar.HOUR_OF_DAY);
    }

    /**
     * 获取当前是几分
     *
     * @return
     */
    public static int getNowMinute() {
        return Calendar.getInstance().get(Calendar.MINUTE);
    }

    /**
     * 获取当前秒
     *
     * @return
     */
    public static int getNowSecond() {
        return Calendar.getInstance().get(Calendar.SECOND);
    }


    /**
     * 获取当前时间字符串,年月日时分秒
     *
     * @return
     */
    public static String getNowString() {
//        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(PATTEN_YMDSFM);
//        return simpleDateFormat.format(getNowMills());
        return DEFAULT_FORMAT.format(getNowMills());
    }

    /**
     * 获取当前时间字符串,自定义返回类型
     *
     * @return
     */
    public static String getNowString(String pattern) {
//        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
////        return simpleDateFormat.format(getNowMills());
        return getDateParser(pattern).format(getNowMills());
    }

    public static String getNowString(DateFormat dateFormat) {
        return dateFormat.format(getNowMills());
    }

    /**
     * 获取当前时间的时间戳,毫秒
     *
     * @return
     */
    public static long getNowMills() {
        return System.currentTimeMillis();
    }


}

    参考：
    https://juejin.im/post/6844903848847523854#heading-0
    https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/time/DateUtils.html
    http://luokangyuan.com/dateutilsxue-xi-bi-ji/
    https://blog.csdn.net/yaomingyang/article/details/79138466
    https://www.cnblogs.com/abcwt112/p/5147537.html
    https://www.jianshu.com/p/1cbc6740d11a
    https://www.cnblogs.com/wangyayun/p/11732263.html
    https://my.oschina.net/u/437309/blog/3066640

    你可能感兴趣的:(日期工具类DateUtils)

    • 【Java日期类Date、LocalDate、LocalTime、 LocalDateTime及转换】 Rita_zzf Date日期类javaintellij-idea
      目录日期类Date世界标准时间（GMT=UTC）获取日期对象及获取时间毫秒数的两种方法：Date对象获取所有日期数据Date对象获取当前日期时间补零占位方法抽取获取时间日期SimpleDateFormat实现日期格式化与时间字符串解析日期比较与标准时间转换日期比较标准时间转换时区转换与构造方法将时间毫秒数转为日期对象时区转换时间毫秒数转为日期对象日期工具类封装日期对象格式化字符串字符串解析时间日期
    • java实现根据指定日期获取今年 去年 本季度 上个季度 本月 上个月的值 未兆 小技巧java
      日期工具类记录：importjava.text.DecimalFormat;importjava.text.SimpleDateFormat;importjava.util.ArrayList;importjava.util.Calendar;importjava.util.Date;importjava.util.List;/***处理时间的工具类*/publicclassDateUtil{/*
    • Vue3+vite搭建基础架构（3）--- 使用dayjs 谁不想飞舞青春 前端vue.jsvuejavascripthtml5前端
      Vue3+vite搭建基础架构（3）---使用dayjs说明官方文档vite.config.js别名配置安装dayjs安装命令使用dayjs将dayjs封装为自己的日期工具类使用dataUtil.js日期工具类示例说明这里记录下自己在Vue3+vite的项目使用dayjs的过程，不使用ts语法，方便以后直接使用。这里承接自己的博客Vue3+vite搭建基础架构（2）—使用ElementPlus这篇
    • Vue3使用dayjs以及dayjs日期工具类 谁不想飞舞青春 前端vuejavascript前端vue.js
      Vue3使用dayjs全局使用以及将dayjs封装为自己需要的日期工具类说明安装dayjs命令在main.js里面全局导入在vue模版中使用dayjs语法如下dayjs日期工具类说明这里记录下在Vue3里面使用dayjs插件，以及将它在全局使用，并且将dayjs封装成自己需要的日期工具类。留待以后需要时直接使用。安装dayjs命令npminstalldayjs--save在main.js里面全局导
    • EndOfTheDay - C++ Builder 玄坴
      C++Builder参考手册➙System::Dateutils➙EndOfTheDay这个日期时间所在天的结束时间，这一天的23:59:59.999头文件：#include命名空间：System::Dateutils函数原型：System::TDateTime__fastcallEndOfTheDay(constSystem::TDateTimeAValue);参数：AValue：日期时间；返回
    • Java核心类库之（常用API、字符串类、集合类、泛型） 袁袁袁袁满 java
      目录1常用API1.1Math类1.2System类1.3Object类1.4Objects类1.5Arrays类1.6基本类型包装类1.6.1Integer类概述和使用1.6.2int和String的相互转换1.6.3案例：字符串中数据排序1.6.4自动装箱和拆箱1.7日期类1.7.1Date类1.7.2SimpleDateFormat类[ˈsɪmpl]1.7.3日期工具类1.7.4Calend
    • JAVA 日期工具类：日期获取周，获取指定周周一周日，某月月初月末日期，日期时间戳字符串转换，日期加减等 程序媛一枚~ 工具箱JAVA算法java开发语言日期转换及获取指定周周一周日获取指定月月初月末获取
      JAVA日期工具类获取某天00:00:00点的时间戳日期获取周日期获取星期几获取时间戳属于当月的哪天获取指定周周一周日获取某月月初月末日期根据星期几获取日期获取年月日，时分秒根据day获取所在周，周一周日根据day获取所在月，月初月末日期根据day获取上月月末的时间戳日期时间戳字符串转换日期加减等源码org.apache.commonscommons-lang33.5org.projectlomb
    • 日期处理第一篇：优雅好用的Java日期工具类Joda-Time 程序无涯海 Java篇java开发语言joda-timejoda日期处理
      日常开发中，处理时间和日期是很常见的需求。基础的java内置工具类只有Date和Calendar，但是这些工具类的api使用并不是很方便和强大，于是就诞生了Joda-Time这个专门处理日期时间的库。安装joda-timejoda-time2.12.6简介Joda-Time提供了Java日期处理的优雅的替代品，在Java8之前，Joda-Time一直是首选日期处理工具类，以弥补JDK的不足。由于J
    • 日期与字符串相互转化（自定义日期工具类总结，Hutool工具类使用） 白白白鲤鱼 java开发语言springboot
      一、将日期格式化成字符串输出（Date转String）Java旧的时间API饱受诟病，Java8以后提供了新的时间API，在java.time包下。//获取当前时间LocalDateTimedate=LocalDateTime.now();//创建日期时间对象格式化器，日期格式类似：2023-05-2322:18:38DateTimeFormatterformatter=DateTimeForma
    • 日期处理第三篇：Hutool的日期时间工具-DateUtil使用 程序无涯海 Java篇hutooljavadatetime
      前面用两篇文章《日期处理第一篇：优雅好用的Java日期工具类Joda-Time》《日期处理第二篇：Java8新时间和日期API，看完你就全明白了》介绍了Java中日期处理常用的类，为什么还会有第三篇Hutool日期类的介绍呢？因为他实在太好用了，不信你看。官网文章介绍的很好，推荐可以直接去看官网：https://doc.hutool.cn/pages/Date/安装cn.hutoolhutool-
    • 日期处理第二篇：Java8新时间和日期API，看完你就全明白了 程序无涯海 Java篇java8新特性DateTime日期处理
      这里写目录标题简介为什么要引入新的日期APIJava8的日期&时间类LocalDate和LocalTimeLocalDateTimeInstantDurationPeriod日期的操作和格式化增加和减少日期格式化日期时区其他历法总结为什么Java8里会有新的时间和日期API呢，因为Java8之前的日期类是在是太难用了，在上一篇《日期处理第一篇：优雅好用的Java日期工具类Joda-Time》详细介
    • Hutool：时间日期工具类（DateUtil、DateTime、农历日期-ChineseDate、LocalDateTimeUtil、计时器工具-TimeInterval） liaozk_c Hutool工具类javaspringintellij-idea
      本文内容来源于Hutool官方文档，更多内容请去官网查看目录日期时间工具-DateUtil1、Date、long、Calendar之间的相互转换2、字符串转日期3、格式化日期输出4、获取Date对象的某个部分5、一天的开始和结束时间6、日期时间偏移7、日期时间差8、格式化时间差9、星座和属相10、日期范围11、其他日期时间对象-DateTime1、获取日期成员（年、月、日等）2、格式化为字符串农历
    • 全网最全的日期格式化工具类 飘风凌雪 工具类java前端springbootspringcloudmavenspringmybatis
      文章目录前言一、日期工具类前言提示：以下是本篇文章正文内容，下面案例可供参考一、日期工具类importlombok.extern.slf4j.Slf4j;importjava.text.ParseException;importjava.text.SimpleDateFormat;importjava.time.LocalDate;importjava.time.LocalDateTime;imp
    • 时间工具类 豆豆子i java
      publicclassDateUtilsextendsorg.apache.commons.lang3.time.DateUtils{publicstaticStringYYYY=“yyyy”;publicstaticStringYYYY_MM="yyyy-MM";publicstaticStringYYYY_MM_DD="yyyy-MM-dd";publicstaticStringYYYYMMD
    • java日期工具类、日期格式校验、日期格式化 五月天的尾巴 javajavajava日期工具类日期格式校验日期格式化
      文章目录前言日期格式校验String转DateDate格式化为String类型获取指定日期所在季度的第一天获取指定日期所在季度的最后一天LocalDate转Date日期utils工具类前言java项目中经常会使用到对日期进行格式校验、格式化日期、LocalDate与Date互转等等，以下整理一份经常会使用到的日期操作相关的方法。日期格式校验一般项目中需要对入参进行校验，比如必须是一个合法的日期且格
    • EndOfADay - C++ Builder 玄坴
      C++Builder参考手册➙System::Dateutils➙EndOfADay某一年的某一天的结束时间，这一年的第几天的结束时间(23:59:59.999)，这个年、月、日的结束时间(23:59:59.999)头文件：#include命名空间：System::Dateutils函数原型：System::TDateTime__fastcallEndOfADay(constSystem::Wor
    • Java日期工具类LocalDate 布丁吖 JavajavaLocalDate日期工具类
      Java日期工具类LocalDate嘚吧嘚java.util.DateJava8新增日期类时区LocalDate-API创建日期获取年月日修改年月日日期比较嘚吧嘚java.util.Date在Java8之前通常会使用Date结合SimpleDateFormat、Calender来处理时间和日期的相关需求。1、可读性差、易用性差、使用起来冗余繁琐2、java.util.Date是非线程安全的3、ja
    • Java日期工具类LocalDateTime 布丁吖 JavajavaLocalDateTimeJava8日期工具类
      Java日期工具类LocalDateTime嘚吧嘚LocalDateTime-API创建时间获取年月日时分秒增加时间减少时间替换时间日期比较嘚吧嘚压轴的来了，个人感觉LocalDateTime是使用频率最高的工具类，所以本篇像文章详细研究说明一下。如果看了Java日期工具类LocalDate和Java时间工具类LocalTime，那么本篇文章就算是一个整合、进阶吧。LocalDateTime-AP
    • Java日期工具类时间校验 布丁吖 Javajava日期校验正则表达式日期工具类
      Java日期工具类时间校验嘚吧嘚正则表达式版本一版本二版本三SimpleDateFormat工具类嘚吧嘚时间校验这个问题，我在网上找了很多资料，有用正则表达式的、有用格式工具类的。其实都能实现时间校验，既然两种方式都能实现，那么使用哪种方式更好呢？先告诉大家一个结论吧，我更倾向于用日期工具类来实现。接下来给大家分析一下。正则表达式版本一先来看一个简单的日期的正则表达式的规则，年份4位数字，月份2位
    • easyexcel导出自定义表头 往后余生9375
      com.alibabaeasyexcel2.2.3packagecom.sunnysoft.transfer.controller;importcom.alibaba.excel.EasyExcel;importcom.alibaba.excel.util.DateUtils;importcom.alibaba.excel.write.metadata.style.WriteCellStyle;i
    • Java日期工具类获取时间列表(一) 布丁吖 java日期时间列表
      Java获取时间列表获取时间列表嘚吧嘚指定时间范围获取指定时间范围内的每一天获取指定时间范围内每月的最后一天获取指定时间范围内每年的最后一天指定结束时间指定结束时间获取过去X天指定结束时间获取过去X月的最后一天指定结束时间获取过去X年的最后一天获取时间列表嘚吧嘚相信很多业务都有各种报表，日报表、月报表、年报表，甚至都有小时、分钟报表‍。要生成报表最基本的就是时间列表了，每次用的时候都写方法是不可取
    • 写了这么多年DateUtils，殊不知你还有这么多弯弯绕！ 哪 吒 搬砖工逆袭Java架构师javaandroid数据库
      目录在日常开发中，Date工具类使用频率相对较高，大家通常都会这样写：这很简单啊，有什么争议吗？格式化后出现的时间错乱。看看Java8是如何解决时区问题的：在处理带时区的国际化时间问题，推荐使用jdk8的日期时间类：在与前端联调时，报了个错，```java.lang.NumberFormatException:multiplepoints```，起初我以为是时间格式传的不对，仔细一看，不对啊。看一
    • WeeksInAYear - C++ Builder 玄坴
      C++Builder参考手册➙System::Dateutils➙WeeksInAYear这个日期所在的年一共有多少周头文件：#include命名空间：System::Dateutils函数原型：System::Word__fastcallWeeksInAYear(constSystem::WordAYear);参数：AYear：年，1-9999；返回值：参数AYear年有多少周，52或53；一年
    • Java 日期工具类(自用) 喝了zhe瓶奶 java开发语言后端
      Java日期工具类(自用)拥有的功能字符串转日期日期转字符串获取当前日所在的周一是几号当前日期周的最后一天根据日期区间获取月份列表根据日期获取年度中的周索引根据年份获取年中周列表获取某年的第几周的开始日期获取某年的第几周的结束日期获取当前时间所在周的开始日期获取当前时间所在周的结束日期获得上周一的日期获得本周一的日期获得下周一的日期获得今天日期获得本月一日的日期/***日期操作工具类*/publi
    • JAVA自用时间时间工具类 超级无敌秀 工具类java
      自用时间时间工具类importjava.text.ParseException;importjava.text.SimpleDateFormat;importjava.util.*;importorg.apache.commons.lang3.time.DateFormatUtils;/***日期工具类,继承org.apache.commons.lang.time.DateUtils类**@aut
    • IsSameDay - C++ Builder 玄坴
      C++Builder参考手册➙System::Dateutils➙IsSameDay判断两个日期时间是否在同一天头文件：#include命名空间：System::Dateutils函数原型：bool__fastcallIsSameDay(constSystem::TDateTimeAValue,constSystem::TDateTimeABasis);参数：AValue：日期时间1；ABasis
    • Java类——日期格式化类：SimpleDateFormat 类和 DateFormatUtils、DateUtils类 ShareBeHappy_Qin Javajava
      文章目录SimpleDateFormat类DateFormatUtils和DateUtils类我们经常需要把时间进行格式化处理，然后在进行存储；同时取出字符串格式的时间并解析成日期，方便阅读。参考SimpleDateFormat类SimpleDateFormat类在java.text.SimpleDateFormat包下。SimpleDateFormat通过new来创建一个对象来操作日期对象，然后
    • StartOfADay - C++ Builder 玄坴
      C++Builder参考手册➙System::Dateutils➙StartOfADay某一年的某一天的开始时间，这一年的第几天的开始时间(00:00:00.000)，这个年、月、日的开始时间(00:00:00.000)头文件：#include命名空间：System::Dateutils函数原型：System::TDateTime__fastcallStartOfADay(constSystem:
    • Java单例模式 1b（￣▽￣）d　 java单例模式开发语言
      单例模式介绍单例模式的作用：节省内存和计算，实例只创建一次，不必重复创建保证结果正确，比如单例计数器，用作多线程的数据统计方便管理，例如日期工具类，字符串工具类，不需要创建那么多的实例单例模式适用场景：无状态的工具类：比如日志工具类，不管是在哪里适用，我们需要的只是它帮我们记录日志信息，除此之外，并不需要在它的实例对象上存储任何状态，这时候我们就只需要一个实例对象即可。全局信息类：比如我们在一个类
    • 字符串时间与Date格式之间的转换 哈皮给 Java工具类java
      //--1、导包org.apache.commons.lang3.time--DateFormatUtils.format(Datedate,Stringpattern)//时间转字符串DateUtils.parseDate(Stringstr,Stringpattern)//字符串转时间//----2、自己写方法----/***Date格式转为字符串时间格式*@paramdate日期*@para
    • Enum 枚举 120153216 enum枚举
      原文地址：http://www.cnblogs.com/Kavlez/p/4268601.html Enumeration 于Java 1.5增加的enum type...enum type是由一组固定的常量组成的类型，比如四个季节、扑克花色。在出现enum type之前，通常用一组int常量表示枚举类型。比如这样： public static final int APPLE_FUJI = 0
    • Java8简明教程 bijian1013 javajdk1.8
              Java 8已于2014年3月18日正式发布了，新版本带来了诸多改进，包括Lambda表达式、Streams、日期时间API等等。本文就带你领略Java 8的全新特性。  一.允许在接口中有默认方法实现         Java 8 允许我们使用default关键字，为接口声明添
    • Oracle表维护 快速备份删除数据 cuisuqiang oracle索引快速备份删除
      我知道oracle表分区，不过那是数据库设计阶段的事情，目前是远水解不了近渴。 当前的数据库表，要求保留一个月数据，且表存在大量录入更新，不存在程序删除。 为了解决频繁查询和更新的瓶颈，我在oracle内根据需要创建了索引。但是随着数据量的增加，一个半月数据就要超千万，此时就算有索引，对高并发的查询和更新来说，让然有所拖累。 为了解决这个问题，我一般一个月会进行一次数据库维护，主要工作就是备
    • java多态内存分析 麦田的设计者 java内存分析多态原理接口和抽象类
            “  时针如果可以回头，熟悉那张脸，重温嬉戏这乐园，墙壁的松脱涂鸦已经褪色才明白存在的价值归于记忆。街角小店尚存在吗？这大时代会不会牵挂，过去现在花开怎么会等待。       但有种意外不管痛不痛都有伤害，光阴远远离开，那笑声徘徊与脑海。但这一秒可笑不再可爱，当天心
    • Xshell实现Windows上传文件到Linux主机 被触发 windows
      经常有这样的需求，我们在Windows下载的软件包，如何上传到远程Linux主机上？还有如何从Linux主机下载软件包到Windows下；之前我的做法现在看来好笨好繁琐，不过也达到了目的，笨人有本方法嘛； 我是怎么操作的： 1、打开一台本地Linux虚拟机，使用mount 挂载Windows的共享文件夹到Linux上，然后拷贝数据到Linux虚拟机里面；（经常第一步都不顺利，无法挂载Windo
    • 类的加载ClassLoader 肆无忌惮_ ClassLoader
      类加载器ClassLoader是用来将java的类加载到虚拟机中，类加载器负责读取class字节文件到内存中，并将它转为Class的对象（类对象），通过此实例的 newInstance()方法就可以创建出该类的一个对象。   其中重要的方法为findClass(String name)。   如何写一个自己的类加载器呢？ 首先写一个便于测试的类Student
    • html5写的玫瑰花 知了ing html5
      <html> <head> <title>I Love You!</title> <meta charset="utf-8" /> </head> <body> <canvas id="c"></canvas>
    • google的ConcurrentLinkedHashmap源代码解析 矮蛋蛋 LRU
      原文地址： http://janeky.iteye.com/blog/1534352 简述 ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对 ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见 http://code.google.com/p/concurrentlinke
    • webservice获取访问服务的ip地址 alleni123 webservice
      1. 首先注入javax.xml.ws.WebServiceContext, @Resource private WebServiceContext context; 2. 在方法中获取交换请求的对象。 javax.xml.ws.handler.MessageContext mc=context.getMessageContext(); com.sun.net.http
    • 菜鸟的java基础提升之道——————>是否值得拥有 百合不是茶
      1，c++，java是面向对象编程的语言，将万事万物都看成是对象；java做一件事情关注的是人物，java是c++继承过来的，java没有直接更改地址的权限但是可以通过引用来传值操作地址，java也没有c++中繁琐的操作，java以其优越的可移植型，平台的安全型，高效性赢得了广泛的认同，全世界越来越多的人去学习java，我也是其中的一员      java组成：
    • 通过修改Linux服务自动启动指定应用程序 bijian1013 linux
      Linux中修改系统服务的命令是chkconfig (check config)，命令的详细解释如下: chkconfig 功能说明：检查，设置系统的各种服务。 语　　法：chkconfig [ -- add][ -- del][ -- list][系统服务] 或 chkconfig [ -- level  <</SPAN>
    • spring拦截器的一个简单实例 bijian1013 javaspring拦截器Interceptor
      Purview接口 package aop; public interface Purview { void checkLogin(); } Purview接口的实现类PurviesImpl.java package aop; public class PurviewImpl implements Purview { public void check
    • [Velocity二]自定义Velocity指令 bit1129 velocity
      什么是Velocity指令 在Velocity中，#set,#if, #foreach, #elseif, #parse等，以#开头的称之为指令，Velocity内置的这些指令可以用来做赋值，条件判断，循环控制等脚本语言必备的逻辑控制等语句，Velocity的指令是可扩展的，即用户可以根据实际的需要自定义Velocity指令   自定义指令(Directive)的一般步骤 &nbs
    • 【Hive十】Programming Hive学习笔记 bit1129 programming
      第二章 Getting Started 1.Hive最大的局限性是什么？一是不支持行级别的增删改(insert, delete, update)二是查询性能非常差(基于Hadoop MapReduce）,不适合延迟小的交互式任务三是不支持事务2. Hive MetaStore是干什么的？Hive persists table schemas and other system metadata.
    • nginx有选择性进行限制 ronin47 nginx 动静　限制
      http { limit_conn_zone $binary_remote_addr zone=addr:10m; limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;... server {... location ~.*\.(gif|png|css|js|icon)$ {
    • java-4.-在二元树中找出和为某一值的所有路径 . bylijinnan java
      /* * 0.use a TwoWayLinkedList to store the path.when the node can't be path,you should/can delete it. * 1.curSum==exceptedSum:if the lastNode is TreeNode,printPath();delete the node otherwise
    • Netty学习笔记 bylijinnan javanetty
      本文是阅读以下两篇文章时： http://seeallhearall.blogspot.com/2012/05/netty-tutorial-part-1-introduction-to.html http://seeallhearall.blogspot.com/2012/06/netty-tutorial-part-15-on-channel.html 我的一些笔记 ===
    • js获取项目路径 cngolon js
      //js获取项目根路径，如： http://localhost:8083/uimcardprj function getRootPath(){     //获取当前网址，如： http://localhost:8083/uimcardprj/share/meun.jsp     var curWwwPath=window.document.locati
    • oracle 的性能优化 cuishikuan oracleSQL Server
         在网上搜索了一些Oracle性能优化的文章，为了更加深层次的巩固[边写边记]，也为了可以随时查看，所以发表这篇文章。     1.ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前，那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。（这点本人曾经做过实例验证过，的确如此哦！
    • Shell变量和数组使用详解 daizj linuxshell变量数组
      Shell 变量 定义变量时，变量名不加美元符号（$，PHP语言中变量需要），如： your_name="w3cschool.cc" 注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则： 首个字符必须为字母（a-z，A-Z）。 中间不能有空格，可以使用下划线（_）。 不能使用标点符号。 不能使用ba
    • 编程中的一些概念，KISS、DRY、MVC、OOP、REST dcj3sjt126com REST
      KISS、DRY、MVC、OOP、REST （1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。 （2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。 （3）OOP 即Object-Orie
    • [Android]设置Activity为全屏显示的两种方法 dcj3sjt126com Activity
      1. 方法1：AndroidManifest.xml 里，Activity的 android:theme  指定为" @android:style/Theme.NoTitleBar.Fullscreen" 示例:   <application      
    • solrcloud 部署方式比较 eksliang solrCloud
      solrcloud 的部署其实有两种方式可选，那么我们在实践开发中应该怎样选择呢？ 第一种：当启动solr服务器时，内嵌的启动一个Zookeeper服务器，然后将这些内嵌的Zookeeper服务器组成一个集群。  第二种：将Zookeeper服务器独立的配置一个集群，然后将solr交给Zookeeper进行管理   谈谈第一种：每启动一个solr服务器就内嵌的启动一个Zoo
    • Java synchronized关键字详解 gqdy365 synchronized
      转载自：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html 多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。 同步机制可以使用synchronized关键字实现。 当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。 当s
    • js实现登录时记住用户名 hw1287789687 记住我记住密码cookie记住用户名记住账号
      在页面中如何获取cookie值呢? 如果是JSP的话,可以通过servlet的对象request 获取cookie,可以 参考:http://hw1287789687.iteye.com/blog/2050040 如果要求登录页面是html呢?html页面中如何获取cookie呢? 直接上代码了 页面:loginInput.html 代码: <!DOCTYPE html PUB
    • 开发者必备的 Chrome 扩展 justjavac chrome
      Firebug：不用多介绍了吧https://chrome.google.com/webstore/detail/bmagokdooijbeehmkpknfglimnifench ChromeSnifferPlus：Chrome 探测器，可以探测正在使用的开源软件或者 js 类库https://chrome.google.com/webstore/detail/chrome-sniffer-pl
    • 算法机试题 李亚飞 java算法机试题
             在面试机试时，遇到一个算法题，当时没能写出来，最后是同学帮忙解决的。        这道题大致意思是：输入一个数，比如4,。这时会输出：           &n
    • 正确配置Linux系统ulimit值 字符串 ulimit
      在Linux下面部 署应用的时候，有时候会遇上Socket/File: Can’t open so many files的问题；这个值也会影响服务器的最大并发数，其实Linux是有文件句柄限制的，而且Linux默认不是很高，一般都是1024，生产服务器用 其实很容易就达到这个数量。下面说的是，如何通过正解配置来改正这个系统默认值。因为这个问题是我配置Nginx+php5时遇到了，所以我将这篇归纳进
    • hibernate调用返回游标的存储过程 Supanccy2013 javaDAOoracleHibernatejdbc
      注：原创作品，转载请注明出处。     上篇博文介绍的是hibernate调用返回单值的存储过程，本片博文说的是hibernate调用返回游标的存储过程。     此此扁博文的存储过程的功能相当于是jdbc调用select 的作用。 1，创建oracle中的包，并在该包中创建的游标类型。 ---创建oracle的程
    • Spring 4.2新特性-更简单的Application Event wiselyman application
      1.1 Application Event Spring 4.1的写法请参考10点睛Spring4.1-Application Event 请对比10点睛Spring4.1-Application Event 使用一个@EventListener取代了实现ApplicationListener接口,使耦合度降低; 1.2 示例 包依赖 <p
    按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他