Java -- JodaTime第三方库操作时间

心已赠人 2023-09-23 18:36 145阅读 0赞

Java自带日期格式化工具DateFormat ，但是DateFormat 的所有实现，包括 SimpleDateFormat 都不是线程安全的，因此不应该在多线程序中使用，除非是在对外线程安全的环境中使用，如将 SimpleDateFormat 限制在 ThreadLocal 中。如果不这么做，在解析或者格式化日期的时候，可能会获取到一个不正确的结果。所以，通常我们使用第三方库Joda Time来进行时间相关的操作

## 一、导入JodaTime ##

#### 1、在Maven中 ####

<dependency>
                <groupId>joda-time</groupId>
                <artifactId>joda-time</artifactId>
                <version>2.10.5</version>
            </dependency>

#### 2、在Gradle中 ####

compile 'joda-time:joda-time:2.10.5'

##  ##

## 二、JodaTime核心类 ##

使用最多的五个日期时间类：

\- Instant - 不可变的类，用来表示时间轴上一个瞬时的点（时间戳）

\- DateTime - 不可变的类，用来替换JDK的Calendar类

\- LocalDate - 不可变的类，表示一个本地的日期，而不包含时间部分（没有时区信息）

\- LocalTime - 不可变的类，表示一个本地的时间，而不包含日期部分（没有时区信息）

\- LocalDateTime - 不可变的类，表示一个本地的日期－时间（没有时区信息）

// joda创建时间对象时需要指定时区，如果不指定，默认会把时区设置为运行代码的机器所在的时区
            DateTime dateTime0 = new DateTime(2022, 7, 3, 11, 0, 0).withZone(DateTimeZone.forID("Asia/Shanghai"));
            System.out.println("dateTime0----" + dateTime0.toDate());

## 三、DateTime实例 ##

当使用JodaTime的时候，首先你要获取一个DateTime实例，然后用它的其他方法串联起来实现强大的功能

/**
             * 1、当使用JodaTime的时候，首先你要获取一个DateTime实例，然后用它的其他方法串联起来实现强大的功能。想要获取一个DateTime实例，你有很多种方式
             * */
            // 方式1：使用系统时间构造DateTime实例
            DateTime dateTime = new DateTime();
    
            // 方式2：使用具体的时间构造DateTime实例，该方法有许多重载版本
            DateTime dateTime1 = new DateTime(
                    2022, // year
                    1,    // month
                    1,    // day
                    0,    // hour (midnight is zero)
                    0,    // minute
                    0,    // second
                    0     // milliseconds
            );
    
            // 方式3：使用Calendar构造DateTime实例
            DateTime dateTime2 = new DateTime(Calendar.getInstance());
            System.out.println("dateTime2----" + dateTime2.toDate());
    
            // 方式4：使用其他DateTime实例构造DateTime实例
            DateTime dateTime3 = new DateTime(dateTime);
            System.out.println("dateTime3----" + dateTime3.toDate());
    
            // 方式5：使用字符串构造DateTime实例
            DateTime dateTime4 = new DateTime("2022-01-26T13:30:00-06:00");
            DateTime dateTime5 = new DateTime("2022-01-26");
            System.out.println("dateTime4----" + dateTime4.toDate());
            System.out.println("dateTime5----" + dateTime5.toDate());

## 四、DateTime方法 ##

DateTime中有许多的方法，这里我们将常用的方法分成两类。一类是在方法中返回DateTime的那种，一类是在方法中返回Property类型的那种。显然，后面的那种继续串联操作的话，就需要调用Property的实例方法了

#### 1、返回DateTime ####

/**
             * 2、DateTime的方法
             * DateTime中有许多的方法，这里我们将常用的方法分成两类。
             * 一类是在方法中返回DateTime的那种，一类是在方法中返回Property类型的那种。
             * 后面的那种继续串联操作的话，就需要调用Property的实例方法了
             * */
            // 指定的时间单位上面增加指定的值
            DateTime dateTime00 = dateTime.plusDays(1);
            System.out.println("dateTime00----" + dateTime00);
    
            // 指定的时间单位上面减少指定的值
            DateTime dateTime6 = dateTime.minusDays(1);
            System.out.println("dateTime6----" + dateTime6);
    
            // 除了增减日期还可以直接指定它的指定时间单位上面的值
            DateTime dateTime7 = dateTime.withYear(2020);
            System.out.println("dateTime7----" + dateTime7);
    
            // 按照指定的格式输出日期
            System.out.println(dateTime.toString("E MM/dd/yyyy HH:mm:ss.SSS"));

#### 2、返回Property ####

以通过DateTime实例的millisOfDay() dayOfYear() minuteOfDay()等一些列方法可以获取到该DateTime的一个Property实例，然后可以通过调用Property的方法再获取一个DateTime实例。也就是说，实际上调用DateTime的方法获取Property实例是为了对指定的时间位置的信息进行修改。比如，对“日”进行修改，对“年”进行修改等等。修改了之后还是要获取一个DateTime实例，然后再继续进行后续的操作。

实际上每次调用DateTime的方法获取Property实例的时候，都会将当前的DateTime作为参数传入。然后当调用了指定的方法之后又会调用DateTime实例的withMillis()方法判断时间是否发生变化，如果发生了变化就创建一个新实例并返回

/**
             * 3、使用Property
             * 可以通过DateTime实例的millisOfDay() dayOfYear() minuteOfDay()等一些列方法可以获取到该DateTime的一个Property实例，然后可以通过调用Property的方法再获取一个DateTime实例。也就是说，实际上调用DateTime的方法获取Property实例是为了对指定的时间位置的信息进行修改。比如，对“日”进行修改，对“年”进行修改等等。修改了之后还是要获取一个DateTime实例，然后再继续进行后续的操作。
             * 实际上每次调用DateTime的方法获取Property实例的时候，都会将当前的DateTime作为参数传入。然后当调用了指定的方法之后又会调用DateTime实例的withMillis()方法判断时间是否发生变化，如果发生了变化就创建一个新实例并返回
             * */
            // 这里先用dayOfMonth获取一个Property实例，然后调用它的withMaximumValue方法
            // 它的含义是指定日期的其他日期不变，月份变成最大的之后返回一个DateTime，即如果传入的是2022年5月1日，将返回2022年5月31日，年，月，秒等位置不变，日变成该月最大的。
            DateTime dateTime000 = dateTime.dayOfMonth().withMaximumValue();
            DateTime dateTime111 = dateTime.dayOfMonth().withMinimumValue();
            System.out.println("dateTime000----" + dateTime000);
            System.out.println("dateTime111----" + dateTime111);

#### 3、其他静态方法 ####

/**
             * 4、其他静态方法
             * */
            System.out.println("Days.daysBetween(dateTime1, dateTime).getDays()----" + Days.daysBetween(dateTime1, dateTime).getDays());
            System.out.println("Months.monthsBetween(dateTime1, dateTime).getMonths()----" + Months.monthsBetween(dateTime1, dateTime).getMonths());
            System.out.println("Years.yearsBetween(dateTime1, dateTime).getYears()----" + Years.yearsBetween(dateTime1, dateTime).getYears());

#### 4、封装工具类 ####

package com.mycompany.joda;
    
    import org.joda.time.*;
    import org.joda.time.format.DateTimeFormat;
    import org.joda.time.format.DateTimeFormatter;
    
    import java.util.Date;
    
    public class JodaTimeUtil {
    
        private static final String PATTERN_STANDARD = "yyyy-MM-dd HH:mm:ss";
        private static final String PATTERN_DATE = "yyyy-MM-dd";
        private static final String PATTERN_TIME = "HH:mm:ss";
    
        /**
         * date类型 -> string类型
         *
         * @param date
         * @return
         */
        public static String date2Str(Date date) {
            if (date == null) {
                return "";
            }
            DateTime dateTime = new DateTime(date);
            return dateTime.toString(PATTERN_STANDARD);
        }
    
        /**
         * date类型 -> string类型
         *
         * @param date
         * @param formatPattern
         * @return
         */
        public static String date2Str(Date date, String formatPattern) {
            if (date == null) {
                return "";
            }
            DateTime dateTime = new DateTime(date);
            return dateTime.toString(formatPattern);
        }
    
        /**
         * string类型 -> date类型
         *
         * @param timeStr
         * @return
         */
        public static Date str2Date(String timeStr) {
            DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(PATTERN_STANDARD);
            DateTime dateTime = dateTimeFormatter.parseDateTime(timeStr);
            return dateTime.toDate();
        }
    
        /**
         * 获取指定时间
         * @param year 年
         * @param month 月
         * @param day 日
         * @param hour 时
         * @param minute 分
         * @param seconds 秒
         * @return yyyy-MM-dd HH:mm:ss
         */
        public static String getAssignedDateTime(Integer year, Integer month, Integer day, Integer hour, Integer minute, Integer seconds) {
            DateTime dt = new DateTime(year, month, day, hour, minute, seconds);
            String date = dt.toString(PATTERN_STANDARD);
            return date;
        }
        /**
         * 获取指定日期
         * @param year
         * @param month
         * @param day
         * @return
         */
        public static String getAssignedDate(Integer year, Integer month, Integer day) {
            LocalDate dt = new LocalDate(year, month, day);
            String date = dt.toString(PATTERN_DATE);
            return date;
        }
        /**
         * 获取指定时间
         * @param hour
         * @param minutes
         * @param seconds
         * @return
         */
        public static String getAssignedTime(Integer hour, Integer minutes, Integer seconds) {
            LocalTime dt = new LocalTime(hour, minutes, seconds);
            String date = dt.toString(PATTERN_TIME);
            return date;
        }
        /**
         * 判断date日期是否过期(与当前时刻比较)
         *
         * @param date
         * @return
         */
        public static boolean isTimeExpired(Date date) {
            if (null == date) {
                return true;
            }
            String timeStr = date2Str(date);
            return isBeforeNow(timeStr);
        }
    
        /**
         * 判断date日期是否过期(与当前时刻比较)
         *
         * @param timeStr
         * @return
         */
        public static boolean isTimeExpired(String timeStr) {
            if (StringUtils.isBlank(timeStr)) {
                return true;
            }
    
            return isBeforeNow(timeStr);
        }
    
        /**
         * 判断timeStr是否在当前时刻之前
         *
         * @param timeStr
         * @return
         */
        private static boolean isBeforeNow(String timeStr) {
            DateTimeFormatter format = DateTimeFormat.forPattern(PATTERN_STANDARD);
            DateTime dateTime = DateTime.parse(timeStr, format);
            return dateTime.isBeforeNow();
        }
    
    
        /**
         * 加天数
         *
         * @param date
         * @param days
         * @return
         */
        private static Date plusDays(Date date, Integer days) {
            if (null == date) {
                return null;
            }
            days = null == days ? 0 : days;
    
            DateTime dateTime = new DateTime(date);
            dateTime = dateTime.plusDays(days);
    
            return dateTime.toDate();
        }
    
        /**
         * 减天数
         *
         * @param date
         * @param days
         * @return
         */
        private static Date minusDays(Date date, Integer days) {
            if (null == date) {
                return null;
            }
            days = null == days ? 0 : days;
    
            DateTime dateTime = new DateTime(date);
            dateTime = dateTime.minusDays(days);
    
            return dateTime.toDate();
        }
    
    
        /**
         * 加分钟
         *
         * @param date
         * @param minutes
         * @return
         */
        private static Date plusMinutes(Date date, Integer minutes) {
            if (null == date) {
                return null;
            }
            minutes = null == minutes ? 0 : minutes;
    
            DateTime dateTime = new DateTime(date);
            dateTime = dateTime.plusMinutes(minutes);
    
            return dateTime.toDate();
        }
    
        /**
         * 减分钟
         *
         * @param date
         * @param minutes
         * @return
         */
        private static Date minusMinutes(Date date, Integer minutes) {
            if (null == date) {
                return null;
            }
            minutes = null == minutes ? 0 : minutes;
    
            DateTime dateTime = new DateTime(date);
            dateTime = dateTime.minusMinutes(minutes);
    
            return dateTime.toDate();
        }
    
        /**
         * 加月份
         *
         * @param date
         * @param months
         * @return
         */
        private static Date plusMonths(Date date, Integer months) {
            if (null == date) {
                return null;
            }
            months = null == months ? 0 : months;
    
            DateTime dateTime = new DateTime(date);
            dateTime = dateTime.plusMonths(months);
    
            return dateTime.toDate();
        }
    
        /**
         * 减月份
         *
         * @param date
         * @param months
         * @return
         */
        private static Date minusMonths(Date date, Integer months) {
            if (null == date) {
                return null;
            }
            months = null == months ? 0 : months;
    
            DateTime dateTime = new DateTime(date);
            dateTime = dateTime.minusMonths(months);
    
            return dateTime.toDate();
        }
    
        /**
         * 判断target是否在开始和结束时间之间
         *
         * @param target
         * @param startTime
         * @param endTime
         * @return
         */
        public static boolean isBetween(Date target, Date startTime, Date endTime) {
            if (null == target || null == startTime || null == endTime) {
                return false;
            }
    
            DateTime dateTime = new DateTime(target);
            return dateTime.isAfter(startTime.getTime()) && dateTime.isBefore(endTime.getTime());
        }
    
        /**
         * 获取当前系统时间
         * @return yyyy-MM-dd HH:mm:ss
         */
        public static String getCurrentDateTime() {
            DateTime dt = new DateTime();
            String time = dt.toString(PATTERN_STANDARD);
            return time;
        }
        /**
         * 获取当前日期
         * @return
         */
        public static String getCurrentDate() {
            DateTime dt = new DateTime();
            String date = dt.toString(PATTERN_DATE);
            return date;
        }
        /**
         * 获取系统当前时间按照指定格式返回
         * @return
         */
        public static String getCurrentTime() {
            DateTime dt = new DateTime();
            String time = dt.toString(PATTERN_TIME);
            return time;
        }
        /**
         * 获取当前是一周星期几
         * @return
         */
        public static String getWeek() {
            DateTime dts = new DateTime();
            String week = null;
            switch (dts.getDayOfWeek()) {
                case DateTimeConstants.SUNDAY:
                    week = "星期日";
                    break;
    
                case DateTimeConstants.MONDAY:
                    week = "星期一";
                    break;
    
                case DateTimeConstants.TUESDAY:
                    week = "星期二";
                    break;
                case DateTimeConstants.WEDNESDAY:
                    week = "星期三";
                    break;
                case DateTimeConstants.THURSDAY:
                    week = "星期四";
                    break;
                case DateTimeConstants.FRIDAY:
                    week = "星期五";
                    break;
                case DateTimeConstants.SATURDAY:
                    week = "星期六";
                default:
                    break;
            }
            return week;
        }
        /**
         * 获取指定时间是一周的星期几
         * @param year
         * @param month
         * @param day
         * @return
         */
        public static String getWeek(Integer year, Integer month, Integer day) {
            LocalDate dts = new LocalDate(year, month, day);
            String week = null;
            switch (dts.getDayOfWeek()) {
                case DateTimeConstants.SUNDAY:
                    week = "星期日";
                    break;
                case DateTimeConstants.MONDAY:
                    week = "星期一";
                    break;
                case DateTimeConstants.TUESDAY:
                    week = "星期二";
                    break;
                case DateTimeConstants.WEDNESDAY:
                    week = "星期三";
                    break;
                case DateTimeConstants.THURSDAY:
                    week = "星期四";
                    break;
                case DateTimeConstants.FRIDAY:
                    week = "星期五";
                    break;
                case DateTimeConstants.SATURDAY:
                    week = "星期六";
                    break;
    
                default:
                    break;
            }
            return week;
        }
        /**
         * 计算两个时间相差多少天
         * @param startDate
         * @param endDate
         * @return
         */
        public static Integer diffDay(Date startDate, Date endDate) {
            if (startDate == null || endDate == null) {
                return null;
            }
            DateTime dt1 = new DateTime(startDate);
            DateTime dt2 = new DateTime(endDate);
            int day = Days.daysBetween(dt1, dt2).getDays();
            return Math.abs(day);
        }
    }

参考链接

[Java第三方库JodaTime的具体使用是怎样的\_编程设计\_IT干货网][Java_JodaTime_IT]

[Java_JodaTime_IT]: https://www.itgh.cn/post/hcfj2b8.html

发表评论取消回复

表情：

评论列表（有 0 条评论，145人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java -- JodaTime第三方库操作时间

Java自带日期格式化工具DateFormat ，但是DateFormat 的所有实现，包括 SimpleDateFormat 都不是线程安全的，因此不应该在多线程序中使用，除

心已赠人/ 2023年09月23日 18:36/ 0 赞/ 146 阅读

相关 python 第三方库

requests 模块具体详见：[https://requests.kennethreitz.org//zh\_CN/latest/user/quickstart.html

朴灿烈づ我的快乐病毒、/ 2023年06月12日 09:43/ 0 赞/ 16 阅读

相关 pip安装第三方库时下载超时错误

pip安装时timed out 1.问题描述执行pip install pyinstaller命令时报错： File "c:\python\python

电玩女神/ 2022年12月30日 07:45/ 0 赞/ 167 阅读

相关安装go第三方库

安装GO第三方库 go help查看命令 The commands are: build compile packages

偏执的太偏执、/ 2022年09月23日 03:49/ 0 赞/ 363 阅读

相关 Python第三方库

文章目录第三方库 time库 random库 Pyinstaller库 jieba库 word

雨点打透心脏的1/2处/ 2022年09月11日 03:15/ 0 赞/ 863 阅读

相关 python安装第三方库

1.cmd下使用pip install “第三方库名” 2.使用easy\_install（但是不推荐，删除的时候很麻烦） 3.下载第三方库，把后缀whl改成zip，解压后

太过爱你忘了你带给我的痛/ 2022年08月20日 04:25/ 0 赞/ 368 阅读

相关 java第三方库

网上摘抄的java第三方库的介绍，记录下 1.Apache Commons Apache Commons Lang、Apache Commons Collect

浅浅的花香味﹌/ 2022年07月24日 05:00/ 0 赞/ 367 阅读

相关 java第三方库

一、testng和selenium-java TestNG是一个测试框架，其灵感来自JUnit和NUnit，但引入了一些新的功能，使其功能更强大，使用更方便。 Test

偏执的太偏执、/ 2022年02月16日 08:18/ 0 赞/ 413 阅读

相关 pip 用第三方镜像安装第三方库

运行环境：Python 3.6.0 Python 自带 pip ，可以通过 pip 安装大部分的第三方库，但是在这里还是有很大的缺陷的，因为我们要访问的第三方库的所在服

不念不忘少年蓝@/ 2021年12月18日 21:57/ 0 赞/ 649 阅读

相关 dart 引入库、第三方库

系统内置库 import 'dart:math' import 'dart:io' import 'dart:convert'

桃扇骨/ 2021年07月25日 02:35/ 0 赞/ 560 阅读