日期工具类

最新推荐文章于 2023-07-15 10:39:47 发布
最新推荐文章于 2023-07-15 10:39:47 发布
阅读量252 收藏
点赞数
分类专栏： jAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_42552888/article/details/122487385
版权 
package com.yw.common.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 日期工具类
 *
 * @author lfb
 */
public class DateUtils {
    /**
     * 当String时间超过2038-01-19 11:14:07时,long(毫秒)转换为int(秒)会溢出.
     */
    public static final long TIME_MAX_VALUE = Integer.MAX_VALUE * 1000L;
    /**
     * yyyy-MM
     */
    public static final String FMT_DATE = "yyyy-MM";
    /**
     * yyyy-MM-dd
     */
    public static final String FMT_SHORT_DATE = "yyyy-MM-dd";
    /**
     * yyyy-MM-dd HH:mm:ss
     */
    public static final String FMT_LONG_DATE = "yyyy-MM-dd HH:mm:ss";
    /**
     * HH:mm
     */
    public static final String FMT_TIME_HH_MM = "HH:mm";
    /**
     * HH:mm:ss
     */
    public static final String FMT_TIME_HH_MM_SS = "HH:mm:ss";
    public static final SimpleDateFormat SDF_SHORT_DATE = new SimpleDateFormat(FMT_SHORT_DATE);
    public static final SimpleDateFormat SDF_LONG_DATE = new SimpleDateFormat(FMT_LONG_DATE);
    public static final SimpleDateFormat SDF_TIME = new SimpleDateFormat(FMT_TIME_HH_MM);
    public static final SimpleDateFormat SDF_TIME_HMS = new SimpleDateFormat(FMT_TIME_HH_MM_SS);
    private static final Logger LOGGER = LoggerFactory.getLogger(DateUtils.class);

    /**
     * 日期修改
     *
     * @param theDate    日期
     * @param addHours   增加天
     * @param addMinutes 增加分
     * @param addSecond  增加秒
     * @return
     */
    public static Date add(Date theDate, int addHours, int addMinutes, int addSecond) {
        if (theDate == null) {
            return null;
        }

        Calendar cal = Calendar.getInstance();
        cal.setTime(theDate);
        cal.add(11, addHours);
        cal.add(12, addMinutes);
        cal.add(13, addSecond);

        return cal.getTime();
    }

    /**
     * 判断到目前为止是否超过了指定的时间区间
     *
     * @param startTime
     * @param timeInterval
     * @return
     */
    public static boolean beyondTheTime(long startTime, long timeInterval) {
        return System.currentTimeMillis() - startTime >= timeInterval;
    }

    /**
     * 日期转换为字符串
     *
     * @param theDate     日期
     * @param datePattern {@code DatePattern}
     * @return
     */
    public static String date2String(Date theDate, String datePattern) {
        if (theDate == null) {
            return "";
        }

        DateFormat format = new SimpleDateFormat(datePattern);
        try {
            return format.format(theDate);
        } catch (Exception e) {
            LOGGER.error("", e);
        }
        return "";
    }

    /**
     * 格式化date时间类型为yyyy-MM-dd HH:mm:ss格式
     *
     * @param date
     * @return
     */
    public static String formatTime(Date date) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return simpleDateFormat.format(date);
    }

    /**
     * 格式化date时间类型为yyyy-MM-dd HH:mm:ss格式
     *
     * @param time
     * @return
     */
    public static String formatTime(long time) {
        return formatTime(new Date(time));
    }
    // /**
    // * long[]类型的秒 转换为总毫耗数
    // * @param seconds 秒数组
    // * @return
    // */
    // public static long toMillisSecond(long[] seconds) {
    // long millis = 0L;
    // if ((seconds != null) && (seconds.length > 0)) {
    // long[] arrayOfLong = seconds;
    // int j = seconds.length;
    // for (int i = 0; i < j; ++i) {
    // long time = arrayOfLong[i];
    // millis += time * 1000L;
    // }
    //
    // }
    // return millis;
    // }

    /**
     * 当前时间转换为秒
     *
     * @return
     */
    public static long getCurrentSecond() {
        return System.currentTimeMillis() * 1000; // 转换为秒
    }

    // /**
    // * 日期修改
    // * @param theDate 日期
    // * @param addDays 增加天数
    // * @param hour 设置小时
    // * @param minute 设置分
    // * @param second 设置秒
    // * @return
    // */
    // public static Date changeDateTime(Date theDate, int addDays, int hour,
    // int minute, int second) {
    // if (theDate == null) {
    // return null;
    // }
    //
    // Calendar cal = Calendar.getInstance();
    // cal.setTime(theDate);
    //
    // cal.add(5, addDays);
    //
    // if ((hour >= 0) && (hour <= 24)) {
    // cal.set(11, hour);
    // }
    // if ((minute >= 0) && (minute <= 60)) {
    // cal.set(12, minute);
    // }
    // if ((second >= 0) && (second <= 60)) {
    // cal.set(13, second);
    // }
    //
    // return cal.getTime();
    // }

    /**
     * @param delay
     * @param timeUnit
     * @return
     */
    public static Date getDelayDate(int delay, TimeUnit timeUnit) {
        return getDelayDate(System.currentTimeMillis(), delay, timeUnit);
    }

    /**
     * 根据指定时间获取delay时间
     *
     * @param time
     * @param delay
     * @param timeUnit
     * @return
     */
    public static Date getDelayDate(long time, int delay, TimeUnit timeUnit) {
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(time);
        if (delay == 0) {
            return c.getTime();
        }
        switch (timeUnit) {
            case DAYS:
                c.add(Calendar.DAY_OF_YEAR, delay);
                break;
            case HOURS:
                c.add(Calendar.HOUR_OF_DAY, delay);
                break;
            case MILLISECONDS:
                c.add(Calendar.MILLISECOND, delay);
                break;
            case MINUTES:
                c.add(Calendar.MINUTE, delay);
                break;
            case SECONDS:
                c.add(Calendar.SECOND, delay);
                break;
            default:
                LOGGER.warn(String.format("IllegalArgumentException:{%s}", timeUnit.toString()));
                break;
        }
        return c.getTime();
    }
    // /**
    // * 是否为本周的日期
    // * @param theDate 日期
    // * @return
    // */
    // public static int dayOfWeek(Date theDate) {
    // if (theDate == null) {
    // return -1;
    // }
    //
    // Calendar cal = Calendar.getInstance();
    // cal.setTime(theDate);
    //
    // return cal.get(7);
    // }

    // /**
    // * 日期是否为凌晨
    // * @param theDate
    // * @return
    // */
    // public static Date getDate0AM(Date theDate) {
    // if (theDate == null) {
    // return null;
    // }
    //
    // Calendar cal = Calendar.getInstance();
    // cal.setTime(theDate);
    // return new GregorianCalendar(cal.get(1), cal.get(2),
    // cal.get(5)).getTime();
    // }

    /**
     * 根据当前时间，获取下一天的零点
     *
     * @return
     */
    public static Date getDelayDay0AM(int day) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(new Date().getTime() + day * 86400000L);
        return new GregorianCalendar(cal.get(1), cal.get(2), cal.get(5)).getTime();
    }

    // public static Date getThisDay2359PM(Date theDate) {
    // if (theDate == null) {
    // return null;
    // }
    //
    // Calendar cal = Calendar.getInstance();
    // long millis = theDate.getTime() + 86400000L - 1000L;
    // cal.setTimeInMillis(millis);
    // Date date = new GregorianCalendar(cal.get(1), cal.get(2),
    // cal.get(5)).getTime();
    // return new Date(date.getTime() - 1000L);
    // }

    // public static int calc2DateTDOADays(Date startDate, Date endDate) {
    // if ((startDate == null) || (endDate == null)) {
    // return 0;
    // }
    // Date startDate0AM = getDate0AM(startDate);
    // Date endDate0AM = getDate0AM(endDate);
    // long v1 = startDate0AM.getTime() - endDate0AM.getTime();
    // return Math.abs((int) divideAndRoundUp(v1, 86400000.0D, 0));
    // }

    // public static Date getNextMonday(Date date) {
    // if (date == null) {
    // return null;
    // }
    //
    // Calendar cal = Calendar.getInstance();
    // cal.setTime(getDate0AM(date));
    // cal.set(7, 2);
    //
    // Calendar nextMondayCal = Calendar.getInstance();
    // nextMondayCal.setTimeInMillis(cal.getTimeInMillis() + 604800000L);
    // return nextMondayCal.getTime();
    // }

    // public static Date add(int addDay, boolean to0AM) {
    // Calendar calendar = Calendar.getInstance();
    // calendar.add(5, addDay);
    // Date time = calendar.getTime();
    // return (to0AM) ? getDate0AM(time) : time;
    // }

    public static int getNowInSecondes() {
        return (int) (new Date().getTime() / 1000);
    }

    // private static double divideAndRoundUp(double v1, double v2, int scale) {
    // if (scale < 0) {
    // throw new
    // IllegalArgumentException("The scale must be a positive integer or zero");
    // }
    //
    // BigDecimal bd1 = new BigDecimal(v1);
    // BigDecimal bd2 = new BigDecimal(v2);
    //
    // return bd1.divide(bd2, scale, 0).doubleValue();
    // }

    /**
     * 两个日期相差几天(按天数单位来比较)
     *
     * @param beginDate 开始日期
     * @param endDate   结束日期
     * @return
     */
    public static int getRemainDays(Date beginDate, Date endDate) {
        Calendar beginCalendar = Calendar.getInstance();
        beginCalendar.setTime(beginDate);
        Calendar endCalendar = Calendar.getInstance();
        endCalendar.setTime(endDate);
        int days = endCalendar.get(Calendar.DAY_OF_YEAR) - beginCalendar.get(Calendar.DAY_OF_YEAR);
        int diffYears = endCalendar.get(Calendar.YEAR) - beginCalendar.get(Calendar.YEAR);
        if (diffYears > 0) {
            if (beginCalendar.get(Calendar.YEAR) % 4 == 0 && beginCalendar.get(Calendar.YEAR) % 100 != 0 || beginCalendar.get(Calendar.YEAR) % 400 == 0) {
                days += 1;
            }
            days += diffYears * 365;
        }
        return days;
    }

    /**
     * 两个日期相差几天(按天数单位来比较)
     *
     * @param beginTime 开始日期
     * @param endTime   结束日期
     * @return
     */
    public static int getRemainDays(long beginTime, long endTime) {
        Calendar beginCalendar = Calendar.getInstance();
        beginCalendar.setTimeInMillis(beginTime);
        Calendar endCalendar = Calendar.getInstance();
        endCalendar.setTimeInMillis(endTime);
        int days = endCalendar.get(Calendar.DAY_OF_YEAR) - beginCalendar.get(Calendar.DAY_OF_YEAR);
        int diffYears = endCalendar.get(Calendar.YEAR) - beginCalendar.get(Calendar.YEAR);
        if (diffYears > 0) {
            if (beginCalendar.get(Calendar.YEAR) % 4 == 0 && beginCalendar.get(Calendar.YEAR) % 100 != 0 || beginCalendar.get(Calendar.YEAR) % 400 == 0) {
                days += 1;
            }
            days += diffYears * 365;
        }
        return days;
    }

    /**
     * 获取timeUnit字段指定的整数时间 example : delay 指定延时周期, timeUnit为MINUTE 那么每分钟00秒
     *
     * @param timeUnit 时间字段
     * @return
     */
    public static Date getRoundDelayDate(TimeUnit timeUnit) {
        Date now = new Date();
        Calendar c = Calendar.getInstance();
        c.setTime(now);
        c.set(Calendar.MILLISECOND, 0);
        switch (timeUnit) {
            case HOURS:
                c.set(Calendar.HOUR_OF_DAY, 0);
                break;
            case MINUTES:
                c.add(Calendar.MINUTE, 1);
                c.set(Calendar.SECOND, 0);
                break;
            case SECONDS:
                c.set(Calendar.SECOND, 0);
                break;
            default:
                LOGGER.warn(String.format("IllegalArgumentException:{%s}", timeUnit.toString()));
                break;
        }
        return c.getTime();
    }

    /**
     * 获取今天指定时间的Date
     *
     * @param hour
     * @param minute
     * @param seconds
     * @param millSenconds
     * @return
     */
    public static Calendar getSpecialTimeOfToday(int hour, int minute, int seconds, int millSenconds) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, hour);
        cal.set(Calendar.MINUTE, minute);
        cal.set(Calendar.SECOND, seconds);
        cal.set(Calendar.MILLISECOND, millSenconds);
        return cal;
    }

    /**
     * 获取指定时间的Date
     *
     * @param hour
     * @param time
     * @param hour
     * @return
     */
    public static long getSpecialTime(long time, int hour, int delayDay) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(time);
        cal.set(Calendar.HOUR_OF_DAY, hour);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        return getDelayDate(cal.getTimeInMillis(), delayDay, TimeUnit.DAYS).getTime();
    }

    /**
     * 获取今天指定时间
     *
     * @param hour
     * @return
     */
    public static long getSpecialTimeOfToday(int hour) {
        return getSpecialTimeOfToday(hour, 0, 0, 0).getTimeInMillis();
    }

    public static Calendar getTodayStart() {
        return getSpecialTimeOfToday(0, 0, 0, 0);
    }

    public static long getTodayEnd() {
        return DateUtils.getDelayDate(getSpecialTimeOfToday(0, 0, 0, 0).getTimeInMillis(), 1, TimeUnit.DAYS).getTime();
    }

    /**
     * 判断是否在时间区间内
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public static boolean isActiveTime(int startTime, int endTime) {
        int now = TimeUtils.getNow();
        return startTime < now && now < endTime;
    }

    /**
     * 判断是否在时间区间内
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public static boolean isActiveTime(long startTime, long endTime) {
        long now = System.currentTimeMillis();
        return startTime <= now && now <= endTime;
    }


    /**
     * 获取时间短内跨过了几个指定的点
     *
     * @param hours (小时点)
     */
    public static int getBetweenTimePassTimes(List<Integer> hours, long beginTime, long endTime) {
        int times = 0;
        int day = getRemainDays(beginTime, endTime) + 1;
        Calendar nowDay = Calendar.getInstance();
        nowDay.setTimeInMillis(beginTime);
        nowDay.set(Calendar.MINUTE, 0);
        nowDay.set(Calendar.SECOND, 0);
        nowDay.set(Calendar.MILLISECOND, 0);
        for (int i = 0; i < day; i++) {
            for (int hour : hours) {
                nowDay.set(Calendar.HOUR_OF_DAY, hour);
                long now = nowDay.getTimeInMillis();
                if (beginTime < now && now < endTime) {
                    times++;
                }
            }
            nowDay.add(Calendar.DATE, 1);
        }
        return times;
    }

    /**
     * 当前时间是否超过了指定时间
     *
     * @param endTime
     * @return
     */
    public static boolean isExceedTime(Date endTime) {
        Date now = new Date();
        return endTime.getTime() < now.getTime();
    }

    /**
     * 判断是否应该触发每日事件(例如次数重置事件)
     *
     * @param hour          事件应该被触发的时间,即配置时间(24小时制)
     * @param lastOccurTime 最近一次实际触发的时间,单位：秒
     * @return
     */
    public static boolean isTime4DailyEvent(int hour, int lastOccurTime) {
        long secondes = lastOccurTime;
        // 取得今天的触发时间
        Calendar checkDate = DateUtils.getSpecialTimeOfToday(hour, 0, 0, 0);
        Calendar now = Calendar.getInstance();

        // 如果今天的触发时间未到,则取过去最近一次的可触发时间
        if (now.before(checkDate)) {
            checkDate.add(Calendar.DAY_OF_YEAR, -1);
        }

        // 如果过去最近一次触发时间事件未被触发,则判断为可触发
        if (new Date(secondes * 1000).before(checkDate.getTime())) {
            return true;
        }
        return false;
    }

    /**
     * 判断是否应该触发每日事件(例如次数重置事件)
     *
     * @param hour          事件应该被触发的时间,即配置时间(24小时制)
     * @param lastOccurTime 最近一次实际触发的时间,单位：秒
     * @return
     */
    public static boolean isTime4DailyEvent(int hour, long lastOccurTime) {
        // 取得今天的触发时间
        Calendar checkDate = DateUtils.getSpecialTimeOfToday(hour, 0, 0, 0);
        Calendar now = Calendar.getInstance();

        // 如果今天的触发时间未到,则取过去最近一次的可触发时间
        if (now.before(checkDate)) {
            checkDate.add(Calendar.DAY_OF_YEAR, -1);
        }

        // 如果过去最近一次触发时间事件未被触发,则判断为可触发
        if (new Date(lastOccurTime).before(checkDate.getTime())) {
            return true;
        }
        return false;
    }

    /**
     * 是不否为今天
     *
     * @param second utc转换忧的秒
     * @return
     */
    public static boolean isToday(int second) {
        return isToday(second * 1000L);
    }
    
    /**
     * 是不是本月
     * @param millis
     * @return
     */
    public static boolean isMonth(long millis) {
        Calendar today = Calendar.getInstance();
        Calendar compareday = Calendar.getInstance();
        compareday.setTimeInMillis(millis);
        if (today.get(Calendar.YEAR) == compareday.get(Calendar.YEAR) && today.get(Calendar.MONTH) == compareday.get(Calendar.MONTH)) {
            return true;
        }
        return false;
    }

    /**
     * 是否为今天
     *
     * @param millis
     * @return
     */
    public static boolean isToday(long millis) {
        Calendar today = Calendar.getInstance();
        Calendar compareday = Calendar.getInstance();
        compareday.setTimeInMillis(millis);
        if (today.get(Calendar.YEAR) == compareday.get(Calendar.YEAR) && today.get(Calendar.DAY_OF_YEAR) == compareday.get(Calendar.DAY_OF_YEAR)) {
            return true;
        }
        return false;
    }

    /**
     * 字符串转换为Date对象
     *
     * @param dateString  日期字符串
     * @param datePattern {@code DatePattern}
     * @return
     */
    public static Date string2Date(String dateString, String datePattern) {
        if ((dateString == null) || (dateString.trim().isEmpty())) {
            return null;
        }
        DateFormat format = new SimpleDateFormat(datePattern);
        try {
            Date date = format.parse(dateString);
            if (date.getTime() > TIME_MAX_VALUE) {
                date.setTime(TIME_MAX_VALUE);
                return date;
            }
            return date;
        } catch (ParseException e) {
            LOGGER.error("ParseException in converting string to date: " + e.getMessage());
        }
        return null;
    }

    /**
     * 毫秒转换为秒
     *
     * @param millis 毫秒
     * @return
     */
    public static long toSecond(long... millis) {
        long second = 0L;
        if ((millis != null) && (millis.length > 0)) {
            long[] arrayOfLong = millis;
            int j = millis.length;
            for (int i = 0; i < j; ++i) {
                long time = arrayOfLong[i];
                second += time / 1000L;
            }

        }
        return second;
    }

    public static Date getDayEnd(long current) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(current);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 995);
        return new Date(calendar.getTimeInMillis());
    }

    public static Date getDateWithDifferDay(int differDay) {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_YEAR, differDay);
        return new Date(calendar.getTimeInMillis());
    }

    public static Date getDateWithDifferDay(Date current, int differDay) {
        if (current != null) {
            return getDateWithDifferDay(current.getTime(), differDay);
        } else {
            return getDateWithDifferDay(differDay);
        }
    }

    public static Date getDateWithDifferDay(long current, int differDay) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(current);
        calendar.add(Calendar.DAY_OF_YEAR, differDay);
        return new Date(calendar.getTimeInMillis());
    }

    public static Date getDayStart(long current) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(current);
        setDateToZeroHMS(calendar);
        return new Date(calendar.getTimeInMillis());
    }

    /**
     * 延期执行(整数倍时间)
     * <pre>例如：5分钟执行一次，当前时间为2015-8-24 15:48:22 开始时间为：2015-8-24 15:50:01</pre>
     * <pre>    当前时间为2015-8-24 15:57:22 开始时间为：2015-8-24 16:00:01</pre>
     *
     * @param startMinute 分钟
     * @return
     */
    public static Date getDelayMinuteDate(int startMinute) {
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        int m = c.get(Calendar.MINUTE);
        int minute = startMinute - (m % startMinute);
        c.add(Calendar.MINUTE, minute);
        c.set(Calendar.SECOND, 1);
        c.set(Calendar.MILLISECOND, 0);

        return c.getTime();
    }

    private static void setDateToZeroHMS(Calendar calendar) {
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
    }

    public static Date getDayStart(Date current) {
        if (current != null) {
            return getDayStart(current.getTime());
        } else {
            return getDayStart();
        }
    }

    public static Date getDayStart() {
        return getDayStart(System.currentTimeMillis());
    }

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

    public static int getMonth() {
        return Calendar.getInstance().get(Calendar.MONTH) + 1;
    }

    public static int getDayOfMonth() {
        return Calendar.getInstance().get(Calendar.DAY_OF_MONTH);
    }

    public static int getHourOfDay() {
        return Calendar.getInstance().get(Calendar.HOUR_OF_DAY);
    }

    public static long getTimeWithHHmm(String timeStr) {
        return getTimeWithHHmm(timeStr, 0);
    }

    /**
     * 根据小时分钟获取时间
     *
     * @param timeStr
     * @param delayDay
     * @return
     */
    public static long getTimeWithHHmm(String timeStr, int delayDay) {
        return getCalendarWithHHmm(timeStr, delayDay).getTimeInMillis();
    }

    /**
     * 获取时间根据周几,小时分钟
     *
     * @param dayOfWeek
     * @param hour
     * @param minute
     * @return
     */
    public static long getTimeWithWeekDayHHmm(int dayOfWeek, int hour, int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY, hour);
        calendar.set(Calendar.MINUTE, minute);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        if (dayOfWeek == Calendar.SUNDAY && calendar.get(Calendar.DAY_OF_WEEK) > Calendar.SUNDAY) {
            calendar.add(Calendar.WEEK_OF_YEAR, 1);
        }
        calendar.set(Calendar.DAY_OF_WEEK, dayOfWeek);
        return calendar.getTimeInMillis();
    }

    /**
     * 获取时间根据中国周几,小时分钟
     *
     * @param chineseWeekDays
     * @param timeStr
     * @return
     */
    public static long getTimeWihtWeekDayHHmm(int chineseWeekDays, String timeStr) {
        Calendar calendar = getCalendarWithHHmm(timeStr, 0);
        int dayOfWeek = getDayOfWeekByChinese(chineseWeekDays);
        if (dayOfWeek == Calendar.SUNDAY && calendar.get(Calendar.DAY_OF_WEEK) > Calendar.SUNDAY) {
            calendar.add(Calendar.WEEK_OF_YEAR, 1);
        }
        calendar.set(Calendar.DAY_OF_WEEK, dayOfWeek);
        return calendar.getTimeInMillis();
    }

    /**
     * 获取时间根据中国周几,小时分钟
     *
     * @param chineseWeekDays
     * @param timeStr
     * @return
     */
    public static Calendar getCalendarWihtWeekDayHHmm(int chineseWeekDays, String timeStr) {
        Calendar calendar = getCalendarWithHHmm(timeStr, 0);
        int dayOfWeek = getDayOfWeekByChinese(chineseWeekDays);
        if (calendar.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
            calendar.add(Calendar.WEEK_OF_YEAR, -1);
        }
        if (dayOfWeek == Calendar.SUNDAY) {
            calendar.add(Calendar.WEEK_OF_YEAR, 1);
        }
        calendar.set(Calendar.DAY_OF_WEEK, dayOfWeek);
        return calendar;
    }

    /**
     * 根据小时分钟获取Calendar
     *
     * @param timeStr
     * @return
     */
    public static Calendar getCalendarWithHHmm(String timeStr) {
        return getCalendarWithHHmm(timeStr, 0);
    }

    /**
     * 获取小时分钟数
     *
     * @return
     */
    public static int getHourMinute() {
        return getHourMinute(Calendar.getInstance());
    }

    /**
     * 获取小时分钟数
     *
     * @param time
     * @return
     */
    public static int getHourMinute(long time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(time);
        return calendar.get(Calendar.HOUR_OF_DAY) * 100 + calendar.get(Calendar.MINUTE);
    }

    /**
     * 获取小时分钟数
     *
     * @param calendar
     * @return
     */
    public static int getHourMinute(Calendar calendar) {
        return calendar.get(Calendar.HOUR_OF_DAY) * 100 + calendar.get(Calendar.MINUTE);
    }

    /**
     * 根据小时分钟获取Calendar
     *
     * @param calendar
     * @param timeStr
     * @return
     */
    public static Calendar getCalendarWithHHmm(Calendar calendar, String timeStr) {
        return getCalendarWithHHmm(calendar, timeStr, 0);
    }

    /**
     * 根据小时分钟获取Calendar
     *
     * @param timeStr
     * @param delayDay
     * @return
     */
    public static Calendar getCalendarWithHHmm(String timeStr, int delayDay) {
        Calendar calendar = Calendar.getInstance();
        return getCalendarWithHHmm(calendar, timeStr, delayDay);
    }

    /**
     * 根据小时分钟获取Calendar
     *
     * @param timeStr
     * @param delayDay
     * @return
     */
    public static Calendar getCalendarWithHHmm(Calendar calendar, String timeStr, int delayDay) {
        String[] strArray = timeStr.split(":");
        int hour = Integer.parseInt(strArray[0]);
        int minute = Integer.parseInt(strArray[1]);
        calendar.add(Calendar.DAY_OF_YEAR, delayDay);
        calendar.set(Calendar.HOUR_OF_DAY, hour);
        calendar.set(Calendar.MINUTE, minute);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar;
    }

    /**
     * 获取本周一零点时间
     *
     * @return
     */
    public static long getWeekMonday0AM() {
        return getWeekMonday0AM(System.currentTimeMillis());
    }

    /**
     * 获取上周一零点时间
     *
     * @return
     */
    public static long getPreWeekMonday0AM() {
        return getWeekMonday0AM(DateUtils.getDelayDate(-7, TimeUnit.DAYS).getTime());
    }

    /**
     * 获取本周一零点时间
     *
     * @return
     */
    public static long getWeekMonday0AM(long time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(time);
        if (calendar.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
            calendar.add(Calendar.DAY_OF_WEEK, -1);
        }
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTimeInMillis();
    }

    /**
     * 根据中国周几获取国际周几
     *
     * @param chineseDayOfWeek
     * @return
     */
    public static int getDayOfWeekByChinese(int chineseDayOfWeek) {
        if (chineseDayOfWeek == 7) {
            return 1;
        } else {
            return ++chineseDayOfWeek;
        }
    }

    /**
     * 获取下一周期星期几的几点几分
     *
     * @param dayOfWeek
     * @return
     */
    public static long getNextDayOfWeekHHMM(int dayOfWeek, String timeStr) {
        Calendar calendar = Calendar.getInstance();
        long now = calendar.getTimeInMillis();
        calendar = getCalendarWithHHmm(calendar, timeStr, 0);
        calendar.set(Calendar.DAY_OF_WEEK, dayOfWeek);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        if (calendar.getTimeInMillis() < now) {
            calendar.add(Calendar.WEEK_OF_YEAR, 1);
        }
        return calendar.getTimeInMillis();
    }

    /**
     * 获取下一周期星期几的几点几分
     *
     * @param dayOfWeek
     * @return
     */
    public static long getNextDayOfWeekHH(int dayOfWeek, int hour) {
        Calendar calendar = Calendar.getInstance();
        long now = calendar.getTimeInMillis();
        calendar.set(Calendar.DAY_OF_WEEK, dayOfWeek);
        calendar.set(Calendar.HOUR_OF_DAY, hour);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        if (calendar.getTimeInMillis() < now) {
            calendar.add(Calendar.WEEK_OF_YEAR, 1);
        }
        return calendar.getTimeInMillis();
    }

    /**
     * 获取下一周期星期几的0点
     *
     * @param dayOfWeek
     * @return
     */
    public static long getNextDayOfWeek0AM(int dayOfWeek) {
        Calendar calendar = Calendar.getInstance();
        long now = calendar.getTimeInMillis();
        calendar.set(Calendar.DAY_OF_WEEK, dayOfWeek);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        if (calendar.getTimeInMillis() < now) {
            calendar.add(Calendar.WEEK_OF_YEAR, 1);
        }
        return calendar.getTimeInMillis();
    }

    /**
     * Sunday为星期天，数值为7 ,Monday为星期一,数值为 1
     *
     * @return
     */
    public static int getChineseDayOfWeek() {
        Integer dayOfWeek = getDayOfWeek();
        return getChineseDayOfWeek(dayOfWeek);
    }

    /**
     * Sunday为星期天，数值为7 ,Monday为星期一,数值为 1
     *
     * @return
     */
    public static int getChineseDayOfWeek(int dayOfWeek) {
        if (dayOfWeek == 1) {
            dayOfWeek = 7;
        } else {
            dayOfWeek--;
        }
        return dayOfWeek;
    }

    /**
     * 获取当前时间为星期几(Calendar)
     *
     * @return
     */
    public static Integer getDayOfWeek() {
        return Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 获取月份最大天数
     *
     * @param year
     * @param month
     * @return
     */
    public static int getMaxDayByYearMonth(int year, int month) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        calendar.set(Calendar.MONTH, month - 1);
        return calendar.getActualMaximum(Calendar.DATE);
    }

    /**
     * 获取历史最近的周几某小时
     *
     * @param dayOfWeek
     * @param hour
     * @return
     */
    public static long getLastDayOfWeek(int dayOfWeek, int hour) {
        Calendar calendar = Calendar.getInstance();
        long now = calendar.getTimeInMillis();
        calendar.set(Calendar.DAY_OF_WEEK, dayOfWeek);
        calendar.set(Calendar.HOUR_OF_DAY, hour);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        if (calendar.getTimeInMillis() > now) {
            calendar.add(Calendar.WEEK_OF_YEAR, -1);
        }
        return calendar.getTimeInMillis();
    }


    /**
     * 比较日期（年月日）
     */

    public static int dateCompare(Date date1, Date date2) {

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date dateFirst = null;
        try {
            dateFirst = dateFormat.parse(dateFormat.format(date1));
            Date dateLast = dateFormat.parse(dateFormat.format(date2));

            if (dateFirst.after(dateLast)) {
                return 1;
            } else if (dateFirst.before(dateLast)) {
                return -1;
            }
            return 0;
        } catch (ParseException e) {
            return 0;
        }
    }

}

package com.yw.module.projectstatistic.test;

import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.yw.common.util.HttpUtils;
import com.yw.common.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @Author lj
 * @Description 获取从某年有多少周，并且获取每一周的开始以及结束时间
 * @Date 2022/1/14
 **/
public class YearWeeksUtil {
    protected static final Logger logger = LoggerFactory.getLogger(YearWeeksUtil.class);

    public static Map<String, List<String>> holiday = Maps.newHashMap();

    public static Map<String, List<String>> overDay = Maps.newHashMap();

    /**
     * 获取某年某周的时间跨度
     *
     * @param year
     * @param week
     * @return
     */
    public static Map<String, String> getWeekRangeMap(int year, int week) {
        Map<String, String> timeMap = new LinkedHashMap<>();
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        calendar.setFirstDayOfWeek(Calendar.MONDAY);//设置星期一为一周开始的第一天
        calendar.setMinimalDaysInFirstWeek(4);//可以不用设置
        int weekYear = calendar.get(Calendar.YEAR);//获得当前的年
        calendar.setWeekDate(weekYear, week, 2);//获得指定年的第几周的开始日期
        Date time = calendar.getTime();
        String startTime = new SimpleDateFormat("yyyy-MM-dd").format(time);
        timeMap.put("startTime", startTime);
        calendar.setWeekDate(weekYear, week, 1);//获得指定年的第几周的结束日期
        time = calendar.getTime();
        String endTime = new SimpleDateFormat("yyyy-MM-dd").format(time);
        timeMap.put("endTime", endTime);
        return timeMap;
    }

    /**
     * 获取某年有多少周
     *
     * @param year
     * @return
     * @throws ParseException
     */

    public static int getYearWeekConut(int year) {
        int week = 52;
        try {
            Map<String, String> timeMap = getWeekRangeMap(year, 53);
            if (!CollectionUtils.isEmpty(timeMap)) {
                String startTime = timeMap.get("startTime");
                if (startTime.substring(0, 4).equals(year + "")) { //判断年度是否相符，如果相符说明有53个周。
                    week = 53;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return week;
    }

    /**
     * 获取某年所有周的时间跨度
     *
     * @param year
     * @return
     */

    public static Map<String, Map<String, String>> getYearWeekMap(int year) {
        int weeks = getYearWeekConut(year);
        Map<String, Map<String, String>> yearWeekMap = new LinkedHashMap<>();
        for (int i = 1; i <= weeks; i++) {
            Map<String, String> timeMap = getWeekRangeMap(year, i);
            yearWeekMap.put(i + "", timeMap);
        }
        return yearWeekMap;
    }

    public static void main(String[] args) {
//        Map<String, Map<String, String>> yearWeekMap = getYearWeekMap(2022);
//        for (Map.Entry<String, Map<String, String>> stringMapEntry : yearWeekMap.entrySet()) {
//            System.out.println(stringMapEntry.getKey() + "-" + stringMapEntry.getValue());
//        }
//        System.out.println("getYearWeekConut(2021) = " + getYearWeekConut(2021));
        try {
            System.err.println(findDates("2021-12-27", "2022-01-02"));
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }


    /**
     * 将时间段转换成list集合
     *
     * @param dBegin
     * @param dEnd
     * @return
     * @throws ParseException
     */
    public static List<String> findDates(String dBegin, String dEnd) throws ParseException {
        // 日期工具类准备
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd");

        // 设置开始时间
        Calendar calBegin = Calendar.getInstance();
        calBegin.setTime(format.parse(dBegin));

        // 设置结束时间
        Calendar calEnd = Calendar.getInstance();
        calEnd.setTime(format.parse(dEnd));

        // 装返回的日期集合容器
        List<String> Datelist = Lists.newArrayList();

        // 每次循环给calBegin日期加一天，直到calBegin.getTime()时间等于dEnd
        Datelist.add(dBegin);
        while (format.parse(dEnd).after(calBegin.getTime())) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            calBegin.add(Calendar.DAY_OF_MONTH, 1);
            Datelist.add(format.format(calBegin.getTime()));
        }

        List<String> list = new ArrayList<String>();
        // 将日期格式xxxx-xx-xx 转换成 xx-xx
        for (int i = 0; i < Datelist.size(); i++) {
            String date = Datelist.get(i);
            String day = date.substring(5, 7) + "-" + date.substring(8) + "";
            list.add(day);
        }
        return list;
    }

    public static void setHolidayAndOverDay(String year) {
        List<String> holidays = holiday.get(year);
        List<String> overDays = overDay.get(year);
        if (CollUtil.isNotEmpty(holidays) && CollUtil.isNotEmpty(overDays)) {
            return;
        }
        String url = "https://timor.tech/api/holiday/year/" + year + "/";
        String s = HttpUtils.sendGet(url);
        if (StringUtils.isEmpty(s)) {
            return;
        }
        try {
            Map<String, Map<String, Map<String, String>>> map = JSON.parseObject(s, Map.class);
            Map<String, Map<String, String>> holidaysMap = map.get("holiday");
            for (Map.Entry<String, Map<String, String>> entry : holidaysMap.entrySet()) {
                String key = entry.getKey();
                Object f = entry.getValue().get("holiday");
                if (f instanceof Boolean) {
                    boolean flag = (boolean) f;
                    if (flag) {
                        List<String> day = holiday.get(year);
                        if (CollUtil.isEmpty(day)) {
                            day = Lists.newArrayList();
                        }
                        day.add(key);
                        holiday.put(year, day);
                        continue;
                    }
                    List<String> list = overDay.get(year);
                    if (CollUtil.isEmpty(list)) {
                        list = Lists.newArrayList();
                    }
                    list.add(key);
                    overDay.put(year, list);
                }
            }
        }catch (Exception e){
            logger.error("json parse exception ");
        }
    }

    public static boolean isHodliDays(String year,String date, int type) { // 判断是否滴节假日，是否有节假日加班
        // 中国法定节假日期
        List<String> isHoliday = holiday.get(year);
        // 节假前后加班日期
        List<String> overDays = overDay.get(year);
        // 指定的 月份和日期
        if (isHoliday.contains(date)) {
            //放假
            return true;
        }
        if (overDays.contains(date)) {
            return false;
        }
        if (type >= 5) {
            //双休
            return true;
        }
        return false;
    }


    /**
     * 比较日期（年月日）
     */
    public static int dateCompare(Date date1, Date date2) {

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date dateFirst = null;
        try {
            dateFirst = dateFormat.parse(dateFormat.format(date1));
            Date dateLast = dateFormat.parse(dateFormat.format(date2));

            if (dateFirst.after(dateLast)) {
                return 1;
            } else if (dateFirst.before(dateLast)) {
                return -1;
            }
            return 0;
        } catch (ParseException e) {
            return 0;
        }
    }

}

python实现简单日期工具类
09-19
这里我们讨论的是一个简单的日期工具类的实现，这个类提供了一系列方法来处理日期和时间相关的操作。以下是对这些方法的详细解释： 1. `curMilis()` 和 `curSeconds()`：这两个函数分别返回当前时间的毫秒数和秒数...
Java日期工具类DateUtils实例详解
08-28
Java 日期工具类 DateUtils 实例详解 本文主要介绍了 Java 日期工具类 DateUtils 实例的实现和使用，涵盖了日期工具类的常用方法和变量，包括日期格式化、字符串转换、日期比较等。 日期工具类 DateUtils ...
cal.add(zoom, amount);
慕禾⑦叶
10-03 530
DateUtil.addDays(todayWorkEnd, 1); //表示对日期进行加一天操作 public static Date addDays(Date date, int amount) { return add(date, 5, amount); } private static Date add(Date date, int zoom, in...
JAVA时间戳-Calendar类（包括set,get,add方法）
最新发布
0
07-15 2932
Calendar 类是一个抽象类，它为特定时间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。
java中关于时间日期操作的常用函数
hbcui1984的专栏
10-12 1万+
java中关于时间日期操作的常用函数1.计算某一月份的最大天数Calendar time=Calendar.getInstance(); time.clear(); time.set(Calendar.YEAR,year); time.set(Calendar.MONTH,i-1);//注意,Calendar对象默认一月为0             int day=time.getAc
calendar的使用
02-01 428
经常要对时间进行处理，比如要算成月初，算成年初之类的，就常常用到calendar类，之前用到，一不小心把add写成set，然后一直出错，我看了老半天，才发现这个错误。比如提前12个月，正确的是要这样：cal.setTime(date);cal.add(Calendar.Month,-12); ps:这个Calendar特别要要注意月份是要加1的；还有还有平时要是算月末，就月份加1 ，日期减1，也...
Calendar的add()方法介绍
suoyihen
01-11 4741
由于项目当中要统计指定日期的日志记录，是使用Calendar的add方法来进行对日期参数进行相关的动态改变。但是看了java doc上面介绍的不是很清楚，只是说了一下add能够做什么事，并没有介绍如何具体实现。看了网上的一些资料大部分都是在讲add和roll两个方法的区别，其实我们只需要使用add方法就可以解决大部分的功能。比如我们需要得到当前年，月，日，小时，分钟，秒，毫秒的前面时间或者后面时间...
Android开发中日期工具类DateUtil完整实例
08-28
"Android日期工具类DateUtil详解" Android开发中日期工具类DateUtil是Android开发中一个非常重要的工具类，它提供了许多有用的方法来处理日期和时间相关的操作。今天，我们将详细介绍DateUtil工具类的实现和使用。 ...
calendar java 小时_使用Java中的Calendar.add()方法将小时数添加到当前时间
weixin_34012046的博客
02-20 2356
为Java中的Calendar类导入以下软件包。importjava.util.Calendar;首先，创建一个Calendar对象并显示当前日期和时间。Calendarcalendar=Calendar.getInstance();System.out.println("CurrentDateandTime="+calendar.getTime());现在，让我们使用cal...
java中时间的运算方式
MyArray的博客
11-22 3879
 对时间的各种操作如下示： import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; public class Test { public static void main(String[] args) { Calendar cal = Calendar.getInstan...
Calendar使用--> 获取星期几、一周日期的函数， calendar.add(Calendar.DATE, 1);日期加1
04-11 3万+
Calendar使用--> 获取星期几、一周日期的函数 一、获取星期几： private String getWeekDay(Calendar c){    if(c == null){     return "星期一";    }       if(Calendar.MONDAY == c.get(Calendar.DAY_OF_WEEK)){     ret
java calendar.add方法_Java Calendar add()方法与示例
weixin_39662142的博客
02-16 5278
日历类add()方法add()方法在java.util包中可用。add()方法用于对指定的cal_fi(日历字段)执行相加或相减的时间量。add()方法是一个非静态方法，可通过类对象访问，如果尝试使用类名称访问该方法，则会收到错误消息。在给定日历字段添加或减去给定时间时，add()方法不会引发异常。语法：publicabstractvoidadd(intcal_fi,inttime)...
Calendar类使用
忆往昔的博客
08-15 2838
标题Calendar类的成员方法时间单位字段： Calendar类的成员方法 使用默认时区和区域设置获取日历。
java day of month,在Java中的日历对象中添加DAY_OF_MONTH或DAY_OF_YEAR的区别是什么？
weixin_30549779的博客
02-19 430
I want to increase a certain date by 1 day. I create a Calendar object like :Calendar cal = Calendar.getInstance();cal.set(Calendar.YEAR, 2012);cal.set(Calendar.MONTH, 0);cal.set(Calendar.DAY_OF_MONTH...
java的日历类_java 中的Calendar日历类
weixin_42126399的博客
02-21 4979
一、java 中的Calendar日历类解析Calendar类是一个抽象类public abstract class Calendar implements Serializable, Cloneable, Comparable，它为特定时间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(例如获得下星期的日期)提供了一些方法。...
常见对象_Calendar类的add()和set()方法
热门推荐
辐_射的博客
12-10 4万+
package cn.itcast_02; import java.util.Calendar; /* * public void add(int field,int amount):根据给定的日历字段和对应的时间,来对当前的日历进行操作。 * public final void set(int year,int month,int date):设置当前日历的年月日 */ public
Calendar.add方法参数
iPhone11s的博客
02-01 4万+
如果是1则代表的是对年份操作，2是对月份操作，3是对星期操作，5是对日期操作，11是对小时操作，12是对分钟操作，13是对秒操作，14是对毫秒操作。例如：Calendar calendar = Calendar.getInstance(); calendar .add(5,1);则表示对日期进行加一天操作
Java日期工具类使用指南及功能详解
Java中的日期工具类对于处理日期和时间的转换、格式化以及日期的计算等任务至关重要。以下是对Java日期工具类涉及知识点的详细解释： 1. 日期的各种格式化：在Java中，可以使用`java.text.SimpleDateFormat`类进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值