超级全的日期时间工具类DateUtils

最新推荐文章于 2025-05-12 20:20:26 发布
原创 最新推荐文章于 2025-05-12 20:20:26 发布 · 525 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

这是一个Java时间操作工具类，包含获取当前时间、日期转换、时间戳转换、日期区间计算、时间格式化等功能，支持处理本周、本月、昨天等特定时间范围的起始和结束时间。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package com.nuiiqk.common.util;
import java.lang.management.ManagementFactory;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 时间的操作的工具类
 *
 * @author NuiiQK
 * @date 2020/12/24 024
 */
public class DateUtils {

    public static final String STARTTIME = " 00:00:00";
    public static final String ENDTIME = " 23:59:59";
    public final static String FORMAT_STRING = "yyyy-MM-dd HH:mm:ss";
    public final static String[] REPLACE_STRING = new String[] {"GMT+0800", "GMT+08:00"};
    public final static String SPLIT_STRING = "(中国标准时间)";
    // 日志输出器
    public static Logger log = LoggerFactory.getLogger(DateUtils.class);

    public static String YYYY = "yyyy";

    public static String YYYY_MM = "yyyy-MM";

    public static String YYYY_MM_DD = "yyyy-MM-dd";

    public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

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

    private final static String in_formate_s = "yyyy-MM-dd";

    private final static String in2_formate_s = "yyyy-MM-dd HH:mm:ss";

    private final static String out_formate_s = "MM/dd/yyyy";

    private final static String out3_formate_s = "MM/dd/yyyy HH:mm:ss";

    private static String[] parsePatterns =
            {"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM", "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss",
                    "yyyy/MM/dd HH:mm", "yyyy/MM", "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};

    private DateUtils() {}

    /**
     * 获取今天开始的时间
     *
     * @return
     * @author NuiiQK
     *         2018年5月8日 上午9:40:53
     */
    public static String getToDayStartTime() {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        Date date = new Date(System.currentTimeMillis());
        return formate.format(date);
    }

    /**
     * 获取今天结束的时间
     *
     * @return
     * @author NuiiQK
     *         2018年6月12日
     */
    public static String getToDayEndTime() {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        Date date = new Date(System.currentTimeMillis());
        return formate.format(date);
    }

    /**
     * 获取昨天开始的时间
     *
     * @return
     * @author NuiiQK
     *         2018年6月11日
     */
    public static String getYestodayStartTime() {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        Date date = new Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L);
        return formate.format(date);
    }

    /**
     * 获取昨天结束的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月11日
     */
    public static String getYestodayEndTime() {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        Date date = new Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L);
        return formate.format(date);
    }

    /**
     * 获取某天开始的时间
     *
     * @return
     * @author NuiiQK
     *         2019年6月20日09:39:25
     */
    public static String getOneDayStartTime(String oneDay) {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        Date date = new Date(oneDay);
        return formate.format(date);
    }

    public static String getOneDayStartTime(Date oneDay) {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        return formate.format(oneDay);
    }

    /**
     * 获取某天结束的时间
     *
     * @return
     * @author NuiiQK
     *         2019年6月20日09:42:16
     */
    public static String getOneDayEndTime(String oneDay) {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        Date date = new Date(oneDay);
        return formate.format(date);
    }

    public static String getOneDayEndTime(Date oneDay) {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        return formate.format(oneDay);
    }

    /**
     * 获取本周开始的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static Date getWeekStartTime() {
        // 获得本周一0点时间
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        return cal.getTime();
    }

    /**
     * 将 String 转换成 date
     *
     * @param dateTime
     * @return
     * @author NuiiQK
     * @date 2018年6月19日
     */
    public static Date strToDateTime(String dateTime) {
        Date date = null;
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            date = format.parse(dateTime);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 将 date 转换成 时间戳
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月26日
     */
    public static Long dateToStamp(String s) throws ParseException {

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = simpleDateFormat.parse(s);
        long ts = date.getTime();
        return ts;
    }

    /**
     * Date 转换成 String
     *
     * @param dateTime
     * @return
     * @author NuiiQK
     * @date 2018年6月19日
     */
    public static String dateTimeToStr(Date dateTime) {

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

    /**
     * 获取本周开始的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getWeekStartTimeStr() {
        // 获得本周一0点时间
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        return formate.format(cal.getTime());
    }

    /**
     * 获取本周结束的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static Date getWeekEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getWeekStartTime());
        cal.add(Calendar.DAY_OF_WEEK, 7);
        return cal.getTime();
    }

    /**
     * 获取本周结束的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getWeekEndTimeStr() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getWeekStartTime());
        cal.add(Calendar.DAY_OF_WEEK, 7);
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        return formate.format(cal.getTime());
    }

    /**
     * 获取上周开始的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getLastWeekStartTimeStr() {
        int weeks = -1;
        int mondayPlus = getMondayPlus();
        GregorianCalendar currentDate = new GregorianCalendar();
        currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks);
        Date monday = currentDate.getTime();
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        return formate.format(monday);
    }

    /**
     * 获取本月开始的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static Date getMonthStartTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(Calendar.DAY_OF_MONTH));
        return cal.getTime();
    }

    /**
     * 获取本月开始的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getMonthStartTimeStr() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(Calendar.DAY_OF_MONTH));
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        return formate.format(cal.getTime());
    }

    /**
     * 获取本月结束的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static Date getMonthEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 24);
        return cal.getTime();
    }

    /**
     * 获取本月结束的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getMonthEndTimeStr() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 24);
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        return formate.format(cal.getTime());
    }

    /**
     * 获取当月的 天数
     */
    public static int getCurrentMonthDay() {
        Calendar a = Calendar.getInstance();
        a.set(Calendar.DATE, 1);
        a.roll(Calendar.DATE, -1);
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }

    /**
     * 得到二个日期间的间隔天数
     */
    public static int getDayByTwoDay(String sj1, String sj2) {
        SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
        Long day = 0L;
        try {
            Date date = myFormatter.parse(sj1);
            Date mydate = myFormatter.parse(sj2);
            day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
        } catch (Exception e) {
            return 0;
        }
        return day.intValue();
    }

    /**
     * 得到两个日期相差的秒数
     *
     * @param lastDate
     * @param date
     * @return
     */
    public static int getSecondByTwoDay(Date lastDate, Date date) {
        Long second = 0L;
        try {
            second = (lastDate.getTime() - date.getTime()) / 1000;
        } catch (Exception e) {
            return 0;
        }
        return second.intValue();
    }

    /**
     * 判断某个日期属于本周的第几天 (星期一代表第一天)
     *
     * @param dateTime
     * @return
     * @throws ParseException
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static int getDaysByWeek(String dateTime) throws ParseException {
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = dateFormat.parse(dateTime);
        cal.setTime(date);
        int day = cal.get(Calendar.DAY_OF_WEEK);
        day = day - 1;
        if (day == 0) {
            day = 7;
        }
        return day;
    }

    /**
     * 判断某个日期属于本月的第几天
     *
     * @param dateTime
     * @return
     * @throws ParseException
     * @author NuiiQK
     * @date 2018年6月14日
     */
    public static int getDaysByMonth(String dateTime) throws ParseException {
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = dateFormat.parse(dateTime);
        cal.setTime(date);
        int day = cal.get(Calendar.DAY_OF_MONTH);
        return day;
    }

    /**
     * 根据年 月 获取对应的月份 天数
     */
    public static int getDaysByYearMonth(int year, int month) {

        Calendar a = Calendar.getInstance();
        a.set(Calendar.YEAR, year);
        a.set(Calendar.MONTH, month - 1);
        a.set(Calendar.DATE, 1);
        a.roll(Calendar.DATE, -1);
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }

    /**
     * 获取当前的年
     *
     * @return
     * @author NuiiQK
     *         2018年5月8日 上午9:36:12
     */
    public static Integer getYears() {
        Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
        return calendar.get(Calendar.YEAR);

    }

    /**
     * 获取当前的月
     *
     * @return
     * @author NuiiQK
     *         2018年5月8日 上午9:37:37
     */
    public static Integer getMonth() {
        Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
        return calendar.get(Calendar.MONTH) + 1;

    }

    /**
     * 获取当前天
     *
     * @return
     * @author NuiiQK
     *         2018年5月8日 上午10:31:37
     */
    public static Integer getDay() {
        Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
        return calendar.get(Calendar.DAY_OF_MONTH);
    }

    /**
     * wx支付的过期时间
     *
     * @param hour
     * @return
     */
    @SuppressWarnings("unused")
    public static String getTime(double hour) {
        Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
        long time = (long)(System.currentTimeMillis() + hour * 60 * 60 * 1000L);
        Date date = new Date(time);
        SimpleDateFormat formate = new SimpleDateFormat("yyyyMMddHHmmss");
        String format = formate.format(date);
        return format;
    }

    // 获得当前日期与本周日相差的天数
    private static int getMondayPlus() {
        Calendar cd = Calendar.getInstance();
        // 获得今天是一周的第几天，星期日是第一天，星期二是第二天......
        int dayOfWeek = cd.get(Calendar.DAY_OF_WEEK) - 1; // 因为按中国礼拜一作为第一天所以这里减1
        if (dayOfWeek == 1) {
            return 0;
        } else {
            return 1 - dayOfWeek;
        }
    }

    /**
     * 获取几天之后的日期（wq）
     *
     * @param date yyyy-MM-dd HH:mm:ss
     * @param day 加减的天数
     * @return
     */
    public static Date getDate(String date, int day) {

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

        Calendar cal = Calendar.getInstance();
        try {
            Date beforeDate = formate.parse(date);
            cal.setTime(beforeDate);
            cal.add(Calendar.DAY_OF_MONTH, day);
            // cal.set(beforeDate.getYear(), beforeDate.getMonth(), beforeDate.getDay()+day,
            // beforeDate.getHours(),beforeDate.getSeconds(), beforeDate.getMinutes());
            Date newDate = cal.getTime();
            return newDate;
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 把date转换成字符串
     *
     * @param date
     * @param code 例如 yyyy-MM-dd 00:00:00
     * @return
     */
    public static String formateDate(Date date, String code) {
        SimpleDateFormat formate = new SimpleDateFormat(code);
        return formate.format(date);

    }

    /**
     * 获取过去N天内的日期数组
     *
     * @param intervals intervals天内
     * @param formatStr 格式化字符串 yyyy-MM-dd
     * @return 日期数组
     */
    public static ArrayList<String> getDaysByN(int intervals, String formatStr) {
        ArrayList<String> pastDaysList = new ArrayList<>();
        for (int i = intervals - 1; i >= 0; i--) {
            pastDaysList.add(getPastDate(i, formatStr));
        }
        return pastDaysList;
    }

    /**
     * 获取过去第几天的日期
     *
     * @param past
     * @return
     */
    public static String getPastDate(int past, String formatStr) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - past);
        Date today = calendar.getTime();
        SimpleDateFormat format = new SimpleDateFormat(formatStr);
        String result = format.format(today);
        return result;
    }

    /**
     * 获取某个时间段内所有日期
     *
     * @param begin
     * @param end
     * @return
     */
    public static List<String> getDayBetweenDates(String begin, String end) {
        Date dBegin = strToDateTime(begin);
        Date dEnd = strToDateTime(end);
        List<String> lDate = new ArrayList<>();
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
        lDate.add(sd.format(dBegin));
        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(dBegin);
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calEnd.setTime(dEnd);
        // 测试此日期是否在指定日期之后
        while (dEnd.after(calBegin.getTime())) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            calBegin.add(Calendar.DAY_OF_MONTH, 1);
            lDate.add(sd.format(calBegin.getTime()));
        }
        return lDate;
    }

    /**
     * 获取服务器启动时间
     */
    public static Date getServerStartDate() {
        long time = ManagementFactory.getRuntimeMXBean().getStartTime();
        return new Date(time);
    }

    /**
     * 计算两个时间差
     */
    public static String getDatePoor(Date endDate, Date nowDate) {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时" + min + "分钟";
    }

    /**
     * "yyyy-MM-dd" to "MM/dd/yyyy";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return "";
        }
        return new SimpleDateFormat(out_formate_s).format(new SimpleDateFormat(in_formate_s).parse(inDate));
    }

    /**
     * "MM/dd/yyyy"; to "yyyy-MM-dd"
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange2(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return "";
        }

        return new SimpleDateFormat(in_formate_s).format(new SimpleDateFormat(out_formate_s).parse(inDate));
    }

    /**
     * "MM/dd/yyyy HH:mm:ss"; to "yyyy-MM-dd HH:mm:ss";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange3(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return "";
        }

        return new SimpleDateFormat(in2_formate_s).format(new SimpleDateFormat(out3_formate_s).parse(inDate));
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"; to "MM/dd/yyyy HH:mm:ss";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange4(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return "";
        }

        return new SimpleDateFormat(in2_formate_s).format(new SimpleDateFormat(out3_formate_s).parse(inDate));
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"; to "Data";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static Date dateChange1(String inDate) throws ParseException {
        return new SimpleDateFormat(in2_formate_s).parse(inDate);
    }

    /**
     * "Data"; to "yyyy-MM-dd HH:mm:ss";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange(Date inDate) throws ParseException {
        if (inDate == null) {
            return "";
        }
        return new SimpleDateFormat(in2_formate_s).format(inDate);
    }

    /**
     * "Data"; to "yyyy-MM-dd";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange5(Date inDate) throws ParseException {
        if (inDate == null) {
            return "";
        }
        return new SimpleDateFormat(in_formate_s).format(inDate);
    }

    /**
     * "yyyy/MM/dd"; to "Data";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static Date dateChange6(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return null;
        }
        return new SimpleDateFormat(out_formate_s).parse(inDate);
    }

    /**
     * "yyyy-MM-dd"; to "Data";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static Date dateChange7(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return null;
        }
        return new SimpleDateFormat(in_formate_s).parse(inDate);
    }

    /*    *//**
     * "MM/dd/yyyy" to "yyyy-MM-dd"
     *
     * @param inDate
     * @return
     * @throws ParseException
     *//*
                       public static String dateChange4(String inDate) throws ParseException {
                        if(StringUtils.isBlank(inDate)) return "";

                        return in_formate.format(out_formate_s.parse(inDate));
                       }*/

    /**
     * 将字符串的时间按照format格式转换为date
     *
     * @param inDate
     * @param format
     * @return
     * @throws ParseException
     */
    public static Date stringToDate(String inDate, String format) throws ParseException {
        // TODO Auto-generated method stub
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return null;
        }
        return new SimpleDateFormat(format).parse(inDate);
    }

    /**
     * 将date按照format格式转换为String
     *
     * @param inDate
     * @param format
     * @return
     * @throws ParseException
     */
    public static String dateToString(Date inDate, String format) throws ParseException {
        // TODO Auto-generated method stub
        if (inDate == null) {
            return "";
        }
        return new SimpleDateFormat(format).format(inDate);
    }

    /**
     * 将数据库查出来的时间多.0的string时间去掉.0
     *
     * @param time
     * @return
     */
    public static String normTime(String time) {
        if (StringUtils.isEmpty(time)) {
            return "";
        }
        int index = time.indexOf(".0");
        if (index >= 0) {
            time = time.substring(0, index);
        }
        return time;
    }

    /**
     * 判断当前日期是否在期间内
     *
     * @param deadLine 格式: 2018-04-01|2018-06-30
     * @return
     */
    public static boolean isDeadLine(String deadLine) {
        boolean result = false;

        String start = deadLine.substring(0, deadLine.indexOf("|"));
        String end = deadLine.substring(deadLine.indexOf("|") + 1);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date startDate = sdf.parse(start);
            Date endDate = sdf.parse(end);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(endDate);
            calendar.add(Calendar.DAY_OF_YEAR, 1);
            endDate = calendar.getTime();
            Date now = new Date();
            if (now.after(startDate) && now.before(endDate)) {
                result = true;
            }

        } catch (Exception e) {
            log.info("Exception ", e);
        }
        return result;
    }

    /**
     * 获取上海时区的当前日期时间
     *
     * @return yyyy-MM-dd HH:mm:ss
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getNowDateTime() {
        return getNowDateTimeFormatter("yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 获取上海时区的昨天的日期时间
     *
     * @return yyyy-MM-dd HH:mm:ss
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getYesterdayDateTime() {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        return LocalDateTime.now(ZoneId.of("Asia/Shanghai")).minusDays(1).format(formatter);
    }

    /**
     * 获取上海时区的昨天的日期
     *
     * @return yyyy-MM-dd
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getYesterdayDate() {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        return LocalDate.now(ZoneId.of("Asia/Shanghai")).minusDays(1).format(formatter);
    }

    /**
     * 获取上海时区的当前日期
     *
     * @return yyyy-MM-dd
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getNowDate() {
        return getNowDateTimeFormatter("yyyy-MM-dd");
    }

    /**
     * yyyy-MM-dd HH:mm:ss格式时间字符串转换为yyyy-MM-dd格式
     *
     * @return
     * @author NuiiQK
     * @date 2019-11-08
     */
    public static String dateTimeTODate(String timeStr) {
        return getDateTimeToFormatter(timeStr, "yyyy-MM-dd");
    }

    /**
     * 获取上海时区的当前年
     *
     * @return yyyy-MM-dd
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static int getNowYear() {
        return LocalDate.now(ZoneId.of("Asia/Shanghai")).getYear();
    }

    /**
     * 获取上海时区的当前日期的日
     *
     * @return yyyy-MM-dd
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static int getNowDayOfMonth() {
        return LocalDateTime.now(ZoneId.of("Asia/Shanghai")).getDayOfMonth();
    }

    /**
     * 获取上海时区的当前星期
     *
     * @return
     * @author NuiiQK
     * @date 2019-11-08
     */
    public static int getNowDayOfWeek() {
        return LocalDate.now(ZoneId.of("Asia/Shanghai")).getDayOfWeek().getValue();
    }

    /**
     * 获取上海时区的当前时间
     *
     * @return HH:mm:ss
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getNowTime() {
        return getNowDateTimeFormatter("HH:mm:ss");
    }

    /**
     * 获取上海时区的当前小时
     *
     * @return HH:mm:ss
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static int getNowHour() {
        return LocalDateTime.now(ZoneId.of("Asia/Shanghai")).getHour();
    }

    /**
     * 获取当天的毫秒秒时间值
     *
     * @return
     * @author NuiiQK
     * @date 2019-09-09
     */
    public static String getMicroTimestamp() {
        return String.valueOf(LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli());
    }

    /**
     * 获取当天的秒时间值
     *
     * @return
     * @author NuiiQK
     * @date 2019-09-09
     */
    public static String getTimestamp() {
        return String.valueOf(LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8")));
    }

    /**
     * 指定格式化当前时间
     *
     * @param pattern
     * @return
     * @author NuiiQK
     * @date 2019-09-10
     */
    public static String getNowDateTimeFormatter(String pattern) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return LocalDateTime.now(ZoneId.of("Asia/Shanghai")).format(formatter);
    }

    /**
     * yyyy-MM-dd HH:mm:ss格式日期时间字符串转换指定格式时间字符串
     *
     * @param timeStr
     * @param pattern
     * @return
     * @author NuiiQK
     * @date 2019-10-25
     */
    public static String getDateTimeToFormatter(String timeStr, String pattern) {
        if (StringUtils.isEmpty(timeStr)) {
            return "";
        }
        LocalDateTime time = LocalDateTime.parse(timeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return time.format(formatter);
    }

    /**
     * yyyy-MM-dd格式日期字符串转换指定格式日期字符串
     *
     * @param timeStr
     * @param pattern
     * @return
     * @author NuiiQK
     * @date 2019-10-25
     */
    public static String getDateToFormatter(String timeStr, String pattern) {
        if (StringUtils.isEmpty(timeStr)) {
            return "";
        }
        LocalDate time = LocalDate.parse(timeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return time.format(formatter);
    }

    /**
     * HH:mm:ss格式时间字符串转换指定格式时间字符串
     *
     * @param timeStr
     * @param pattern
     * @return
     * @author NuiiQK
     * @date 2019-10-25
     */
    public static String getTimeToFormatter(String timeStr, String pattern) {
        if (StringUtils.isEmpty(timeStr)) {
            return "";
        }
        LocalTime time = LocalTime.parse(timeStr, DateTimeFormatter.ofPattern("HH:mm:ss"));
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return time.format(formatter);
    }

    /**
     * 以当前时间生成yyyyMMddHHmmssSSS格式的编号
     *
     * @return
     * @author NuiiQK
     * @date 2019-09-10
     */
    public static String getDateTimeCode() {
        return getNowDateTimeFormatter("yyyyMMddHHmmssSSS");
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串转换为LocalDateTime对象
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static LocalDateTime parseDateTime(String timeStr) {
        return LocalDateTime.parse(timeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * "yyyy-MM-dd"格式时间字符串转换为LocalDate对象
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static LocalDate parseDate(String timeStr) {
        return LocalDate.parse(timeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }

    /**
     * "HH:mm:ss"格式时间字符串转换为LocalTime对象
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static LocalTime parseTime(String timeStr) {
        return LocalTime.parse(timeStr, DateTimeFormatter.ofPattern("HH:mm:ss"));
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串是否在当前时间之后
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeAfterNow(String timeStr) {
        return parseDateTime(timeStr).isAfter(LocalDateTime.now());
    }

    /**
     * "yyyy-MM-dd"格式时间字符串是否在当前时间之后
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateAfterNow(String timeStr) {
        return parseDate(timeStr).isAfter(LocalDate.now());
    }

    /**
     * "HH:mm:ss"格式时间字符串是否在当前时间之后
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean timeAfterNow(String timeStr) {
        return parseTime(timeStr).isAfter(LocalTime.now());
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串是否在当前时间之前
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeBeforeNow(String timeStr) {
        return parseDateTime(timeStr).isBefore(LocalDateTime.now());
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串是否在当前时间之前
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateBeforeNow(String timeStr) {
        return parseDate(timeStr).isBefore(LocalDate.now());
    }

    /**
     * "HH:mm:ss"格式时间字符串是否在当前时间之前
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean timeBeforeNow(String timeStr) {
        return parseTime(timeStr).isBefore(LocalTime.now());
    }

    /**
     * 某日期时间是否在另一日期时间之后
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeAfterDateTime(String t1, String t2) {
        return parseDateTime(t1).isAfter(parseDateTime(t2));
    }

    /**
     * 某日期是否在另一日期之后
     * "yyyy-MM-dd"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateAfterDate(String t1, String t2) {
        return parseDate(t1).isAfter(parseDate(t2));
    }

    /**
     * 某时间是否在另一时间之后
     * "HH:mm:ss"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean timeAfterTime(String t1, String t2) {
        return parseTime(t1).isAfter(parseTime(t2));
    }

    /**
     * 某日期时间是否在另一日期时间之前
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeBeforeDateTime(String t1, String t2) {
        return parseDateTime(t1).isBefore(parseDateTime(t2));
    }

    /**
     * 某日期是否在另一日期之前
     * "yyyy-MM-dd"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateBeforeDate(String t1, String t2) {
        return parseDate(t1).isBefore(parseDate(t2));
    }

    /**
     * 某时间是否在另一时间之前
     * "HH:mm:ss"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean timeBeforeTime(String t1, String t2) {
        return parseTime(t1).isBefore(parseTime(t2));
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串是否在当天之后包括当天
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeAfterNowDate(String timeStr) {
        return parseDateTime(timeStr).toLocalDate().isAfter(LocalDate.now().plusDays(-1));
    }

    /**
     * 计算两个时间的差"yyyy-MM-dd HH:mm:ss"格式字符串
     *
     * @param unit
     * @return
     * @author NuiiQK
     * @date 2019-11-12
     */
    public static long differ(String startStr, String endStr, TimeUnit unit) throws Exception {
        LocalDateTime start = parseDateTime(startStr);
        LocalDateTime end = parseDateTime(endStr);
        Duration duration = Duration.between(start, end);
        long res;
        if (TimeUnit.DAYS == unit) {
            // 相差的天数
            res = duration.toDays();
        } else if (TimeUnit.HOURS == unit) {
            // 相差的小时数
            res = duration.toHours();
        } else if (TimeUnit.MINUTES == unit) {
            // 相差的分钟数
            res = duration.toMinutes();
        } else if (TimeUnit.MILLISECONDS == unit) {
            // 相差毫秒数
            res = duration.toMillis();
        } else if (TimeUnit.NANOSECONDS == unit) {
            // 相差的纳秒数
            res = duration.toNanos();
        } else {
            throw new Exception("unsupport unit: " + unit);
        }
        return res;
    }
}
超级实用的Java工具类
阿杰同学的博客
10-09 470
字符串工具类 首先介绍一下commons-lang3的一个字符串工具类StringUtils，常用方法如下： 1、isEmpty() 判断字符串是否为空。 2、isBlank() 判断字符串是否为空，如果字符串都是空格，也认为是空。 public class StringUtilsTest { public static void main(String[] args) { String str = " "; System.out.println(Strin
帝可得管理系统发
娜的博客
07-21 1564
提示（Prompt）是我们对大模型提出的问题。举一个最简单的例子，很多同学在第一次使用AI时，都会问AI"你是谁"，"你是谁"这个问题便是prompt。提示工程（Prompt Engineering）也被称为上下文提示，它涉及到设计和优化输入文本，也就是Prompt，来引导AI模型生成预期的输出。简单来说，就像是给AI出一个好问题，让它给我们一个满意的答案。
TimeFormatter:日期和时间的字符串
05-01
时间格式化器 日期和时间的字符串
time-formater 时间格式化插件
达拉崩巴斑得贝迪卜多比鲁翁_
09-18 447
time-formater 不是 time-format[t]er English 在javascript中显示日期。 使用方法 下载 npm i -S time-formater let rawDate = time().format('YYYY-MM-DD HH:mm:ss') // 当前时间 console.log(rawDate) // 2020-12-28 15:19:3...
一文看懂Java时间工具类:Date,SimpleDateFormat,Calendar
最新发布
aa_hdkf_vg的博客
05-12 898
在 Java 开发中，时间处理是一项非常常见且重要的任务。无论是记录系统日志的时间戳、处理用户订单的时间信息，还是实现定时任务，都离不开对时间的操作。Java 提供了`Date`、`SimpleDateFormat`、`Calendar`等一系列时间工具类，它们各有特点和适用场景。本文将深入剖析这些时间工具类的用法，结合丰富的实际案例，帮助你全面掌握 Java 中的时间处理技巧。
《JavaScript插件》时间格式化工具time-formater的详解
Oliver尹的博客
02-13 1657
这是一个时间格式化工具，虽然有点小众，但感觉还是有点好用的
time-formatter-js：js时间类型格式化工具库（兼容的IE）：自定义时间格式，时间排序，间隔天数，前n天的日期。
02-21
时间格式js 一个简单易用的js时间类型格式化工具库（兼容IE）大小：4KB 例子： //引入timeFormatter.js //使用方式非常简单，创建一个timeFormatter实例，传入的对象可省略 var timeFormatter = new TimeFormatter({ isAddPrefixZero: true,//是否给时间增加前缀0，默认为true }); timeFormatter.getDateStr('yyyy-mm-dd hh:MM:ss:S D ap q')// "2021-02-20 23:17:44:726 星期六 下午 Spring". 默认格式yyyy-mm-dd hh:MM:ss 方法（API）： getDateStr 根据时间格式对时间进行转换，返回一个时间字符串 getDateStr（format, date） format： 对应
time_formatter(xctf)
weixin_43868725的博客
08-08 402
0x0 程序保护和流程 保护： 流程： main() 选择1可以设置时间格式，选择2可以设置时间，选择3可以设置时区，选择4可以打印时间，选择5可以退出程序。 可以看到再选择4的时候使用了snprintf函数构造了一个命令字符串，然后再交由system函数执行相应的命令。 ptr在选择1中被赋值。 并且ptr所指向的内存空间中的字符串不能含有除**%aAbBcCdDeFgGhHIjklmNnNpPrRsStTuUVwWxXyYzZ:-_/0^#** 之外的字符。 最后进入选择5。 发现程序在退出
java日期时间工具类超级全
07-23
java日期时间工具类超级全。其中包含：获得当前日期 yyyy-MM-dd HH:mm:ss；获取系统当前时间戳；获取当前日期 yy-MM-dd；得到两个时间差 格式yyyy-MM-dd HH:mm:ss；转化long值的日期为yyyy-MM-dd HH:mm:ss.SSS格式的...
TypeScript语法总结-看这篇就够
米糊hia的博客
10-15 1023
融合了后端面向对象思想的超级版的JavaScript语言。​ TypeScript是JavaScript的超集，扩展了JavaScript的语法。特点：（1） TypeScript: 【静态类型检查器】 可在编译时检查错误（2） TypeScript为JS的超集（3） TS === JS + 【类型】 js有的ts都有（4） TS 规范了 JS类型声明 使之更加严谨TypeScript本质就是带有类型检查的JavaScript。
Java Poi 在Excel中输出特殊符号
浮生的博客
07-16 4198
最近的工作围绕报表导出，并没有集成相应的报表插件，只是使用了Poi。其中有一个需求，Excel中导出特殊符号，如√、×等。在网上找寻了许久，没有相关资料，故记录分享一下。 思考良久，走了不少弯路，最后受 System.out.println() 启发，实现方式真的超级简单。每一个特殊符号，都对应一个Unicode编码，我们只需要将特定的符号，转变成Unicode编码，进行输出即可。 相应的代码输出： cell.setCellValue("\u221A"); 另附自己编写的Excel工具类，支持单表、主
时间工具类
Jusenr的博客
08-03 930
-–关于时间格式、获取、处理的封装。。。**DateFormat.java**package com.putao.wd.paibot.wallet;import java.text.ParseException; import java.text.ParsePosition; import java.text.SimpleDateFormat; import java.util.Calendar;
系统状态监控
weixin_42502300的博客
04-28 420
1、pom文件 <!-- 获取系统信息 --> <dependency> <groupId>com.github.oshi</groupId> <artifactId>oshi-core</artifactId> <version>3.9.1</version> </dependency> <dependency> <groupId>org
Java日期工具类DateUtils详解与实例
- `DATE_FORMAT_FULL`：全格式日期时间，"yyyy-MM-dd HH:mm:ss" - `DATE_FORMAT_YMD`：年月日格式，"yyyy-MM-dd" - `DATE_FORMAT_HMS`：时分秒格式，"HH:mm:ss" - `DATE_FORMAT_HM`：时分格式，"HH:mm" - `DATE_...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值