时间工具类（优化版）

最新推荐文章于 2024-04-24 17:32:57 发布
最新推荐文章于 2024-04-24 17:32:57 发布
阅读量1k 收藏 26
点赞数 20
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46493080/article/details/134665574
版权

       

目录

一、获取当前时间(系统时间)距离特定时间(如18:00:00)的间隔

二、将 unix 时间戳转换为 相应时区时间

三、将特定时区的字符串时间转换为UTC时间

四、将原始格式的时间转换为指定格式的时间

五、将 Long 型时间转换为 指定格式的时间

六、将 unix 时间戳转换为特定格式的日期数组,其中索引位置0为日期, 索引位置1为时间

七、获取当前日期的特定格式

八、获取从今天起的未来若干个间隔的日期信息

九、获取距离当前日期特定间隔特定格式的日期信息

十、将 String 时间转换为 相应时区下的时间戳

十一、将 Instant 时间转为形如 2022102714 的时间

十二、将特定格式的字符串日期转为日期形式

十三、将LocalDate 转换为 特定格式的 字符串格式的日期

十四、LocalDateTime 转 string

十五、判断日期时间是否有效

十六、将LocalTime 转换为 特定格式的 字符串格式的时间

结尾：

        时间是计算机程序中常用的数据类型之一，它在很多场景中都有着重要的作用，如日志记录、计时、缓存、定时任务等等。因此开发一个实用、可靠的时间工具类对于程序员来说是非常有必要的。

        一个好的时间工具类应该具备以下特点：易用性高、精度高、能够处理各种时间格式、支持不同的时区、提供丰富的时间计算方法等。在本文中，我们将探讨如何设计一个高质量的时间工具类。

一、获取当前时间(系统时间)距离特定时间(如18:00:00)的间隔
    /**
     * 获取当前时间(系统时间)距离特定时间(如18:00:00)的间隔,结果可能为正,亦可为负
     * 间隔 >=0: 表示当前时间未到达(或刚好到达)设定的时间(含异常情况)
     * 间隔 <0: 表示当前时间已超过设定的时间
     *
     * @param time 字符串形式的时间,如18:00:00
     * @return long
     */
    public static long getTimeDiffWithMills(String time) {
        DateFormat dateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
        DateFormat dayFormat = new SimpleDateFormat("yy-MM-dd");
        try {
            Date curDate = dateFormat.parse(dayFormat.format(new Date()) + " " + time);
            return curDate.getTime() - System.currentTimeMillis();
        } catch (ParseException e) {
            LOGGER.error("时间转换出错,原因是 <{}>", e.getMessage());
            return 0;
        }
    }
二、将 unix 时间戳转换为 相应时区时间
    /**
     * 将 unix 时间戳转换为 相应时区时间
     *
     * @param instant    Instant
     * @param zoneIdType SystemEnumEntity.ZoneIdType
     * @return String
     */
    public static String instantToString(Instant instant, SystemEnumEntity.ZoneIdType zoneIdType) {
        if (null == instant || null == zoneIdType) {
            return ConstantUtil.SPECIAL_CHARACTER_EMPTY;
        }
        try {
            return DateTimeFormatter.ofPattern(ConstantUtil.DATE_TIME_FORMAT_GENERAL)
                    .withZone(ZoneId.of(zoneIdType.getLabel())).format(instant);
        } catch (Exception e) {
            LOGGER.error("error message: 时间转换异常,原因是 <{}>", e.toString());
            return ConstantUtil.SPECIAL_CHARACTER_EMPTY;
        }
    }
三、将特定时区的字符串时间转换为UTC时间
/**
     * 将特定时区的字符串时间转换为UTC时间
     *
     * @param dateTime       String
     * @param dateTimeFormat String
     * @param zoneIdType     SystemEnumEntity.ZoneIdType
     * @return Instant
     */
    public static Instant stringToInstant(String dateTime, String dateTimeFormat, SystemEnumEntity.ZoneIdType zoneIdType) {
        if (StringUtil.isEmpty(dateTime) || StringUtil.isEmpty(dateTimeFormat)) {
            LOGGER.error("error message: 待处理的时间无效,请检查,默认返回系统当前的UTC时间");
            return Instant.now();
        }
        try {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(dateTimeFormat);
            LocalDateTime localDateTime = LocalDateTime.parse(dateTime, dateTimeFormatter);
            return localDateTime.atZone(ZoneId.of(zoneIdType.getLabel())).toInstant();
        } catch (Exception e) {
            LOGGER.error("error message: 时间转换异常,原因是 <{}>", e.toString());
            return Instant.now();
        }
    }
四、将原始格式的时间转换为指定格式的时间
/**
     * 将原始格式的时间转换为指定格式的时间
     *
     * @param dateTime        String 待转换的时间
     * @param initialFormat   String 原始格式
     * @param convertedFormat String 指定格式
     * @return String 发生异常时,使用当前系统时间进行转换
     */
    public static String formatDateTime(String dateTime, String initialFormat, String convertedFormat) {
        try {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(initialFormat);
            LocalDateTime localDateTime = LocalDateTime.parse(dateTime, dateTimeFormatter);
            dateTimeFormatter = DateTimeFormatter.ofPattern(convertedFormat);
            return localDateTime.format(dateTimeFormatter);
        }
        // 转换异常
        catch (Exception e) {
            LOGGER.error("error message: 时间 <{}> 由格式 <{}> 转为 格式 <{}> 时发生异常,原因是 <{}>", dateTime, initialFormat, convertedFormat, e.toString());
            return LocalDateTime.now().format(DateTimeFormatter.ofPattern(convertedFormat));
        }
    }
五、将 Long 型时间转换为 指定格式的时间
/**
     * 将 Long 型时间转换为 指定格式的时间
     *
     * @param timeStamp  String Long型时间
     * @param format     String 指定格式
     * @param zoneIdType SystemEnumEntity.ZoneIdType 时区类型
     * @return String 发生异常时,使用当前系统时间进行转换
     */
    public static String conversionTime(String timeStamp, String format, SystemEnumEntity.ZoneIdType zoneIdType) {
        try {
            long times = Long.parseLong(timeStamp) * 1000L;
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
            LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(times), ZoneId.of(zoneIdType.getLabel()));
            return dateTimeFormatter.format(localDateTime);
        }
        // 转换异常
        catch (Exception e) {
            LOGGER.error("error message: Long型时间 <{}> 转为 格式 <{}> 时发生异常,原因是 <{}>", timeStamp, format, e.toString());
            return LocalDateTime.now().format(DateTimeFormatter.ofPattern(format));
        }
    }
六、将 unix 时间戳转换为特定格式的日期数组,其中索引位置0为日期, 索引位置1为时间
/**
     * 将 unix 时间戳转换为特定格式的日期数组,其中索引位置0为日期, 索引位置1为时间
     *
     * @param timeStamp String long型时间
     * @param format    String 特定格式
     * @return String[] 索引位置0为日期, 索引位置1为时间
     */
    public static String[] getDateTimeArrayFromUtc(String timeStamp, String format, SystemEnumEntity.ZoneIdType zoneIdType) {
        try {
            String time = conversionTime(timeStamp, format, zoneIdType);
            return StringUtil.spiltBySpecialCharacter(time, ConstantUtil.SPECIAL_CHARACTER_BACKSPACE);
        } catch (Exception e) {
            LOGGER.error("error message: Long型时间 <{}> 转为 数组格式时间发生异常,原因是 <{}>", timeStamp, e.toString());
            return new String[0];
        }
    }
七、获取当前日期的特定格式

特定格式：yyyy-MM-dd、yyyy-MM-dd HH:mm:ss、等等

    /**
     * 获取当前日期的特定格式
     *
     * @param timeFormat String 日期格式
     * @return String
     * @throws BusinessException 异常
     */
    public static String getCurrentDate(String timeFormat) throws BusinessException {
        try {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(timeFormat);
            return dateTimeFormatter.format(LocalDateTime.now());
        } catch (Exception e) {
            LOGGER.error("error message: 获取当前日期的特定格式,数据异常,原因:<{}>", String.valueOf(e));
            throw new BusinessException((SystemErrorCode.DATE_CONVERT_FAILED));
        }
    }
八、获取从今天起的未来若干个间隔的日期信息
    /**
     * 获取从今天起的未来若干个间隔的日期信息
     *
     * @param intervals int
     * @return List<String>,形如 2022-06-24, 2022-06-25 ...
     */
    public static List<String> getFutureDays(int intervals) {
        List<String> futureDaysList = new ArrayList<>();
        for (int i = 0; i <= intervals; i++) {
            String date = getFutureDate(i, ConstantUtil.DATE_TIME_FORMAT_GENERAL_WITHOUT_HOUR_THREE);
            if (StringUtil.isEmpty(date)) {
                continue;
            }
            futureDaysList.add(date);
        }
        return futureDaysList;
    }
九、获取距离当前日期特定间隔特定格式的日期信息
    /**
     * 获取距离当前日期特定间隔特定格式的日期信息
     *
     * @param future int  特定间隔
     * @param format String 特定格式
     * @return String 发生异常时返回空字符串
     */
    public static String getFutureDate(int future, String format) {
        LocalDate localDate = LocalDate.now().plusDays(future);
        try {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
            return dateTimeFormatter.format(localDate);
        } catch (Exception e) {
            LOGGER.error("error message: 获取距离当前日期第 <{}> 日的日期失败,原因是 <{}>", future, e.toString());
            return ConstantUtil.SPECIAL_CHARACTER_EMPTY;
        }
    }
十、将 String 时间转换为 相应时区下的时间戳
/**
     * 将 String 时间转换为 相应时区下的时间戳
     *
     * @param dateTime           String
     * @param zoneIdType         SystemEnumEntity.ZoneIdType
     * @param dateTimeFormatFlag boolean
     *                           True-Instant格式的字符串,形如"2021-11-25T14:00:13Z"
     *                           False-非Instant格式的字符串,形如"2021-11-25 14:00:13"
     * @return Instant
     * @throws BusinessException 抛出异常
     */
    public static Instant stringToInstant(String dateTime,
                                          SystemEnumEntity.ZoneIdType zoneIdType,
                                          boolean dateTimeFormatFlag) throws BusinessException {
        if (StringUtil.isEmpty(dateTime) || null == zoneIdType) {
            LOGGER.error("error message: 日期时间 <{}> 或 时区信息 <{}> 无效", dateTime, zoneIdType);
            throw new BusinessException(GuiErrorCode.ACCESS_PARAMETER_INVALID);
        }
        try {
            if (dateTimeFormatFlag) {
                return LocalDateTime.ofInstant(Instant.parse(dateTime), ZoneId.of(zoneIdType.getLabel())).toInstant(ZoneOffset.UTC);
            } else {
                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(ConstantUtil.DATE_TIME_FORMAT_GENERAL);
                LocalDateTime localDateTime = LocalDateTime.parse(dateTime, dateTimeFormatter);
                return localDateTime.atZone(ZoneId.of(zoneIdType.getLabel())).toInstant();
            }
        } catch (Exception e) {
            LOGGER.error("error message: 字符串格式时间 <{}> 转换为 Instant 异常,原因是 <{}>", dateTime, String.valueOf(e));
            throw new BusinessException(SystemErrorCode.DATE_CONVERT_FAILED);
        }
    }
十一、将 Instant 时间转为形如 2022102714 的时间
    /**
     * 将 Instant 时间转为形如 2022102714 的时间
     *
     * @param instant instant Instant 时间
     * @return String
     */
    public static String convertInstantToDateHour(Instant instant) {
        try {
            return instant.atOffset(ZoneOffset.ofHours(0)).format(DateTimeFormatter.ofPattern(ConstantUtil.TIME_FORMAT_YEAR_MONTH_DAY_HOUR_FULL_NORMAL));
        } catch (Exception e) {
            return Instant.now().atOffset(ZoneOffset.ofHours(0)).format(DateTimeFormatter.ofPattern(ConstantUtil.TIME_FORMAT_YEAR_MONTH_DAY_HOUR_FULL_NORMAL));
        }
    }
十二、将特定格式的字符串日期转为日期形式
    /**
     * 将特定格式的字符串日期转为日期形式
     *
     * @param str        Date
     * @param dateFormat String
     * @return String
     * @throws BusinessException 自定义异常
     */
    public static LocalDate stringToLocalDate(String str, String dateFormat) throws BusinessException {
        try {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(dateFormat);
            return LocalDate.parse(str, dateTimeFormatter);
        } catch (Exception e) {
            LOGGER.error("error message: String 格式日期 <{}> 转换为 LocalDate 格式 <{}> 日期时间异常,原因是:", str, dateFormat, e);
            throw new BusinessException(SystemErrorCode.DATE_CONVERT_FAILED);
        }
    }
十三、将LocalDate 转换为 特定格式的 字符串格式的日期
    /**
     * 将LocalDate 转换为 特定格式的 字符串格式的日期
     *
     * @param localDate  LocalDate
     * @param timeFormat String 特定格式
     * @return LocalDate
     * @throws BusinessException 自定义异常
     */
    public static String localDateToString(LocalDate localDate, String timeFormat) throws BusinessException {
        if (null == localDate || StringUtil.isEmpty(timeFormat)) {
            throw new BusinessException(GuiErrorCode.ACCESS_PARAMETER_INVALID);
        }
        try {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(timeFormat);
            return localDate.format(dateTimeFormatter);
        } catch (Exception e) {
            LOGGER.error("error message: LocalDate<{}> 转换为 <{}> 格式的 字符串格式日期  异常,原因是:", localDate, timeFormat, e);
            throw new BusinessException(SystemErrorCode.DATE_CONVERT_FAILED);
        }
    }
十四、LocalDateTime 转 string
    /**
     * LocalDateTime 转 string
     *
     * @param dateDate   LocalDateTime
     * @param timeFormat String
     * @return String
     */
    public static String localDataTimeToStringDateTime(LocalDateTime dateDate, String timeFormat) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(timeFormat);
        return dateDate.format(dateTimeFormatter);
    }
十五、判断日期时间是否有效
    /**
     * 日期时间 年, 月, 日, 时, 分, 秒, 毫秒 域
     */
    private static final List<ChronoField> DATE_TIME_FIELD_LIST = List.of(ChronoField.YEAR,
            ChronoField.MONTH_OF_YEAR,
            ChronoField.DAY_OF_MONTH,
            ChronoField.HOUR_OF_DAY,
            ChronoField.MINUTE_OF_HOUR,
            ChronoField.SECOND_OF_MINUTE,
            ChronoField.MILLI_OF_SECOND);


    /**
     * 判断日期时间是否有效
     *
     * @param strDateTime    String 日期时间 如 2022-12-01 17:26:17, 2022-12-01, 17:53:24, 17:37
     * @param dateTimeFormat String 时间格式 如 yyyy-MM-dd HH:mm:ss, yyyy-MM-dd, HH:mm:ss, HH:mm
     * @return boolean True-日期时间有效 False-日期时间无效
     */
    public static boolean isDateTimeValid(String strDateTime, String dateTimeFormat) {
        try {
            if (StringUtil.isEmpty(strDateTime)
                    || StringUtil.isEmpty(dateTimeFormat)) {
                return false;
            }
            // // 使用了 uuuu 而不是 yyyy 即 YEAR而不是 YEAR_OF_ERA, 从而避免 将 2022-02-30 这样无效的日期 自动更正为一个有效日期
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(dateTimeFormat.replaceAll("[yY]", "u"))
                    .withResolverStyle(ResolverStyle.STRICT);
            final TemporalAccessor dateTimeFieldAccessor = dateTimeFormatter.parse(strDateTime);
            // 日期时间仅有 年, 月, 日, 时, 分, 秒, 毫秒时，校验是否在有效范围内
            return DATE_TIME_FIELD_LIST
                    .stream()
                    .filter(dateTimeFieldAccessor::isSupported)
                    .allMatch(field -> field.range().isValidValue(dateTimeFieldAccessor.get(field)));
        } catch (Exception e) {
            return false;
        }
    }
十六、将LocalTime 转换为 特定格式的 字符串格式的时间
    /**
     * 将LocalTime 转换为 特定格式的 字符串格式的时间
     *
     * @param localTime  LocalTime
     * @param timeFormat String 特定格式
     * @return LocalDate
     * @throws BusinessException 自定义异常
     */
    public static String localTimeToString(LocalTime localTime, String timeFormat) throws BusinessException {
        if (null == localTime || StringUtil.isEmpty(timeFormat)) {
            throw new BusinessException(GuiErrorCode.ACCESS_PARAMETER_INVALID);
        }
        try {
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(timeFormat);
            return localTime.format(dateTimeFormatter);
        } catch (Exception e) {
            LOGGER.error("error message: LocalDate<{}> 转换为 <{}> 格式的 字符串格式时间  异常,原因是:", localTime, timeFormat, e);
            throw new BusinessException(SystemErrorCode.DATE_CONVERT_FAILED);
        }
    }
结尾：

        以上这十几种、时间类型转换的方法、有用不了的地方、评论或私信都可、欢迎一起来讨论一下........

单人可khalil
关注
  • 20
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一个long型与Date型时间转换工具
11-27
一个long型与Date型时间转换工具，适合测试人员使用，内附JAVA代码
java常用工具类封装
09-14
在Java编程中，工具类（Util Classes）是包含各种实用方法的静态类，它们提供了一种简化常见任务的方式。"java常用工具类封装"是指将常见的功能如线程管理、数据解析、第三方库集成等进行封装，以提高代码的可重用性...
Unix、UTC、GPS时间戳及转换
xiaojinger_123的博客
04-13 1万+
Unix、UTC、GPS时间戳及转换
-UTC时间及时区获取
最新发布
chuyouyinghe的专栏
04-24 219
可以采用多种方法获取，这里只简单介绍两种：直接获取零时区时间、根据本地时间计算得出。UTC时间：世界统一时间，世界标准时间又称格林尼治平时或格林尼治时间。PS：UTC时间+时区差=本地时间。
Long类型毫秒数时间格式转换成Date格式
南国以南i的博客
03-09 3711
Long类型毫秒数时间格式转换成Date格式
将long值转换为时间
qiujieda的专栏
08-07 1440
public class ParseLongToTime { public static void main(String[] args) { long timeTemp = System.currentTimeMillis(); long time = timeTemp; long mSec = time % 1000; time /= 1000; long year =
算法之unix时间戳和UTC时间(年月日)互换
Once_day的回忆
06-08 2750
author：onceday date：2022年6月8日 一个简单而效率的unix时间戳和UTC时间互换算法。 3.底层tick滴答时钟获取函数 4.标准时间time()函数，返回时间点用于时间计算 5.星期计算公式，由年月日计算当前星期情况 参考文档：C语言根据日期判断星期几（使用基姆拉尔森计算公式） (51hei.com) 6.Unix时间戳计算标准UTC时间 这里需要注意闰年的计算，如果计算缺少，就会影响到最终天数的准确性。 7.标准UTC时间生成Unix时间戳 8.time标准库函数实现...
java操作日期时间工具类
03-24
在Java编程语言中，处理日期和...总之，一个良好的日期时间工具类应该简化日期时间的常见操作，提高代码的可读性和可维护性。在Java 8及更高版本中，可以考虑利用`java.time`包提供的新特性来进一步优化工具类的设计。
Android开发常用工具类
08-27
2. **日期时间工具类**： - `DateUtils`：提供了对日期和时间的处理，如格式化日期、计算两个日期之间的差值、获取当前时间等。 - `TimeUtils`：包含与时间相关的操作，例如将毫秒值转换为友好的显示格式。 3. **...
Java工具类合集
11-28
此外，可能会有针对集合操作的工具类，如`ListUtil`、`MapUtil`，它们提供了对Java集合框架的扩展和优化。 这个合集可能还包括线程池管理工具，如`ThreadPoolUtil`，用于创建和管理线程池，提高多线程环境下的性能...
java常用工具类
01-10
"com-jarvis-base"可能是一个自定义的基础工具库，可能包含了开发者自定义的一系列通用工具类，比如日期时间处理、IO操作、网络请求、加密解密等。这些工具类通常是为了避免代码重复，提高代码复用性和一致性。例如...
long类型时间转换
程序哈哈的博客
04-16 8401
long time = 2222222222222； SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); java.util.Date date = new Date(time); String str = sdf.format(date);
工具类：DateUtils：long型与日期时间型、String相互转换，获取各种类型的时间
m0_62208814的博客
07-21 2420
long型转换为日期时间型 将cst时间格式转化为正常日期 日期类型转换为long型 string转date类型 获取当前日期时间戳 获取前一天日期，格式为20220815 获取当前时间的整点的时间戳（毫秒） 获取当天时间的0点的时间戳（毫秒） 获取当天时间的0点的时间戳（秒）
（多种方法实现 ）Java中日期时间与时间毫秒值(Long)之前相互转换【亲测有效】
萌小崔的博客
11-26 6697
时间毫秒值转日期时间 方式一 :setTime方法转换 public static void main(String[] args) { //获取当前时间毫秒值 long timeMillis = System.currentTimeMillis(); //获取当前时间 Date date = new Date(); //将毫秒值传给Date下方法setTime(long time),自动转换日期方法,后面加L,强转数..
Unix时间戳转化为UTC日期格式（Unix 50周年快乐）
Donald_Shallwing的博客
02-02 2042
Unix系统内记录的时间是一个时间戳，所谓时间戳，就是Unix元年
long类型转换成日期
热门推荐
nenguou04的博客
12-22 5万+
后台给返回的日期格式有时候不符合要求，不能直接在界面上显示，这篇文章提供了一些方法用于格式的转换
Java获取当前的UTC时间
SpringBoy的博客
03-22 4787
Instant获取的是格林威治标准时间（UTC时间）。因为Instant是表示时间戳的对象，它不依赖于时区信息。但是在显示Instant对象时，需要将其转换为特定时区的本地时间。但是此修改可能是全局性的，建议在代码启动之初设定全部使用同一时区时间，后面就不再频繁更改，避免产生时间错乱问题。java中如何获取utc时间，并转为Date对象，这是一个常见的问题。获取了UTC的毫秒时间，然后new一个Date对象。那么为什么不能获取，如何正确获取utc时间呢？时打印的是带时区的时间，而非UTC时间。
java Date、String、Long三种日期类型之间的相互转换(亲测)
gb4215287的博客
09-14 6584
java Date、String、Long三种日期类型之间的相互转换
[JAVA语法] long类型转时间类型
m0_56227168的博客
04-24 6256
1.long类型转时间类型 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String timeNow= sdf.format( lastModified ); //timeNow为当前时间的格式化显示,为字符串类型 注:此系列用与个人学习总结,当遇到新代码,还会在此基础上更新 ......
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值