枚举型时间工具类，时间字符串自动处理，获取最后一天，调整年、月、天和时、分、秒。

已于 2022-10-10 14:43:36 修改
阅读量249 收藏
点赞数
分类专栏： 笔记 工具 文章标签： java jvm
于 2022-09-29 16:25:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adions0819/article/details/127107582
版权

枚举类型的日期工具类

优点就是通过枚举型，见明知意的了解输入时间类型与最终转换的字符串格式。

        //对已知类型时间字符串进行转义
        Date date = null;
        try {
            date = DateTimeUtils.DATE.parseDate("2022-03-03");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(DateTimeUtils.DATE_CHINESE.formatDate(date));
        
        //对未知类型时间字符串自动获取时间枚举工具类
        DateTimeUtils dateTimeUtils =  DateTimeUtils.getDateTimeUtil("2022年01月");
        String formatDate = dateTimeUtils.formatDate(new Date());
        System.out.println(formatDate);
        
        
        //获取时间月、周第一天或着最后一天  等
        final Date weekendOfmonday = DateTimeUtils.getWeekendFirstDayOfMonday(date);
        final Date weekendOfSunday = DateTimeUtils.getWeekendFirstDayOfMonday(date);
        final Date weekendOfmonday1 = DateTimeUtils.getWeekendFirstDayOfMonday("2022-03-03");
        final Date weekendOfSunday1 = DateTimeUtils.getWeekendFirstDayOfSunday("2022-03-03");
        final String monday = DateTimeUtils.DATE.formatDate(weekendOfmonday);
        final String sunday = DateTimeUtils.DATE.formatDate(weekendOfSunday);
        final String monday1 = DateTimeUtils.DATE.formatDate(weekendOfmonday1);
        final String sunday1 = DateTimeUtils.DATE.formatDate(weekendOfSunday1);
        System.out.println(monday);
        System.out.println(sunday);
        System.out.println(monday1);
        System.out.println(sunday1);
        
        //增加天/月/年
        System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setYearDate(1)));
        System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setYearDate(1,weekendOfmonday)));
        System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setMonthDate(1)));
        System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setMonthDate(1,weekendOfSunday)));
        System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setDayDate(1)));
        System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setDayDate(1,weekendOfmonday1)));
        System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setDate(1,2,3,new Date())));
               System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setDate(0,0,-3,new Date())));
        
        //增加时/分/秒
        System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setTime(1,0,3,weekendOfSunday1)));
        System.out.println(DateTimeUtils.DATE.formatDate(DateTimeUtils.setTime(-1,0,0,weekendOfSunday1)));

源码如下：


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalQuery;
import java.util.Calendar;
import java.util.Date;

/**
 * 
 * @date 2022年9月29日
 * @Description 枚举类型时间工具类
 * 
 * 
 **/
public enum DateTimeUtils {

    /**
     * 日期格式 <code>[yyyy-MM-dd]</code>
     **/
    YEAR("yyyy", 4), 
    MONTH("MM", 2), 
    DATE("yyyy-MM-dd", 10), 
    DATE_FOR_EXCEL("yyyy.MM.dd", 10),
    DATE_SLASH("yyyy/MM/dd", 10), 
    DATE_MONTH_FOR_EXCEL("yyyy-MM", 7), 
    DATE_MONTH_SLASH_FOR_EXCEL("yyyy/MM", 7),
    TIME("HH:mm:ss", 8), 
    DATE_TIME("yyyy-MM-dd HH:mm:ss", 19), 
    DATE_TIME_FOR_EXCEL("yyyy.MM.dd HH:mm:ss", 19),

    YEAR_CHINESE("yyyy年", 5), 
    MONTH_CHINESE("MM月", 3), 
    DATE_MONTH_CHINESE("yyyy年MM月", 8),
    DATE_CHINESE("yyyy年MM月dd日", 11), 
    DATE_TIME_CHINESE("yyyy年MM月dd日 HH时mm分ss秒", 21);

    private final DateTimeFormatter formatter;

    String pattern;
    int len;

    DateTimeUtils(String pattern, int len) {
        this.pattern = pattern;
        this.len = len;
        this.formatter = DateTimeFormatter.ofPattern(pattern).withZone(ZoneId.systemDefault());
    }

    
    /**
     * 获取现在时
     *
     * @return
     */
    public String now() {
        return formatter.format(Instant.now());
    }

    /**
     * 转换成时间字符串
     */
    public String formatDate(Date date) {
        return date != null ? formatter.format(date.toInstant()) : "";
    }

    public String formatIimestamp(long epochMilli) {
        return formatter.format(Instant.ofEpochMilli(epochMilli));
    }

    private <R> R parse(String date, TemporalQuery<R> query) {
        return formatter.parse(date, query);
    }

    private <R> Date parseDate(String dateStr, TemporalQuery<R> query) {
        return Date.from(parseInstant(dateStr, query));
    }

    private <R> Instant parseInstant(String dateStr, TemporalQuery<R> query) {
        R temporal = parse(dateStr, query);
        if (temporal instanceof Instant) {
            return (Instant) temporal;
        }
        if (temporal instanceof LocalDateTime) {
            return ((LocalDateTime) temporal).atZone(ZoneId.systemDefault()).toInstant();
        }
        if (temporal instanceof LocalDate) {
            return ((LocalDate) temporal).atStartOfDay(ZoneId.systemDefault()).toInstant();
        }
        if (temporal instanceof LocalDateTime) {
            LocalDate epoch = LocalDate.of(1970, 1, 1);
            LocalDateTime dateTime = LocalDateTime.of(epoch, (LocalTime) temporal);
            return dateTime.atZone(ZoneId.systemDefault()).toInstant();
        }
        throw new DateTimeException(" Type parameter must be LocalDateTime of LocalDate of LocalTime of Instant ");
    }

    /**
     * 字符串转换成时间
     */
    public Date parseDate(String dateStr) throws ParseException {
        return new SimpleDateFormat(pattern).parse(dateStr);
    }

    /**
     * 加对应数量的年单位
     */
    public static Date setYearDate(int year) {
        return setDate(year, 0, 0, null);
    }

    /**
     * 加对应数量的年单位
     */
    public static Date setYearDate(int year, Date date) {
        return setDate(year, 0, 0, date);
    }

    /**
     * 加对应数量的月单位
     */
    public static Date setMonthDate(int month) {
        return setDate(0, month, 0, null);
    }

    /**
     * 加对应数量的月单位
     */
    public static Date setMonthDate(int month, Date date) {
        return setDate(0, month, 0, date);
    }

    /**
     * 加对应数量的天单位
     */
    public static Date setDayDate(int day) {
        return setDate(0, 0, day, null);

    }

    /**
     * 加对应数量的天单位
     */
    public static Date setDayDate(int day, Date date) {
        return setDate(0, 0, day, date);
    }

    /**
     * 加对应数量的年月日单位
     */
    public static Date setDate(int year, int month, int day, Date date) {
        final Calendar instance = Calendar.getInstance();
        if (date != null) {
            instance.setTime(date);
        }
        instance.add(Calendar.YEAR, year);
        instance.add(Calendar.MONTH, month);
        instance.add(Calendar.DATE, day);
        return instance.getTime();
    }

    /**
     * 加对应数量的时分秒单位
     */
    public static Date setTime(int hour, int minute, int second, Date date) {
        final Calendar instance = Calendar.getInstance();
        if (date != null) {
            instance.setTime(date);
        }
        instance.add(Calendar.HOUR_OF_DAY, hour);
        instance.add(Calendar.MINUTE, minute);
        instance.add(Calendar.SECOND, second);
        return instance.getTime();
    }

    public String getPattern() {
        return pattern;
    }

    public int getLen() {
        return len;
    }

    /**
     * 获取当周第一天
     * 
     * @param dateStr
     * @return
     */
    public static Date getFirstDayOfWeek(String dateStr) {
        if (dateStr == null || "".equals(dateStr)) {
            return null;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return null;
        }
        try {
            final Date date = dateTimeUtil.parseDate(dateStr);
            return getFirstDayOfWeek(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取当周第一天
     * 
     * @param date
     * @return
     */
    public static Date getFirstDayOfWeek(Date date) {
        if (date == null) {
            return null;
        }
        final Calendar cal = Calendar.getInstance();
        try {
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_WEEK, 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cal.getTime();
    }

    /**
     * 获取当周最后一天
     * 
     * @param dateStr
     * @return
     */
    public static Date getLastDayOfWeek(String dateStr) {
        if (dateStr == null || "".equals(dateStr)) {
            return null;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return null;
        }
        try {
            final Date date = dateTimeUtil.parseDate(dateStr);
            return getLastDayOfWeek(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取当周最后一天
     * 
     * @param date
     * @return
     */
    public static Date getLastDayOfWeek(Date date) {
        final Calendar cal = Calendar.getInstance();
        try {
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_WEEK, 1);
            cal.set(Calendar.DATE, cal.get(Calendar.DATE) + 6);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cal.getTime();
    }

    /**
     * 获取时间枚举工具类
     *
     * @param dateStr
     * @return
     */
    public static DateTimeUtils getDateTimeUtil(String dateStr) {
        if (null == dateStr) {
            return null;
        }
        DateTimeUtils[] values = DateTimeUtils.values();
        for (int i = 0; i < values.length; i++) {
            DateTimeUtils dateTimeUtil = values[i];
            if (dateTimeUtil.len == dateStr.length() && dateTimeUtil.pattern.charAt(4) == dateStr.charAt(4)) {
                    return dateTimeUtil;
            }
        }
        return null;
    }

    /**
     * 获取月的最后一天
     * 
     * @return
     */
    public static Date getLastDayOfMonth() {
        return getLastDayOfMonth(new Date(System.currentTimeMillis()));
    }

    /**
     * 获取月的最后一天
     * 
     * @param date 日期
     * @return
     */
    public static Date getLastDayOfMonth(Date date) {
        final Calendar instance = Calendar.getInstance();
        instance.setTime(date);
        instance.set(Calendar.DAY_OF_MONTH, 1);
        instance.roll(Calendar.DAY_OF_MONTH, -1);
        return setTime(23, 59, 59, instance.getTime());
    }

    /**
     * 获取月的第一天
     * 
     * @param date 日期
     * @return
     */
    public static Date getFirstDayOfMonth(Date date) {
        final Calendar instance = Calendar.getInstance();
        instance.setTime(date);
        instance.set(Calendar.DAY_OF_MONTH, 1);
        return instance.getTime();
    }

    public static void main(String[] args) {
    }

    public static Date getWeekendFirstDayOfMonday(String dateStr) {
        if (dateStr == null || "".equals(dateStr)) {
            return null;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return null;
        }
        try {
            final Date date = dateTimeUtil.parseDate(dateStr);
            return getWeekendFirstDayOfMonday(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 以周日为第一天的获取
     * @param date
     * @return
     */
    public static Date getWeekendFirstDayOfMonday(Date date) {
        if (date == null) {
            return null;
        }
        final Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        return calendar.getTime();
    }

    public static Date getWeekendFirstDayOfSunday(String dateStr) {
        if (dateStr == null || "".equals(dateStr)) {
            return null;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return null;
        }
        try {
            final Date date = dateTimeUtil.parseDate(dateStr);
            return getWeekendFirstDayOfSunday(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;

    }

    public static Date getWeekendFirstDayOfSunday(Date date) {
        if (date == null) {
            return null;
        }
        final Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
        return calendar.getTime();
    }

    /**
     * 转化成对应的中文内容
     * 
     * @param dateStr
     * @param chineseDateTimeUtil
     * @return
     * @throws ParseException
     */
    public static String getDataChineseValue(String dateStr, DateTimeUtils chineseDateTimeUtil) throws ParseException {
        String chineseData = "";
        if (dateStr == null || "".equals(dateStr)) {
            return chineseData;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return chineseData;
        }
        chineseData = chineseDateTimeUtil.formatDate(dateTimeUtil.parseDate(dateStr));

        return chineseData;
    }
}
adions0819
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python 枚举一段时间内的日期，利用timedelta()
gene博客
09-08 1935
def get_date_list(start,end): date_list= [] date = datetime.datetime.strptime(start,'%Y-%m-%d') end = datetime.datetime.strptime(end,'%Y-%m-%d') while date &lt;= end: date_list...
Acwing 1229日期问题
qq_43573977的博客
12-28 353
小明正在整理一批历史文献。这些历史文献中出现了很多日期。 小明知道这些日期都在1960年1月1日至2059年12月31日。 令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。 更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。 比如02/03/04，可能是2002年03月04日、2004年02月03日或2...
蓝桥杯2017 日期问题
一只懒猫的博客
03-11 510
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。 比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。 给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？ 输入 一个日期，格式是"A
jdk(java)8 日期格式化工具-使用枚举处理
privateobject的博客
11-10 9952
jdk(java)8 日期格式化工具-使用枚举处理 在项目开发中，日期格式化是高频的工具类。大部分 工具类 都是 class ，格式化 字符串 直接传入到 方法内，确定是 每次都要 手写 格式化字符串，或者使用 封装好的方法 内嵌格式字符串。 后来想了想，觉得使用枚举 定义日期格式化处理，感觉不用手写格式化字符串，并且可以根据需要集中增加 格式化 字符串 暂不清楚，为什么这种方式比较少。可能有我想不到的问题吧ヾ(ﾟ∀ﾟゞ) 工具类代码-示例 import java.text.SimpleDateForm
Java学习13（日期，枚举，异常）
windyjcy的博客
05-08 173
Java学习13 今天怎么过呢，还没想好哈哈 2021.5.8（下了雷阵雨马上就出彩虹了，哈哈，心情瞬间满格了），今天争取把这个复习完把 对日期的处理 java.util.Date 获取系统当前时间（精确到豪秒，但是其中的toString不会显示毫秒），直接调用无参构造就行，输出的时间是国外那种形式的日期 如果用有参构造，传入的参数是毫秒，获取的时间是自 1970年1月1日0时 加上参数的时间 日期怎么格式化？即将日期类型Date，按照指定的格式进行转换，转换成一定格式的日期字符串String S
解析字符串转化为对象+code转desc+通过值实例枚举类+EnumUtil+PackageUtils工具类
12-18
解析字符串转化为对象+code转desc+通过值实例枚举类+EnumUtil+PackageUtils工具类 ZipInputStream实现压缩文件的读取与数据转化的过程，利用反射实现根据枚举值获取枚举对象。
字符串转换成枚举类型的方法
09-04
字符串可以向int, bool等类型转变，但是字符串是否可以向枚举转变呢？一起看下边的例子
mycat字符串枚举分片示例.txt
08-26
org.opencloudb.route.function.PartitionByFileMap可以支持字符串枚举、整型枚举（之前只支持整型枚举） 分片规则：字符串枚举分片 枚举分片的适用场景：记录数可枚举（记录数基本固定或变化很小），比如省份、地区...
c#入门之枚举和结构体使用详解(控制台接收字符串以相反的方向输出)
12-25
枚举、结构枚举的类型有限（short、byte…）且是相同的，在MSDN上找到枚举的一些示例，觉得这个还不错： 代码如下:enum myWeekDay { Monday = 1, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday };int i ...
java开发规范-日期时间
weixin_42005602的博客
10-27 414
日期时间 日期pattern 年份yyyy Not YYYY 【强制】日期格式化时，传入 pattern 中表示年份统一使用小写的 y。 说明：日期格式化时，yyyy 表示当天所在的年，而大写的 YYYY 代表是 week in which year（JDK7 之后引入的概念），意思是当天所在的周属于的年份，一周从周日开始，周六结束，只要本周跨年，返回的 YYYY 就是下一年。 正例：表示日期和时间的格式如下所示： new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”)
日期问题（枚举法+日期合理判断）
最新发布
2302_77698668的博客
08-29 174
所以，这段代码的输出格式为：年-月-日，如2022-01-01。其中，year表示年份，month表示月份，day表示日期。输出时，年份以四位数形式输出，月份和日期以两位数形式输出，不足两位时在前面补0。比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。输出若干个不相同的日期，每个日期一行，格式是”yyyy-MM-dd”。令小明头疼的是，这些日期采用的格式非常不统一，
java8 ChronoUnit日期时间单位枚举类
weixin_49114503的博客
12-02 6715
ChronoUnit是java8提供的一个枚举类，里面定义了很多表示日期/时间的枚举值，提供基于单元的访问来操纵日期，时间或日期时间, 通过实现TemporalUnit来扩展标准单元集。
java枚举类实现日期格式化的相互转换
weixin_44633160的博客
09-02 368
java枚举类实现日期格式化的相互转换
【Java】DateTimeUtils（时间格式化工具类）
XKIND'S 博客
03-15 5104
Java 时间格式化工具类 import java.time.Instant; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.time.ZoneId; import java.time.format.DateTimeFormatter; impo...
整型、浮点型、定点型、时间日期类型、字符串类型、text、enum、列属性、三大范式、表关系
weixin_44518089的博客
08-11 1647
整型 分类： 迷你整型tinyint：系统采用一个字节来保存的整型，一个字节8位，范围0~255 小整型smallint：采用两个字节保存整型，范围0~65535 中整型mediumint：采用三个字节保存 整型int：采用四个字节保存 大整型bigint：采用八个字节保存 显示长度 显示长度：数据(整型)在现实数据的时候到底可以实现多少位 tinyint(3)：表示最长可以实现3位,unsigned说明只是整数，永远不会超过三位长度 tinyint(4):表示最长四位，范围-128~127 显示长度只是代
java8 ChronoField日期时间枚举类
weixin_49114503的博客
12-01 2692
ChronoField是java8提供的一个枚举类，里面定义了很多表示日历的字段，提供基于字段的访问来操纵日期，时间或日期时间, 通过实现TemporalField来扩展标准字段集。
史上最全日期格式枚举类
高山仰止，景行行止
01-13 3653
废话不多说，直接上大餐 package com.fanhf.javastudy.enumTest; import org.apache.commons.lang3.StringUtils; /** * @author fanhf * @Description 日期格式枚举类 * @date 2021-01-13 10:00 */ public enum DateFomateEnum { DATE_FORMAT_RFC_1123_3_YEAR(11230, "EEE, dd.MM.yyyy,
Java基础（日期类和枚举）
ToString的博客
10-01 1037
日期类： Date: setTime(long time):通过一个long型的数值设定时间 getTime():获取毫秒数 SimpleDateFormat：用于实现字符串与日期之间一互转 yyyy-MM-dd HH:mm:ss—表示年月日时分秒，hh表示12小时制，HH表示24小时制 String format(Date d):把一个日期对象转换为指定格式的字符串 Date d = parse(String msg):把一个字符串按照指定格式解析成一个日期 Calendar:日历类 c.set(2022
Java 枚举类、时间类型、UDP、操作流
菜鸟心声：学的不仅是技术，更是梦想！
10-25 209
Java 枚举类 1.什么是枚举类 比较特殊的类 * 定义方式： * enum 名称{} * 不能直接new对象 * 常量 类型就是枚举类型 * java.lang.Enum{} * jdk1.5之后才有的类 2.枚举类和普通类的区别: 1.普通类的对象是使用的时候使用new关键字创建 * 2.枚举类的对象自己在类中已经定义好的，只能使用这几个对象，不能自己创建 枚举类的注意点： * 1.构造方法只能使用默认和private，枚举类型中的构造方法，仅限在本
java根据String 月份 获取第一天和最后一天
05-26
可以使用java.time包中的类来实现该功能。以下是一个示例代码： ```java import java.time.LocalDate; import java.time.format.DateTimeFormatter; public class DateUtils { public static String ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值