日期转换运算工具类

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量382 收藏
点赞数 4
分类专栏： Java 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42390993/article/details/139302302
版权

一、日期转换运算

Java 中的日期常用转换

二、工具类

代码如下：

package com.common.utils.time;

import org.apache.commons.lang3.time.DateFormatUtils;

import java.lang.management.ManagementFactory;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;

public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
    private static final int[] dayArr = new int[]{20, 19, 21, 20, 21, 22, 23, 23, 23, 24, 23, 22};
    private static final String[] constellationArr = new String[]{"摩羯座", "水瓶座", "双鱼座", "白羊座", "金牛座", "双子座", "巨蟹座", "狮子座", "处女座", "天秤座", "天蝎座", "射手座", "摩羯座"};
    public static final String PATTERN_FULL = "yyyy-MM-dd HH:mm:ss.SSS";
    public static final String PATTERN_SHORT_FULL = "yyyyMMddHHmmssSSS";
    public static final String PATTERN_DATETIME = "yyyy-MM-dd HH:mm:ss";
    public static final String PATTERN_DATETIME_MINUTE = "yyyy-MM-dd HH:mm";
    public static final String PATTERN_DATETIME_HOUR = "yyyy-MM-dd HH";
    public static final String PATTERN_DATETIME_CN = "yyyy年MM月dd日HH时mm分ss秒";
    public static final String PATTERN_SHORT_DATETIME = "yyyyMMddHHmmss";
    public static final String PATTERN_DATE = "yyyy-MM-dd";
    public static final String PATTERN_DATE_CN = "yyyy年MM月dd日";
    public static final String PATTERN_SHORT_DATE = "yyyyMMdd";
    public static final String PATTERN_TIME = "HH:mm:ss";
    public static final String PATTERN_TIME_CN = "HH时mm分ss秒";
    public static final String PATTERN_SHORT_TIME = "HHmmss";
    public static final String PATTERN_YEAR = "yyyy";
    public static final String PATTERN_SHORT = "yyyyMMdd";

    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"};

    public DateUtils() {
    }

    public static String formatFull(Date date) {
        return format(date, "yyyy-MM-dd HH:mm:ss.SSS");
    }

    public static String formatDateTime(Date date) {
        return format(date, "yyyy-MM-dd HH:mm:ss");
    }

    public static String formatDateTimeCN(Date date) {
        return format(date, "yyyy年MM月dd日HH时mm分ss秒");
    }

    public static String formatShortDateTime(Date date) {
        return format(date, "yyyyMMddHHmmss");
    }

    public static String formatDate(Date date) {
        return format(date, "yyyy-MM-dd");
    }

    public static String formatYear(Date date) {
        return format(date, PATTERN_YEAR);
    }

    public static String formatShort(Date date) {
        return format(date, PATTERN_SHORT);
    }

    public static String formatDateCN(Date date) {
        return format(date, "yyyy年MM月dd日");
    }

    public static String formatShortDate(Date date) {
        return format(date, "yyyyMMdd");
    }

    public static String formatTime(Date date) {
        return format(date, "HH:mm:ss");
    }

    public static String formatTimeCN(Date date) {
        return format(date, "HH时mm分ss秒");
    }

    public static String formatShortTime(Date date) {
        return format(date, "HHmmss");
    }

    public static String format(Date date, String pattern) {
        SimpleDateFormat formatTime = new SimpleDateFormat(pattern);
        return formatTime.format(date);
    }

    public static Date parseFull(String date) {
        return parse(date, "yyyy-MM-dd HH:mm:ss.SSS");
    }

    public static Date parseShortFull(String date) {
        return parse(date, "yyyyMMddHHmmssSSS");
    }

    public static Date parseDateTime(String date) {
        return parse(date, "yyyy-MM-dd HH:mm:ss");
    }

    public static Date parseShortDateTime(String date) {
        return parse(date, "yyyyMMddHHmmss");
    }

    public static Date parseDate(String date) {
        return parse(date, "yyyy-MM-dd");
    }
    public static Date parseDate(Date date) {
        String value = formatDate(date);
        return parse(value, "yyyy-MM-dd");
    }

    public static Date parseShortDate(String date) {
        return parse(date, "yyyyMMdd");
    }

    public static Date parseTime(String date) {
        return parse(date, "HH:mm:ss");
    }

    public static String nowDateTime() {
        return formatDateTime(new Date());
    }

    public static String nowDate() {
        return formatDate(new Date());
    }

    public static String nowShortDate() {
        return formatShortDate(new Date());
    }

    public static String nowTime() {
        return formatTime(new Date());
    }

    public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


    public static String nowShort() {
        return format(new Date(), PATTERN_SHORT);
    }


    public static Date parse(String date, String pattern) {
        SimpleDateFormat formatTime = new SimpleDateFormat(pattern);

        try {
            return formatTime.parse(date);
        } catch (ParseException var4) {
            throw new IllegalArgumentException("parse error.date:" + date + " pattern" + pattern);
        }
    }
    public static String getSysYear() {
        Calendar calendar = Calendar.getInstance();
        return String.valueOf(calendar.get(Calendar.YEAR));
    }

    public static String getSysYearDetail() {
        int year = LocalDateTime.now().getYear();
        LocalDateTime localDateTime = LocalDateTime.of(year,12,31,23,59,59);
        return localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    public static String getWeekOfDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        switch(calendar.get(7)) {
            case 1:
                return "周日";
            case 2:
                return "周一";
            case 3:
                return "周二";
            case 4:
                return "周三";
            case 5:
                return "周四";
            case 6:
                return "周五";
            case 7:
                return "周六";
            default:
                return "";
        }
    }

    public static String getConstellation(int month, int day) {
        return day < dayArr[month - 1] ? constellationArr[month - 1] : constellationArr[month];
    }

    public static String getZodiac(int year) {
        if (year < 1900) {
            return "未知";
        } else {
            int start = 1900;
            String[] zodiacs = new String[]{"鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪"};
            return zodiacs[(year - start) % zodiacs.length];
        }
    }

    public static int getAgeFromBirthDay(Date birthDay) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(birthDay);
        Calendar now = Calendar.getInstance();
        if (cal.after(now)) {
            throw new IllegalArgumentException("The birthDay is after now.");
        } else {
            int age = now.get(1) - cal.get(1);
            int month = cal.get(2);
            int day = cal.get(5);
            if (month == 2 && day == 29) {
                if (now.get(2) < 2) {
                    --age;
                }
            } else if (cal.get(2) > now.get(2) || cal.get(2) == now.get(2) && cal.get(5) > now.get(5)) {
                --age;
            }

            return age;
        }
    }

    /**
     * 返回 年月日小时分秒
     *
     * @return yyyyMMddHHmmss
     */
    public static String getTodayChar14() {
        return DateUtils.format(new Date(), "yyyyMMddHHmmss");
    }

    /**
     * 返回 年月日
     *
     * @return yyyyMMdd
     */
    public static String getTodayChar15() {
        return DateUtils.format(new Date(), "yyyyMMdd");
    }

    /**
     * 返回 年月日小时分秒 毫秒
     *
     * @return yyyyMMddHHmmssS
     */
    public static String getTodayChar17() {
        String dateString = DateUtils.format(new Date(), "yyyyMMddHHmmss");
        int length = dateString.length();

        if (length < 17) {
            String endStr = dateString.substring(14, length);
            int len = endStr.length();
            for (int i = 0; i < 3 - len; i++) {
                endStr = "0" + endStr;
            }
            dateString = dateString.substring(0, 14) + endStr;
        }
        return dateString;
    }

    public static Date getDateNow() {
        return new Date();
    }

    public static LocalDate getLocalDateNow() {
        return LocalDate.now();
    }

    public static LocalDateTime getLocalDateTimeNow() {
        return LocalDateTime.now();
    }

    public static Long getTimestampNow() {
        Calendar calendar = Calendar.getInstance();
        long timestamp = calendar.getTimeInMillis();
        return timestamp;
    }

    //Date -> 毫秒时间戳
    public static String dateToTimeStampTime(Date date) {
        long time = date.getTime();
        return String.valueOf(time);
    }

    //Date -> LocalDateTime
    public static LocalDateTime dateToLocalDateTime(Date date) {
        Instant instant = date.toInstant();
        ZoneId zone = ZoneId.systemDefault();
        return LocalDateTime.ofInstant(instant, zone);
    }

    //Date -> LocalDate
    public static LocalDate dateToLocalDate(Date date) {
        LocalDateTime localDateTime = dateToLocalDateTime(date);
        return localDateTime.toLocalDate();
    }

    //Date -> LocalTime
    public static LocalTime dateToLocalTime(Date date) {
        LocalDateTime localDateTime = dateToLocalDateTime(date);
        return localDateTime.toLocalTime();
    }

    //timeStamp时间戳 -> Date
    public static Date timeStampToDate(Long timeStamp) {
        String dateString = sdf.format(new Date(timeStamp)); // Date对象转换为字符串
        Date date = null; // 字符串转换为Date对象
        try {
            date = sdf.parse(dateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    //LocalDateTime -> Date
    public static Date localDateTimeToDate(LocalDateTime localDateTime) {
        ZoneId zone = ZoneId.systemDefault();
        Instant instant = localDateTime.atZone(zone).toInstant();
        return Date.from(instant);
    }

    //LocalDate -> Date
    public static Date localDateToDate(LocalDate localDate) {
        ZoneId zone = ZoneId.systemDefault();
        Instant instant = localDate.atStartOfDay().atZone(zone).toInstant();
        return Date.from(instant);
    }

    //LocalTime -> Date
    public static Date localTimeToDate(LocalTime localTime) {
        LocalDate localDate = LocalDate.now();
        ZoneId zone = ZoneId.systemDefault();
        Instant instant = LocalDateTime.of(localDate, localTime).atZone(zone).toInstant();
        return Date.from(instant);
    }

    //LocalDateTime 增加多少秒
    public static LocalDateTime localDateTimePlusSecond(LocalDateTime localDateTime, Long second) {
        LocalDateTime time = localDateTime.plusSeconds(second);
        return time;
    }

    //两个LocalDateTime相差多少毫秒
    public static Long durationMillis(LocalDateTime start, LocalDateTime end)
    {
        Duration duration = Duration.between(start,end);
        long millis = duration.toMillis();
        return millis;
    }

    //两个Date相差多少相差多少毫秒
    public static Long durationMillis(Date start, Date end)
    {
        Duration duration = Duration.between(dateToLocalDateTime(start),dateToLocalDateTime(end));
        long millis = duration.toMillis();
        return millis;
    }

    //两个LocalDateTime相差多少秒
    public static Long durationSeconds(LocalDateTime start, LocalDateTime end)
    {
        Duration duration = Duration.between(start,end);
        long seconds = duration.getSeconds();
        return seconds;
    }

    //两个Date相差多少相差多少秒
    public static Long durationSeconds(Date start, Date end)
    {
        Duration duration = Duration.between(dateToLocalDateTime(start),dateToLocalDateTime(end));
        long seconds = duration.getSeconds();
        return seconds;
    }

    //将秒转化为时分秒的格式
    public static String formatHMS(long second) {
        int temp = (int) second;
        int hh = temp / 3600;
        int mm = (temp % 3600) / 60;
        int ss = (temp % 3600) % 60;
        return (hh < 10 ? ("0" + hh) : hh) + ":" +
                (mm < 10 ? ("0" + mm) : mm) + ":" +
                (ss < 10 ? ("0" + ss) : ss);
    }

    /**
     * 计算是否超时，超时多久
     * @param start 开始时间
     * @param second 超时几秒钟
     * @param now 当前时间
     * @return
     */
    public static Long durationSeconds(Date start, long second, Date now)
    {
        LocalDateTime time = dateToLocalDateTime(start);
        LocalDateTime startTime = localDateTimePlusSecond(time, second);
        LocalDateTime endTime = dateToLocalDateTime(now);
        Duration duration = Duration.between(startTime,endTime);
        long seconds = duration.getSeconds();
        return seconds;
    }

    /**
     * 增加 LocalDateTime ==> Date
     */
    public static Date toDate(LocalDateTime temporalAccessor)
    {
        ZonedDateTime zdt = temporalAccessor.atZone(ZoneId.systemDefault());
        return Date.from(zdt.toInstant());
    }

    /**
     * 增加 LocalDate ==> Date
     */
    public static Date toDate(LocalDate temporalAccessor)
    {
        LocalDateTime localDateTime = LocalDateTime.of(temporalAccessor, LocalTime.of(0, 0, 0));
        ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
        return Date.from(zdt.toInstant());
    }

    /**
     * 获取当前日期, 默认格式为yyyy-MM-dd
     *
     * @return String
     */
    public static String getDate()
    {
        return dateTimeNow(PATTERN_DATE);
    }

    public static final String getTime()
    {
        return dateTimeNow(PATTERN_DATETIME);
    }

    public static final String dateTimeNow()
    {
        return dateTimeNow(PATTERN_SHORT_DATETIME);
    }

    public static final String dateTimeNow(final String format)
    {
        return parseDateToStr(format, new Date());
    }

    public static final String dateTime(final Date date)
    {
        return parseDateToStr(PATTERN_DATE, date);
    }

    public static final String parseDateToStr(final String format, final Date date)
    {
        return new SimpleDateFormat(format).format(date);
    }

    public static final Date dateTime(final String format, final String ts)
    {
        try
        {
            return new SimpleDateFormat(format).parse(ts);
        }
        catch (ParseException e)
        {
            throw new RuntimeException(e);
        }
    }

    /**
     * 日期路径 即年/月/日 如2018/08/08
     */
    public static final String datePath()
    {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyy/MM/dd");
    }

    /**
     * 日期路径 即年/月/日 如20180808
     */
    public static final String dateTime()
    {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyyMMdd");
    }

    /**
     * 日期型字符串转化为日期 格式
     */
    public static Date parseDate(Object str)
    {
        if (str == null)
        {
            return null;
        }
        try
        {
            return parseDate(str.toString(), parsePatterns);
        }
        catch (ParseException e)
        {
            return null;
        }
    }

    /**
     * 获取服务器启动时间
     */
    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 + "分钟";
    }


    public static Date addHour(Date time, int hour) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        calendar.add(Calendar.HOUR_OF_DAY, hour);
        return calendar.getTime();
    }

}
@蓝眼睛
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
oracle 日期转换成毫秒数,ORACLE:毫秒与日期的相互转换,获取某天的信息
weixin_42110038的博客
04-12 2717
毫秒转换为日期SELECT TO_CHAR(1406538765000 / (1000 * 60 * 60 * 24) +TO_DATE('1970-01-01 08:00:00', 'YYYY-MM-DD HH:MI:SS'), 'YYYY-MM-DD HH24:MI:SS') AS CDATEFROM DUAL;日期转换毫秒SELECT TO_NUMBER(TO_DATE('2014-07-2...
python实现简单日期工具类
09-19
这里我们讨论的是一个简单的日期工具类的实现，这个类提供了一系列方法来处理日期和时间相关的操作。以下是对这些方法的详细解释： 1. `curMilis()` 和 `curSeconds()`：这两个函数分别返回当前时间的毫秒数和秒数...
Android分享之时间日期转换工具类DateTime
老司机-黄
10-31 4890
分享一个时间日期转换工具类DateTime源码在最后面！！注：时间日期表达格式（Android端基本都是这个格式） 字符 表达内容 yyyy 表示年份 MM 表示月份 dd 表示日 HH 表示小时，24小时制 hh 表示小时，12小时制 mm 表示分钟 ss 表示秒钟 还有一些不常见的属性，就不一一列举了。一、生成对象DateTime的对
Java中常用的工具类
二哈喇子！
07-06 1820
Object、包装类、SimpleDateFormat、数字格式化、字符串
通用工具类
yaoxin521123的博客
11-14 7855
通用工具类合集
java工具类怎么写_Java工具类
weixin_29128423的博客
02-15 1346
String基本方法方法作用string toUpperCase()小写字母转换成大写字母String toLowerCase()大写字母转换成小写字母String trim()去除字符串的首位空格String concat(String str)字符串连接int indexOf(String str)从前向后查找int lastIndexOf(String str)从后向前查找boolean c...
史上最全的常用开发工具类收集（持续更新中）
热门推荐
想你依然心痛的博客
05-24 6万+
API银行卡管理 → BankCheckcheckBankCard : 校验银行卡卡号是否合法 getBankCardCheckCode: 从不含校验位的银行卡卡号采用 Luhm 校验算法获得校验位 getNameOfBank : 通过银行卡的前六位确定判断银行开户行及卡种 SharePreference缓存数据 → AppSharePreferenceMgrput
时间日期类
BroRiver
01-08 2422
时间日期是每个程序都不可避免要操作到的数据类型。
Java时间处理工具类TimeUtils
weixin_42077074的博客
02-27 2698
以上方法笔者觉得没有必要再封装进工具类了，直接调用就行而其他的处理可以参考笔者的时间处理工具类 TimeUtils 的以下方法时间格式转化：转化成时间戳：转化成 LocalDateTimeformat()：转化成格式化日期字符串时间获取：获取当前时间戳（精确到毫秒）：获取当前的年（仅数值）：获取当前的月（仅数值）：获取当前的日（仅数值）：获取当前的年（格式为 yyyy 的字符串）：获取当前的年月（格式为 yyyy-MM 的字符串）
Hutool常用工具类
有多勉为其难的博客
09-29 2万+
Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。Hutool中的工具方法来自每个用户的精雕细琢，它涵盖了Java开发底层代码中的方方面面，它既是大型项目开发中解决小问题的利器，也是小型项目中的效率担当；Hutool是项目中“util”包友好的替代，它节省了开发人员对项目中公用类和公用工具方法的封装时间，使开发专注于业务，同时可以最大限度的避免封装不完善带来的bug。
一些常见好用的java工具类
aizhupo1314的博客
09-14 4755
文章目录1. 计算器2. 时间处理3. sha1加密4. HttpClient工具类5. json处理工具类 1. 计算器 import java.util.ArrayList; import java.util.Stack; /** * 计算使用util * * @author aa * @since 2020-11-16 */ public class CalculatorUtil { /** * 判断是否无效的运算结果 * * @param n
UTILS_日期处理工具类_
09-29
"UTILS_日期处理工具类_" 提供了一组用嵌入式语言实现的日期处理工具代码，帮助开发者更方便地进行时间相关的操作。下面我们将详细探讨这个工具类包含的主要知识点。 1. **日期和时间基础**： - 在编程中，日期和...
JavaScript日期工具类DateUtils定义与用法示例
10-18
主要介绍了JavaScript日期工具类DateUtils定义与用法,涉及javascript针对日期时间的获取、转换、比较、运算等相关操作技巧,需要的朋友可以参考下
工具类，日期处理，压缩等
05-14
本篇文章将详细讲解标题和描述中提到的几个关键知识点：工具类、日期处理以及压缩技术，包括MD5加密。 首先，我们来谈谈“工具类”。在Java或类似的面向对象编程语言中，工具类（Utility Class）通常包含一些静态...
DateUtil（日期工具类）
01-05
`toTimestamp(Date date)`方法将日期转换为Unix时间戳，而`fromTimestamp(long timestamp)`则从时间戳创建日期对象。 7. **日期区间操作** `dateRange(Date startDate, Date endDate)`可能返回一个日期集合，包含...
主流开发语言和开发环境介绍
weixin_44215445的博客
07-23 1584
主流开发语言和开发环境介绍
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 452
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 251
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 623
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
java常用工具类使用
06-11
Java 常用的工具类有很多，下面列举几个常用的工具类及其使用方法： 1. StringUtils类：提供常用的字符串处理方法，例如 isEmpty、isBlank、trim、substring 等。 2. ArrayUtils类：提供常用的数组处理方法，例如 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@蓝眼睛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值