dateUtil日期工具类

已于 2024-07-29 10:50:38 修改
阅读量148 收藏
点赞数 3
文章标签： java
于 2024-07-29 10:49:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43125048/article/details/140765323
版权

日期工具类

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import lombok.extern.slf4j.Slf4j;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author smile.zhao
 * @version 1.0
 * @date 2024/7/25 12:00
 */
@Slf4j
public class ProductDateUtil {

    /**
     * 判断日期是否合法
     *
     * @param dateStr
     * @return
     */
    public static boolean isLegalDate(String dateStr) {
        String format = "yyyy-MM-dd";
        if (ObjectUtil.isEmpty(dateStr)) {
            return false;
        }
        try {
            DateUtil.parse(dateStr, format);
            return true;
        } catch (Exception e) {
            log.error("日期格式错误:", e);
            return false;
        }
    }

    /**
     * 获取前一天日期
     *
     * @param: dateTime 入参是当前时间2020-03-01
     * @return: 返参是前一天的日期, 理应为2020-02-29(闰年)
     */
    public static String getBeforeLastDay(String dateTime) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = simpleDateFormat.parse(dateTime);
        } catch (ParseException e) {
            log.error("String转Date日期失败:", e);
            throw new RuntimeException("String转Date日期失败");
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        //往前一天
        calendar.add(Calendar.DAY_OF_MONTH, -1);
        return simpleDateFormat.format(calendar.getTime());
    }

    /**
     * 获取前一个月的第一天
     *
     * @param dateTime
     * @return
     */
    public static String getBeforeLastMonthStart(String dateTime) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        try {
            c.setTime(simpleDateFormat.parse(dateTime));
        } catch (ParseException e) {
            log.error("String转Date日期失败:", e);
            throw new RuntimeException("String转Date日期失败");
        }
        c.add(Calendar.MONTH, -1);
        return simpleDateFormat.format(c.getTime());
    }

    /**
     * 获取前一个月的最后一天
     *
     * @param dateTime
     * @return
     */
    public static String getBeforeLastMonthEnd(String dateTime) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        try {
            c.setTime(simpleDateFormat.parse(dateTime));
        } catch (ParseException e) {
            log.error("String转Date日期失败:", e);
            throw new RuntimeException("String转Date日期失败");
        }
        c.add(Calendar.MONTH, 0);
        c.set(Calendar.DAY_OF_MONTH, 0);
        return simpleDateFormat.format(c.getTime());
    }

    /**
     * 获取指定时间的对应的周一的日期
     *
     * @param dateTime
     * @return
     */
    public static String getDateOfWeekStart(String dateTime) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date d = null;
        try {
            d = simpleDateFormat.parse(dateTime);
        } catch (ParseException e) {
            log.error("String转Date日期失败:", e);
        }
        Calendar ca = Calendar.getInstance();
        ca.setTime(d);
        int year = ca.get(Calendar.YEAR);
        int mon = ca.get(Calendar.MONTH) + 1;
        int day = ca.get(Calendar.DAY_OF_MONTH);
        LocalDate date = LocalDate.of(year, mon, day);
        while (date.getDayOfWeek() != DayOfWeek.MONDAY) {
            date = date.minusDays(1);
        }
        log.info("本周周一的日期：" + date);
        return date.toString();
    }

    /**
     * 获取今天日期
     *
     * @return
     */
    public static String getTodayDate() {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String format = sdf.format(calendar.getTime());
        return format;
    }

    /**
     * 获取指定时间的周日的日期
     *
     * @param dateTime
     * @return
     */
    public static String getDateOfWeekEnd(String dateTime) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date d = null;
        try {
            d = simpleDateFormat.parse(dateTime);
        } catch (ParseException e) {
            log.error("String转Date日期失败:", e);
        }
        Calendar ca = Calendar.getInstance();
        ca.setTime(d);
        int year = ca.get(Calendar.YEAR);
        int mon = ca.get(Calendar.MONTH) + 1;
        int day = ca.get(Calendar.DAY_OF_MONTH);
        LocalDate date = LocalDate.of(year, mon, day);
        while (date.getDayOfWeek() != DayOfWeek.SUNDAY) {
            date = date.plusDays(1);
        }
        log.info("本周周日的日期：" + date);
        return date.toString();
    }

    /**
     * 获取7天前的日期
     *
     * @return
     */
    public static String getTheDayBeforeSevenDay() {
        Date date = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 在当前日基础上-1
        calendar.add(Calendar.DAY_OF_MONTH, -7);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String format = sdf.format(calendar.getTime());
        return format;
    }

    /**
     * 获取14天前的日期
     *
     * @return
     */
    public static String getTheDayBeforeFourteenDay() {
        Date date = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 在当前日基础上-1
        calendar.add(Calendar.DAY_OF_MONTH, -14);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String format = sdf.format(calendar.getTime());
        return format;
    }

    /**
     * 获取8天前的日期
     *
     * @return
     */
    public static String getTheDayBeforeEightDay() {
        Date date = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 在当前日基础上-1
        calendar.add(Calendar.DAY_OF_MONTH, -8);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String format = sdf.format(calendar.getTime());
        return format;
    }

    /**
     * 获取30天前的日期
     *
     * @return
     */
    public static String getTheDayBeforeThirtyDay() {
        Date date = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 在当前日基础上-1
        calendar.add(Calendar.DAY_OF_MONTH, -30);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String format = sdf.format(calendar.getTime());
        return format;
    }

    /**
     * 获取31天前的日期
     *
     * @return
     */
    public static String getTheDayBeforeThirtyOneDay() {
        Date date = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 在当前日基础上-1
        calendar.add(Calendar.DAY_OF_MONTH, -31);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String format = sdf.format(calendar.getTime());
        return format;
    }

    /**
     * 获取60天前的日期
     *
     * @return
     */
    public static String getTheDayBeforeSixtyDay() {
        Date date = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 在当前日基础上-1
        calendar.add(Calendar.DAY_OF_MONTH, -60);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String format = sdf.format(calendar.getTime());
        return format;
    }

    /**
     * 获取两个日期之间的天数
     *
     * @param startDay
     * @param endDay
     * @return
     */
    public static int getCycleDate(String startDay, String endDay) {
        DateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
        int i = 0;
        try {
            //开始时间
            Date star = dft.parse(startDay);
            //结束时间
            Date end = dft.parse(endDay);
            Date nextDay = star;
            //当明天不在结束时间之前是终止循环
            if (end.before(nextDay)) {
                return -1;
            }
            while (nextDay.before(end)) {
                Calendar cld = Calendar.getInstance();
                cld.setTime(star);
                cld.add(Calendar.DATE, 1);
                star = cld.getTime();
                //获得下一天日期字符串
                nextDay = star;
                i++;
            }
            System.out.println("相差天数为：" + i);
        } catch (ParseException e) {
            log.error("日期转换失败:", e);
            throw new RuntimeException("日期转换失败");
        }
        return i;
    }

    /**
     * 自定义日期上一个周期开始时间
     *
     * @param startDay
     * @param endDay
     * @return
     */
    public static String getCustomStartDay(String startDay, String endDay) {
        int cycleDate = getCycleDate(startDay, endDay);
        if (cycleDate < 0) {
            log.error("日期差范围不合法");
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = sdf.parse(startDay);
        } catch (ParseException e) {
            log.info("日期转换失败:", e);
            throw new RuntimeException("日期转换失败");
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 在当前日基础上-1
        calendar.add(Calendar.DAY_OF_MONTH, -(cycleDate + 1));
        String format = sdf.format(calendar.getTime());
        return format;
    }


    /**
     * 自定义日期上一个周期结束时间
     *
     * @param startDay
     * @param endDay
     * @return
     */
    public static String getCustomEndDay(String startDay, String endDay) {
        int cycleDate = getCycleDate(startDay, endDay);
        if (cycleDate < 0) {
            log.error("日期差范围不合法");
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = sdf.parse(endDay);
        } catch (ParseException e) {
            log.info("日期转换失败:", e);
            throw new RuntimeException("日期转换失败");
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        // 在当前日基础上-1
        calendar.add(Calendar.DAY_OF_MONTH, -(cycleDate + 1));
        String format = sdf.format(calendar.getTime());
        return format;
    }

    /**
     * 获取两个日期之间的日期集合
     *
     * @param startDay
     * @param endDay
     * @return
     */
    public static List<String> getDatesBetweenTwoDates(String startDay, String endDay) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        List<String> datesInRange = new ArrayList<>();
        Calendar calendar = new GregorianCalendar();
        try {
            calendar.setTime(sdf.parse(startDay));
        } catch (ParseException e) {
            log.error("日期转换失败:", e);
        }
        Calendar endCalendar = new GregorianCalendar();
        try {
            endCalendar.setTime(sdf.parse(endDay));
        } catch (ParseException e) {
            log.error("日期转换失败:", e);
            throw new RuntimeException(e);
        }

        while (calendar.before(endCalendar)) {
            Date result = calendar.getTime();
            datesInRange.add(sdf.format(result));
            calendar.add(Calendar.DATE, 1);
        }
        return datesInRange;
    }

    /**
     * 获取上12个月的日期
     *
     * @param month
     * @return
     */
    public static List<String> getPrevious12Months(String month) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        try {
            calendar.setTime(sdf.parse(month));
        } catch (ParseException e) {
            log.error("日期转换失败:", e);
            throw new RuntimeException(e);
        }
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        Date firstDayOfMonth = calendar.getTime();
        month = sdf.format(firstDayOfMonth);
        List<String> previousMonths = new ArrayList<>();
        LocalDate currentDate = LocalDate.parse(month, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        for (int i = 0; i < 12; i++) {
            currentDate = currentDate.minusMonths(1);
            String formattedDate = currentDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
            previousMonths.add(formattedDate);
        }
        if (previousMonths.size() == 12) {
            previousMonths.add(month);
        }
        return previousMonths.stream().sorted().collect(Collectors.toList());
    }


    /**
     * 获取上12周的日期
     * @param startDay
     * @return
     */
    public static List<String> getPrevious12Weeks(String startDay) {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        List<String> previousWeeks = new ArrayList<>();
        try {
            calendar.setTime(sdf.parse(startDay));
        } catch (ParseException e) {
            log.error("日期转换失败:", e);
            throw new RuntimeException("日期转换失败");
        }
        for (int i = 0; i < 12; i++) {
            // 获取本周的周一
            calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
            String start = sdf.format(calendar.getTime());
            previousWeeks.add(start);
            //LocalDate currentDate = LocalDate.parse(start, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
            //LocalDate sunday = currentDate.with(DayOfWeek.SUNDAY);
            //String end = df.format(sunday);
            //System.out.println("本周的周一：" + start + "，本周的周日：" + end);
//            // 获取本周的周日
//            calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
//            String end = sdf.format(calendar.getTime());
//            System.out.println("本周的周一：" + start + "，本周的周日：" + end);
            calendar.add(Calendar.WEEK_OF_YEAR, -1);
        }
        return previousWeeks.stream().sorted().collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<String> previous12Weeks = getPrevious12Weeks("2024-07-16");
        previous12Weeks.forEach(System.out::println);
    }


}
行走的JVM
关注
【项目实战】Hutool 工具包DateUtil类其中的offsetDay()方法介绍
本本本添哥
10-10 2569
需求是取最近30天的数据，需要传入开始时间和结束时间给MySQL进行查询，
Hutool 常用工具类介绍-DateUtil
热门推荐
liuerchong的博客
05-06 1万+
前言 日期格式转化及计算，比较使我们最常用的功能，现就工具类用法归结如下 字符串转日期 DateUtil.parse 方法 DateUtil.parse 方法会自动识别一些常用格式，包括： yyyy-MM-dd HH:mm:ss yyyy/MM/dd HH:mm:ss yyyy.MM.dd HH:mm:ss yyyy年MM月dd日 HH时mm分ss秒 yyyy-MM-dd yyyy/MM/dd yyyy.MM.dd HH:mm:ss HH时mm分ss秒 yyyy-MM-dd HH:mm yyyy-MM-d
cn.hutool.core.date.DateUtil.beginOfDay 方法的作用和使用
罪域之骨终成王
08-07 2380
cn.hutool.core.date.DateUtil.beginOfDay 方法的作用是返回指定日期的开始时间，即将时、分、秒和毫秒部分设置为 0。
Java自定义日期工具类
weixin_42614150的博客
04-28 1066
Java自定义日期工具类
Java学习Hutool工具库中的DateUtil工具类
李长渊的博客
04-09 6029
Java学习Hutool工具库中的DateUtil工具类
Hutool简介和常用类
weixin_41545189的博客
02-22 1466
Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。Hutool中的工具方法来自每个用户的精雕细琢，它涵盖了Java开发底层代码中的方方面面，它既是大型项目开发中解决小问题的利器，也是小型项目中的效率担当；Hutool是项目中“util”包友好的替代，它节省了开发人员对项目中公用类和公用工具方法的封装时间，使开发专注于业务，同时可以最大限度的避免封装不完善带来的bug。DateUtil。
DateUtil日期工具类
09-24
安卓的时间工具类，包括日期格式化，时间戳转化成日期字符串，获取时间，获取年月份，上一个月，下一个月，闰年等等与日期时间相关的工具
掌握Java中的DateUtil日期工具类使用技巧
由于提供的信息较为有限，但从标题、描述以及标签的...同时，对于大型应用，可能会考虑使用成熟的第三方库如Joda-Time、java.time包中的类，或者业务框架内置的日期工具类，以简化开发并提高代码的健壮性和可维护性。
Android开发实战：DateUtil日期工具类详解
"Android开发中的日期工具类DateUtil是一个实用的辅助类，它提供了日期和时间的计算、转换、格式化以及获取等操作。这个工具类对于Android开发者来说，是处理日期时间问题的一个便捷工具。" 在Android开发中，处理...
Hutool工具类用法详解
最新发布
huoshichao的博客
03-03 774
Hutool是一个Java工具类库，旨在简化Java开发中的常见操作。它提供了丰富的工具类和方法，涵盖了字符串处理、日期时间操作、加密解密、文件操作、网络请求等多个方面。Hutool的设计理念是“小而全”，即在不引入过多依赖的情况下，提供尽可能多的功能。StrUtil是Hutool中用于字符串处理的工具类，提供了丰富的字符串操作方法。Hutool是一个功能强大且易于使用的Java工具类库，涵盖了字符串处理、日期时间操作、加密解密、文件操作、网络请求等多个方面。
hutool系列教材 （十）- 常用类辅助工具 - Java 日期工具
Lan_ht的博客
09-15 141
System.out.printf("\t%s的:\t\"%s\" %n\t被转换为----->%n\t%s的 :\t\"%s\" %n%n",type1,value1, type2, value2);System.out.printf("\t基于 %s:\t\"%s\" %n\t获取 %s:\t\"%s\"%n%n",type1,value1, type2, value2);p2("当前如下两个日期",date1 + " " + date2, "相差小时",b4);
【Java】Hutool实战：使用DateUtil格式化时间
科技改变人类，技术成就未来
08-08 1956
Hutool 是一个小而全的 Java 工具包。它提供了许多实用的工具类，极大地简化了 Java 开发中的常见任务。在这篇博客中，我们将重点介绍 Hutool 的 DateUtil 工具类，特别是如何使用它来格式化时间。
DateUtil的方法
LC的博客
01-07 6044
import cn.hutool.core.date.DateUtil; // 时间工具类 import cn.hutool.core.date.DateUnit; // 时间单位（时分秒，年月日） // 后减前 long between = DateUtil.between(order.getLocktime(), new Date(), DateUnit.MINUTE); // 前比后，负数，前面小于后面，0相等，正数 前面大于后面 int compare = DateUtil.compare(goDa
DateUtil(时间工具类)-当前时间
小二丶的博客
11-15 1108
方法描述当前时间，转换为{@link DateTime}对象当前时间，转换为{@link DateTime}对象，忽略毫秒部分当前时间的时间戳当前时间的时间戳（秒）当前时间，格式 yyyy-MM-dd HH:mm:ss当前日期，格式 yyyy-MM-dd。
Hutool-Java工具库
Leslie_Lei的博客
11-12 2347
Hutool-Java工具库中常用的工具类等
基于hutool编写时间帮助类，根据年份获取全年时间，获取指定月份所有日期，获取指定月份所有日期，获取最近几天的时间List
xcc1974494的博客
04-12 2839
【代码】基于hutool编写时间帮助类，根据年份获取全年时间，获取指定月份所有日期，获取指定月份所有日期，获取最近几天的时间List。
hutool计算两个日期间 的所有的日期
tower888的专栏
06-14 8918
package com.soft.util; import cn.hutool.core.date.DateField; import cn.hutool.core.date.DatePattern; import cn.hutool.core.date.DateTime; import cn.hutool.core.date.DateUtil; import java.util.ArrayList; import java.util.Date; import java.util.List; pub.
Hutool 入门第二步：深入使用核心功能
SAFE20242034的博客
02-03 488
大大简化了常见操作，比如文件读写、字符串处理、HTTP 请求、加密解密等。掌握了这些工具类，能让你的 Java 开发更加高效、简洁。提供了非常简单的 API，用于发送 HTTP 请求，并获取响应内容。你可以通过它快速进行 GET、POST 请求等操作。提供了对常见加密算法的支持，常用于数据保护和信息安全。中，我们了解了 Hutool 的基本用法，现在。你可以根据需要引入合适的模块，也可以直接引入。，帮助你提高 Java 开发效率。的常用操作，方便你进行集合处理。提供强大的字符串操作能力。
时间工具类(自用)
u010012932的博客
05-31 710
public static final DateTimeFormatter DATE_FORMAT_MM_DD = DateTimeFormatter.ofPattern(“MM月dd日”);@description：时间工具类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值