TimeUtil

于 2023-08-31 20:06:41 发布
阅读量93 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42704512/article/details/132610587
版权

TimeUtil

@Slf4j
public class TimeUtil {

    /**
     * 1分钟的秒时间
     */
    public static final long ONE_MINUTE_IN_SECONDS = 60L;

    /**
     * 1小时的分钟时间
     */
    public static final long ONE_HOUR_IN_MINUTES = 60L;

    /**
     * 一分钟的毫秒时长
     */
    public static final long ONE_MINUTE_IN_MILLISECONDS = ONE_MINUTE_IN_SECONDS * 1000;

    /**
     * 一小时的毫秒时长
     */
    public static final long ONE_HOUR_IN_MILLISECONDS = 60L * ONE_MINUTE_IN_MILLISECONDS;
    /**
     * 一天的毫秒时长
     */
    public static final long ONE_DAY_IN_MILLISECONDS = 24L * ONE_HOUR_IN_MILLISECONDS;
    /**
     * 一周的毫秒时长
     */
    public static final long ONE_WEEK_IN_MILLISECONDS = 7 * 24L * ONE_HOUR_IN_MILLISECONDS;

    /**
     * 一天的分鐘时长
     */
    public static final int ONE_DAY_IN_MIN = (int) (24 * ONE_MINUTE_IN_SECONDS);

    /**
     * 一天的秒时长
     */
    public static final long ONE_DAY_IN_SECONDS = ONE_DAY_IN_MIN * ONE_MINUTE_IN_SECONDS;


    /**
     * 1秒的时长
     */
    public static final long ONE_MILLS = 1000L;

    /**
     * 2015-02-23 12:12:12格式
     */
    public static final String DEFAULT_FORMAT = "yyyy-MM-dd HH:mm:ss";

    /**
     * 时间格式 2019-03-09-00-00-00
     */
    public static final String TIME_FORMAT_1 = "yyyy-MM-dd-HH-mm-ss";

    /**
     * 时间格式 20190309
     */
    public static final String TIME_FORMAT_2 = "yyyyMMdd";

    /**
     * 时间格式 2019-03-09
     */
    public static final String TIME_FORMAT_3 = "yyyy-MM-dd";

    /**
     * 时间格式 12:12:12
     */
    public static final String TIME_FORMAT_4 = "HH:mm:ss";

    /**
     * 验证日期字符串是否是YYYY-MM-dd格式或者YYYYMMdd
     *
     * @param str str
     * @return boolean
     */
    public static boolean checkDateFormat(String str) {
        boolean flag = false;
        String regex = "^((\\d{2}(([02468][048])|([13579][26]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][1235679])|([13579][01345789]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))(\\s(((0?[0-9])|([1-2][0-3]))\\:([0-5]?[0-9])((\\s)|(\\:([0-5]?[0-9])))))?$";
        Pattern pattern1 = Pattern.compile(regex);
        Matcher isNo = pattern1.matcher(str);
        if (isNo.matches()) {
            flag = true;
        }
        return flag;
    }

    public static int getNowOfSeconds() {
        return (int) (System.currentTimeMillis() / 1000);
    }

    public static long getNowOfMills() {
        return System.currentTimeMillis();
    }

    /**
     * 获取每天0点开始，每过2个小时的时间戳
     *
     * @param point 间隔小时，例如:间隔2小时，就传2，单位：小时
     * @return
     */
    public static long getNowEvenTime(int point) {
        if (point <= 0) {
            return 0;
        }
        int hourTest = getNowHour();
        int mo = hourTest / point;
        int hour = (mo + 1) * point;
        int dayAdd = 0;
        if (hour >= 24) { //跨天
            hour = 0;
            //TODO  可能增加几天
            dayAdd = 1;
        }

        LocalDateTime localDateTime = LocalDateTime.of(LocalDateTime.now().getYear(), LocalDateTime.now().getMonth(), LocalDateTime.now().getDayOfMonth(), hour, 0, 0);
        if (dayAdd > 0) {
            localDateTime = localDateTime.plusDays(dayAdd);
        }
        ZoneId zone = ZoneId.systemDefault();
        Instant instant = localDateTime.atZone(zone).toInstant();
        return instant.toEpochMilli();
    }

    /**
     * 获取当前时间的小时数
     *
     * @return
     */
    public static int getNowHour() {
        return LocalDateTime.now().getHour();
    }

    /**
     * 判断两个时间是否是同一天
     *
     * @param sourceTime
     * @param targetTime
     * @return
     */
    public static boolean isSameDay(long sourceTime, long targetTime) {
        Instant instant1 = Instant.ofEpochMilli(sourceTime);
        LocalDateTime localDateTime1 = LocalDateTime.ofInstant(instant1, ZoneId.systemDefault());
        long day1 = localDateTime1.getLong(ChronoField.EPOCH_DAY);

        Instant instant2 = Instant.ofEpochMilli(targetTime);
        LocalDateTime localDateTime2 = LocalDateTime.ofInstant(instant2, ZoneId.systemDefault());
        long day2 = localDateTime2.getLong(ChronoField.EPOCH_DAY);

        return day1 == day2;

    }

    public static int distanceDay(long sourceTime, long targetTime) {
        Instant instant1 = Instant.ofEpochMilli(sourceTime);
        LocalDateTime localDateTime1 = LocalDateTime.ofInstant(instant1, ZoneId.systemDefault());
        long day1 = localDateTime1.getLong(ChronoField.EPOCH_DAY);

        Instant instant2 = Instant.ofEpochMilli(targetTime);
        LocalDateTime localDateTime2 = LocalDateTime.ofInstant(instant2, ZoneId.systemDefault());
        long day2 = localDateTime2.getLong(ChronoField.EPOCH_DAY);
        int dis = (int)(day1-day2);
        return Math.abs(dis);

    }

    /**
     * 当前日期是本月第几周
     * @return
     */
    public static int getWeekOfMonth() {
        Calendar c = Calendar.getInstance();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        return c.get(Calendar.WEEK_OF_MONTH);
    }

    /*
     * 获取time日零点秒时间
     *
     * @param time 时间（秒）
     */
    public static int dayZeroSecondsFromTime(long time) {
        return (int) (dayZeroMillsFromTime(time * 1000L) / 1000);
    }

    /**
     * 获取time日零点毫秒时间
     *
     * @param time 时间 （毫秒）
     */
    public static long dayZeroMillsFromTime(long time) {
        Instant instant = Instant.ofEpochMilli(time);
        LocalDateTime dt = LocalDateTime.ofInstant(instant, ZoneId.systemDefault())
                .withHour(0)
                .withMinute(0)
                .withSecond(0)
                .withNano(0);
        return dt.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
    }

    /**
     * 格式化时间
     *
     * @param time
     * @param format
     * @return
     */
    public static String timeFormat(long time, String format) {
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern(format);
        LocalDateTime ldt = LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault());
        return ldt.format(dtf);
    }

    public static String timeFormat(LocalDateTime time, String format) {
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern(format);
        return time.format(dtf);
    }

    public static Date timeFormat(String dateStr, String format) {
        DateFormat df = new SimpleDateFormat(format);
        try {
            return df.parse(dateStr);
        } catch (Exception e) {
            log.error("日期转换错误:{}", dateStr);
            return null;
        }
    }

    /**
     * 获取今天已经过去的分钟数
     *
     * @return
     */
    public static int getTodayOfMinute() {
        int nowOfMinutes = getNowOfMinutes();
        int zeroMinuteFromNow = dayZeroMinuteFromNow();
        return nowOfMinutes - zeroMinuteFromNow;
    }

    public static int getNowOfMinutes() {
        return (int) (System.currentTimeMillis() / 1000 / 60);
    }

    /**
     * 获取今天零点的分钟数
     */
    public static int dayZeroMinuteFromNow() {
        LocalDateTime localDateTime = LocalDate.now().atStartOfDay();
        return (int) (localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli() / 60000);
    }

    /**
     * 获取下一天的零点的分钟数
     */
    public static int nextDayZeroMinuteFromNow() {
        return (dayZeroMinuteFromNow() + ONE_DAY_IN_MIN);
    }

    /**
     * 获取今天零点的秒数
     */
    public static int dayZeroSecondsFromNow() {
        return (int) (dayZeroMillsFromNow() / ONE_MILLS);
    }

    /**
     * 获取今天零点的毫秒数
     * @return
     */
    public static long dayZeroMillsFromNow() {
        LocalDateTime localDateTime = LocalDate.now().atStartOfDay();
        return localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
    }

    /**
     * 判断今天是否为某年的同一周
     *
     * @return boolean
     */
    public static boolean isSameWeek(long oldTime) {
        LocalDateTime nowTime = LocalDateTime.now();
        Instant instant = Instant.ofEpochMilli(oldTime);
        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

        int nowIndex = nowTime.getDayOfWeek().getValue();
        int oldIndex = dateTime.getDayOfWeek().getValue();
        if (nowTime.getYear() != dateTime.getYear() && oldIndex == nowIndex) {
            return false;
        }

        nowTime = nowTime.plusDays(7 - nowIndex).withHour(0).withMinute(0).withSecond(0).withNano(0);
        dateTime = dateTime.plusDays(7 - oldIndex).withHour(0).withMinute(0).withSecond(0).withNano(0);

        return dateTime.compareTo(nowTime) == 0;
    }

    /**
     * 判断指定的时间是否是今天
     *
     * @param time 毫秒数
     * @return
     */
    public static boolean isToday(long time) {
        Instant instant = Instant.ofEpochMilli(time);
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        return localDateTime.toLocalDate().isEqual(LocalDate.now());
    }

    /**
     * 获取距离time的自然天数
     *
     * @param time
     * @return
     */
    public static int getNaturalDayFromTime(long time) {
        Instant instant = Instant.ofEpochMilli(time);
        LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        long day = ldt.getLong(ChronoField.EPOCH_DAY);
        long nowDay = LocalDate.now().getLong(ChronoField.EPOCH_DAY);
        return (int) (nowDay - day);
    }

    /**
     * 通过时间秒毫秒数判断两个时间的间隔天数
     *
     * @param time1
     * @param time2
     * @return
     */
    public static int betweenDay(long time1, long time2) {
        return (int) (Math.abs(time1 - time2) / ONE_DAY_IN_MILLISECONDS);
    }

    /**
     * 获取指定时间的自然天数
     *
     * @param time
     * @return
     */
    public static long getDay(long time) {
        Instant instant = Instant.ofEpochMilli(time);
        LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

        return ldt.getLong(ChronoField.EPOCH_DAY);
    }

    public static LocalDateTime getDateTimeOfMillis(long millis) {
        Instant instant = Instant.ofEpochMilli(millis);
        ZoneId zone = ZoneId.systemDefault();
        return LocalDateTime.ofInstant(instant, zone);
    }

    /**
     * 获取指定日期的时间戳
     *
     * @param year
     * @param month       从1开始
     * @param day
     * @param hour
     * @param minute
     * @param second
     * @param milliSecond
     * @return
     */
    public static long getTimeInMillis(int year, int month, int day, int hour, int minute, int second,
                                       int milliSecond) {
        LocalDateTime ldt = LocalDateTime.of(year, month, day, hour, minute, second, milliSecond * 1000_000);
        return ldt.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
    }

    /**
     * 获取今天已经过去的秒数
     *
     * @return
     */
    public static int getTodayOfSeconds() {
        int nowOfSeconds = getNowOfSeconds();
        int zeroSecondsFromNow = dayZeroSecondsFromNow();
        return nowOfSeconds - zeroSecondsFromNow;
    }

    /**
     * 获得当前周的周一0点时间戳
     * @return
     */
    public static long getTheWeekZeroTime(){
        LocalDate localDate = LocalDate.now();
        LocalDate day2 = localDate.with(TemporalAdjusters.previous(java.time.DayOfWeek.SUNDAY)).plusDays(1);
        return day2.atStartOfDay().toInstant(ZoneOffset.of("+8")).toEpochMilli();
    }
    /**
     * 获得当前周的周一0点时间戳miao
     * @return
     */
    public static int getTheNextZeroSecondTime(){
        return (int) (getTheWeekZeroTime()/1000) + 7*24*3600;
    }
}
小左和小右
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TimeUtil.java
09-04
TimeUtil.java--处理有关时间的工具类，包括格式化时间（[yyyyMMddHHmmss]转换成[yyyy-MM-dd HH:mm:ss]），格式化时间（[yyyy-MM-dd]转换成[yyyy年MM月dd日]），格式化时间(由源格式的时间改为目的格式的时间)，格式...
TimeUtil 时间工具类
一切都会好起来的，即使不在今天
06-18 1575
import java.sql.Timestamp; import java.text.ParseException; import java.text.ParsePosition; import java.text.SimpleDateFormat; import java.time.LocalDate; import java.time.Month; import java.util.*; /** * 超详细的时间工具类 * * @author Administrator */ publ..
最全时间工具类timeUtile
一叶知城的博客
12-10 540
写代码最烦的是什么，写个日期啥，或者判断一个日期是什么星座还要写一大推代码，岂不是很累，伸手党福利来了 import android.support.annotation.NonNull; import java.io.IOException; import java.net.URL; import java.net.URLConnection; import java.text.Dat...
TimeUnit的具体用法
weixin_57763462的博客
08-24 2431
TimeUnit是java.util.concurrent包下面的一个类，表示给定单元粒度的时间段 主要作用 时间颗粒度转换 延时 常用的颗粒度 1 2 3 4 5 TimeUnit.DAYS//天 TimeUnit.HOURS//小时 TimeUnit.MINUTES//分钟 TimeUnit.SECONDS//秒 TimeUnit.M...
java TimeUtil使用
记录点滴
07-20 2196
TimeUtil是在 java.util.concurrent包下的，是一个枚举类。 常用方法： TimeUnit. 常量.方法 把上边的常量转化为 天、小时、分钟、秒、毫秒 以DAYS 和HOURS常量为例： （1）TimeUtil.DAYS. 把 天 转化为 秒 .toSeconds、毫秒 .toMillis、天 .toDay、小时 .toHours、分钟 .toMinutes （2）TimeUnit.HOURS. 把 小时 转化为 秒 .toSeconds、天 .t...
java中常用的时间处理类TimeUtil
飞翔的心
07-31 1919
timeUtil时间工具类开发总结
时间工具TimeUtil
09-14
使用时、分、秒构造一个时间 设置时间字段的值
Utils_timeutil
05-17
Android 时间处理工具类 TimeConstants类：时间单位相差倍率常量。 TimeUtils类：时间处理类。 包括方法： 时间戳、Date、时间字符串相互转换。 判断时间差。 判断是否为今天、是否闰年。 判断第几周。...
Java获取各种常用时间方法
Anas_小白
12-03 471
这个引用别人的一个 有关JAVA时间方法  觉得比较实用  这个就转载了 import java.text.DateFormat; import java.text.ParsePosition; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; ...
Java中时间的计算 年月日小时分钟秒毫秒微秒
菜鸟是如何练成的
05-31 1435
[code="java"] //用到的类 DateUtils //这个类存在于 org.apache.commons.lang.time.DateUtils; //也就是这个包 commons-lang-2.3.jar //API文档在这里 //http://commons.apache.org/lang/api-2.5/org/apache/commons/lan...
TimeUtil工具类
monica1_1的博客
12-04 1408
Emm……这个工具类很强大，做保留…… import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.List; public c...
时间处理工具类 - TimeUtils
weixin_30877755的博客
05-06 180
说明：这个工具类是从同事代码上拉取到的，大概也是来自他人，记录在册，小小工具类，可以省去很多烦恼。 代码： package com.xfc.utils;// TODO import java.sql.Date; import java.sql.Timestamp; import java.text.ParseException; import java.text.Simp...
TimeUtil时间转换工具类
weixin_41306673的博客
12-06 608
package com.example.demo.utils; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; import java.util.TimeZone; public class TimeUtil { public static ThreadLoc...
时间处理工具类TimeUtil
weixin_33714884的博客
11-05 164
转自：https://cnblogs.com/ityouknow/p/5662753.html 功能 Date与String之间的互相转换，以及一些特殊格式的时间字符串处理 代码   1 /** 2 * 类名：TimeUtil.java 类描述：时间处理工具 3 * 4 * @author wader 创建时间：2011-12-02 11:03 5 */ 6 pu...
java.util.concurrent.TimeUtil类
u014785687的博客
11-09 6800
TimeUnit是java.util.concurrent包下面的一个枚举类，TimeUnit提供了可读性更好的线程暂停操作、不同时间之间的转换操作。它包含 7 个枚举实例NANOSECONDS （毫微秒， 千分之一微秒） public static final TimeUnit NANOSECONDSMICROSECONDS （微秒， 千分之一毫秒） public static final T
时间工具类TimeUtils
喵咪妮的博客
04-12 696
public class TimeUtils { /** * 返回当前时间戳 * * @return 当前时间戳, 单位 毫秒 */ public static long now() { return System.currentTimeMillis(); } /** * 把long类型的时间戳转
js时间工具 MyTimeUtil.js
jianfpeng241241的专栏
07-18 1178
// 对Date的扩展，将 Date 转化为指定格式的String // 月(M)、日(d)、小时(H)、分(m)、秒(s)、季度(q) 可以用 1-2 个占位符， // 年(y)可以用 1-4 个占位符，毫秒(S)只能用 1 个占位符(是 1-3 位的数字) // 例子： // (new Date()).Format("yyyy-MM-dd HH:mm:ss.S") ==
module 'timeutil' has no attribute 'DtCalc'
最新发布
05-16
这个错误提示意味着在 timeutil 模块中没有名为 DtCalc 的属性或类。这可能是因为你在程序中尝试调用 timeutil.DtCalc，但是 timeutil 模块中没有定义这个类或属性。 你需要检查 timeutil 模块中是否存在名为 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值