代码家的乐趣
- 浏览: 66715 次
-
文章分类
最新评论
-
小灯笼：
ZooKeeper分布式专题与Dubbo微服务入门网盘地址：h ...
dubbo+zookeeper构建高可用分布式集群 -
qingfengxiu1985：
有没有全部工程代码？发一个呗，邮箱:qingfengxiu19 ...
mongodb+spring +morphia完整版框架搭建
Joda-time 简单出来时间库。
导入maven 工程jar包
引用的http://rensanning.iteye.com/blog/1546652
DateUtils 工具类：JodaTime 对时间的加减 处理起来 特别方便 ，快速。自己在工作写了一下公用的方法。
导入maven 工程jar包
<dependency> <groupId>joda-time</groupId> <artifactId>joda-time</artifactId> <version>2.9.2</version> </dependency>
package com.downjoy.date;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import org.eclipse.jdt.internal.compiler.ast.SuperReference;
import org.joda.time.DateTime;
import org.joda.time.DateTimeConstants;
import org.joda.time.DateTimeZone;
import org.joda.time.Duration;
import org.joda.time.Interval;
import org.joda.time.LocalDate;
import org.joda.time.LocalTime;
import org.joda.time.Period;
import org.joda.time.PeriodType;
public class JodaTimeTest {
//方法一：取系统点间
DateTime dt1 = new DateTime();
//方法二：通过java.util.Date对象生成
DateTime dt2 = new DateTime(new Date());
//方法三：指定年月日点分秒生成(参数依次是：年,月,日,时,分,秒,毫秒)
static DateTime dt3 = new DateTime(2016, 6, 15, 14, 47, 0, 0);
//方法四：ISO8601形式生成
DateTime dt4 = new DateTime("2016-06-15");
DateTime dt5 = new DateTime("2016-06-20T13:14:00");
//只需要年月日的时候
LocalDate ld1 = new LocalDate(2016, 6, 15);
//只需要时分秒毫秒的时候
LocalTime localTime = new LocalTime(13, 30, 26, 0);// 1:30:26PM
DateTime dt = new DateTime();
int year = dt.getYear();//年
int month = dt.getMonthOfYear();//月
int day = dt.getDayOfMonth(); //天
int day1 = dt.getDayOfWeek();//天
int day2 = dt.getDayOfYear();//天
int week = dt.getDayOfWeek(); //星期
int hour = dt.getHourOfDay(); //点
int min = dt.getMinuteOfHour(); //分
int sec = dt.getSecondOfMinute(); //秒
int msec = dt.getMillisOfSecond(); //毫秒
@Override
public String toString() {
System.out.println(year+","+month+","+day+","+day1+","+day2+","+week+","+hour+","+min+","+sec+","+msec);
return "";
}
public void week(){
//星期
DateTime dts = new DateTime();
switch (dts.getDayOfWeek()) {
case DateTimeConstants.SUNDAY:
System.out.println("星期日");
break;
case DateTimeConstants.MONDAY:
System.out.println("星期一");
break;
case DateTimeConstants.TUESDAY:
System.out.println("星期二");
break;
case DateTimeConstants.WEDNESDAY:
System.out.println("星期三");
break;
case DateTimeConstants.THURSDAY:
System.out.println("星期四");
break;
case DateTimeConstants.FRIDAY:
System.out.println("星期五");
break;
case DateTimeConstants.SATURDAY:
System.out.println("星期6");
default:
break;
}
}
public static void main(String[] args) {
JodaTimeTest jodaTime =new JodaTimeTest();
// jodaTime.toString();
// System.out.println(dt3);
//转换成java.util.Date对象
DateTime datetime = new DateTime();
Date d1 = new Date(datetime.getMillis());
Date d2 = datetime.toDate();
//转换成java.util.Calendar对象
Calendar c1 = Calendar.getInstance();
c1.setTimeInMillis(datetime.getMillis());
Calendar c2 = datetime.toCalendar(Locale.getDefault());
jodaTime.week();
System.out.println(d1);
System.out.println(d2);
System.out.println(c1.getTimeInMillis());
System.out.println(datetime);
String s1 = datetime.toString("yyyy/MM/dd hh:mm:ss.SSSa"); //2016/06/15 04:12:22.012下午
String s2 = datetime.toString("yyyy-MM-dd HH:mm:ss"); //2016-06-15 16:12:22
String s3 = datetime.toString("EEEE dd MMMM, yyyy HH:mm:ssa"); //星期三 15 六月, 2016 16:12:22下午
String s4 = datetime.toString("yyyy/MM/dd HH:mm ZZZZ"); //2016/06/15 16:12 +08:00
String s5 = datetime.toString("yyyy/MM/dd HH:mm Z"); //2016/06/15 16:12 +0800
System.out.println(s1+"/n"+s2+"/n"+s3+"/n"+s4+"/n"+s5);
}
DateTime dt01 = new DateTime();
//昨天
DateTime yesterday = dt01.minusDays(1);
//明天
DateTime tomorrow = dt01.plusDays(1);
//1个月前
DateTime before1month = dt01.minusMonths(1);
//3个月后
DateTime after3month = dt01.plusMonths(3);
//2年前
DateTime before2year = dt01.minusYears(2);
//5年后
DateTime after5year = dt01.plusYears(5);
DateTime d1 = new DateTime("2012-02-01");
DateTime d2 = new DateTime("2012-05-01");
//和系统时间比
boolean b1 = d1.isAfterNow();
boolean b2 = d1.isBeforeNow();
boolean b3 = d1.isEqualNow();
//和其他日期比
boolean f1 = d1.isAfter(d2);
boolean f2 = d1.isBefore(d2);
boolean f3 = d1.isEqual(d2);
DateTime begin = new DateTime("2012-02-01");
DateTime end = new DateTime("2012-05-01");
//计算区间毫秒数
Duration d = new Duration(begin, end);
long time = d.getMillis();
//计算区间天数
Period p = new Period(begin, end, PeriodType.days());
int days = p.getDays();
//计算特定日期是否在该区间内
Interval i = new Interval(begin, end);
boolean contained = i.contains(new DateTime("2012-03-01"));
//默认设置为日本时间
DateTime dt001 = new DateTime();
//伦敦时间
DateTime dt002 = new DateTime(DateTimeZone.forID("Europe/London"));
//月末日期
DateTime lastday = dt.dayOfMonth().withMaximumValue();
//90天后那周的周一
DateTime firstday = dt.plusDays(90).dayOfWeek().withMinimumValue();
}
引用的http://rensanning.iteye.com/blog/1546652
DateUtils 工具类：JodaTime 对时间的加减 处理起来 特别方便 ，快速。自己在工作写了一下公用的方法。
package com.jiayu.pingxing.core.common;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.*;
import javax.annotation.Nullable;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.TimeZone;
/**
* <p>
* <p/>
* </p>
* Created by Zw(小猫)
* Date: 17/3/17.
*/
public class DateUtils {
public static final long SECOND = 1000; //1秒 java已毫秒为单位
public static final long MINUTE = SECOND * 60; //一分钟
public static final long HOUR = MINUTE * 60; // 一小时
public static final long DAY = HOUR * 24; //一天
public static final long WEEK = DAY * 7; //一周
public static final long YEAR = DAY * 365; //一年
public static final String FORMAT_TIME = "yyyy-MM-dd HH:mm:ss"; //默认时间格式
public static final String FORMAT_TIME_MINUTE = "yyyy-MM-dd HH:mm"; //默认时间格式
public static final String FORTER_DATE = "yyyy-MM-dd"; //默认日期格式
private static final Map<Integer, String> WEEK_DAY = new HashMap<Integer, String>();
static {
WEEK_DAY.put(7, "星期六");
WEEK_DAY.put(1, "星期天");
WEEK_DAY.put(2, "星期一");
WEEK_DAY.put(3, "星期二");
WEEK_DAY.put(4, "星期三");
WEEK_DAY.put(5, "星期四");
WEEK_DAY.put(6, "星期五");
}
/**
* 获取当前系统时间
* @return yyyy-MM-dd HH:mm:ss
*/
public static String getCurrentTime() {
DateTime dt = new DateTime();
String time = dt.toString(FORMAT_TIME);
return time;
}
/**
* 获取系统当前时间按照指定格式返回
* @param pattern yyyy/MM/dd hh:mm:a
* @return
*/
public static String getCurrentTimePattern(String pattern) {
DateTime dt = new DateTime();
String time = dt.toString(pattern);
return time;
}
/**
* 获取当前日期
* @return
*/
public static String getCurrentDate() {
DateTime dt = new DateTime();
String date = dt.toString(FORTER_DATE);
return date;
}
/**
* 获取当前日期按照指定格式
* @param pattern
* @return
*/
public static String getCurrentDatePattern(String pattern) {
DateTime dt = new DateTime();
String date = dt.toString(pattern);
return date;
}
/**
* 按照时区转换时间
* @param date
* @param timeZone 时区
* @param parrten
* @return
*/
@Nullable
public static String format(Date date, TimeZone timeZone, String parrten) {
if (date == null) {
return null;
}
SimpleDateFormat sdf = new SimpleDateFormat(parrten);
sdf.setTimeZone(timeZone);
return sdf.format(date);
}
/**
* 获取指定时间
* @param year 年
* @param month 月
* @param day 天
* @param hour 小时
* @param minute 分钟
* @param seconds 秒
* @return yyyy-MM-dd HH:mm:ss
*/
public static String getPointTime(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(FORMAT_TIME);
return date;
}
/**
*
* @param year 年
* @param month 月
* @param day 天
* @param hour 小时
* @param minute 分钟
* @param seconds 秒
* @param parrten 自定义格式
* @return parrten
*/
public static String getPointTimePattern(Integer year, Integer month, Integer day, Integer hour, Integer minute, Integer seconds, String parrten) {
DateTime dt = new DateTime(year, month, day, hour, minute, seconds);
String date = dt.toString(parrten);
return date;
}
/**
* 获取指定日期
* @param year
* @param month
* @param day
* @return
*/
public static String getPointDate(Integer year, Integer month, Integer day) {
LocalDate dt = new LocalDate(year, month, day);
String date = dt.toString(FORTER_DATE);
return date;
}
/**
* 获取指定日期 返回指定格式
* @param year
* @param month
* @param day
* @param parrten
* @return
*/
public static String getPointDatParrten(Integer year, Integer month, Integer day, String parrten) {
LocalDate dt = new LocalDate(year, month, day);
String date = dt.toString(parrten);
return date;
}
/**
* 获取当前是一周星期几
* @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 getWeekPoint(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 date
* @return yyyy-MM-dd HH:mm:ss
*/
@Nullable
public static String format(Date date) {
if (date == null) {
return null;
}
SimpleDateFormat format = new SimpleDateFormat(FORMAT_TIME);
return format.format(date);
}
/**
* 格式化日期字符串
* @param date 日期
* @param pattern 日期格式
* @return
*/
@Nullable
public static String format(Date date, String pattern) {
if (date == null) {
return null;
}
SimpleDateFormat format = new SimpleDateFormat(pattern);
return format.format(date);
}
/**
* 解析日期
* @param date 日期字符串
* @param pattern 日期格式
* @return
*/
@Nullable
public static Date parse(String date, String pattern) {
if (date == null) {
return null;
}
Date resultDate = null;
try {
resultDate = new SimpleDateFormat(pattern).parse(date);
} catch (ParseException e) {
}
return resultDate;
}
/**
* 解析日期yyyy-MM-dd HH:mm:ss
* @param date 日期字符串
* @return
*/
@Nullable
public static Date parse(String date) {
if (date == null) {
return null;
}
try {
return new SimpleDateFormat(FORMAT_TIME).parse(date);
} catch (ParseException e) {
return null;
}
}
/**
* 解析日期 yyyy-MM-dd HH:mm:ss
* @param timestamp
* @return
*/
public static String format(Long timestamp, String pattern) {
String dateStr = "";
if (null == timestamp || timestamp.longValue() < 0) {
return dateStr;
}
try {
Date date = new Date(timestamp);
SimpleDateFormat format = new SimpleDateFormat(pattern);
dateStr = format.format(date);
} catch (Exception e) {
// ignore
}
return dateStr;
}
/**
* 解析日期 yyyy-MM-dd HH:mm:ss
* @param timestamp
* @return
*/
public static String format(Long timestamp) {
String dateStr = "";
if (null == timestamp || timestamp.longValue() < 0) {
return dateStr;
}
try {
Date date = new Date(timestamp);
SimpleDateFormat format = new SimpleDateFormat(FORMAT_TIME);
dateStr = format.format(date);
} catch (Exception e) {
// ignore
}
return dateStr;
}
/**
*获取当前时间前几天时间,按指定格式返回
* @param days
* @return
*/
public static String forwardDay(Integer days, String format) {
DateTime dt = new DateTime();
DateTime y = dt.minusDays(days);
return y.toString(format);
}
/**
*获取当前时间前几天时间
* @param days
* @return
*/
public static Date forwardDay(Integer days) {
DateTime dt = new DateTime();
DateTime y = dt.minusDays(days);
return y.toDate();
}
/**
* 获取指定时间之后或者之前的某一天00:00:00 默认返回当天
* @param days
* @return
*/
public static Date day00(Integer days, String date, String zimeZone) throws Throwable {
DateTime dt;
TimeZone timeZone;
try {
if (StringUtils.isBlank(zimeZone)) {
timeZone = TimeZone.getDefault();
} else {
timeZone = TimeZone.getTimeZone(zimeZone);
}
if (StringUtils.isBlank(date)) {
dt = new DateTime().withZone(DateTimeZone.forTimeZone(timeZone)).toLocalDateTime().toDateTime();
} else {
dt = new DateTime(date).withZone(DateTimeZone.forTimeZone(timeZone)).toLocalDateTime().toDateTime();
}
} catch (Exception e) {
throw new Throwable(e);
}
DateTime y = dt.minusDays(days).withHourOfDay(0).withMinuteOfHour(0).withSecondOfMinute(0);
return y.toDate();
}
/**
*获取指定时间之后或者之前的某一天23:59:59 默认返回当天
* @param days 偏移量
* @return
*/
public static Date day59(Integer days, String date, String zimeZone) throws Throwable {
DateTime dt;
TimeZone timeZone;
try {
if (StringUtils.isBlank(zimeZone)) {
timeZone = TimeZone.getDefault();
} else {
timeZone = TimeZone.getTimeZone(zimeZone);
}
if (StringUtils.isBlank(date)) {
dt = new DateTime().withZone(DateTimeZone.forTimeZone(timeZone)).toLocalDateTime().toDateTime();
} else {
dt = new DateTime(date).withZone(DateTimeZone.forTimeZone(timeZone)).toLocalDateTime().toDateTime();
}
} catch (Exception e) {
throw new Throwable(e);
}
DateTime y = dt.minusDays(days).withHourOfDay(23).withMinuteOfHour(59).withSecondOfMinute(59);
return y.toDate();
}
/**
* 计算两个时间相差多少天
* @param startDate
* @param endDate
* @return
*/
@Nullable
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);
}
/**
* 获取某月之前,之后某一个月最后一天,24:59:59
* @return
*/
public static Date lastDay(Date date, Integer month) {
DateTime dt1;
if (month == null) {
month = 0;
}
if (date == null) {
dt1 = new DateTime().minusMonths(month);
} else {
dt1 = new DateTime(date).minusMonths(month);
}
DateTime lastDay = dt1.dayOfMonth().withMaximumValue().
withHourOfDay(23).withMinuteOfHour(59).withSecondOfMinute(59);
return lastDay.toDate();
}
/**
*获取某月月之前,之后某一个月第一天,00:00:00
* @return
*/
public static Date firstDay(Date date, Integer month) {
DateTime dt1;
if (month == null) {
month = 0;
}
if (date == null) {
dt1 = new DateTime().minusMonths(month);
} else {
dt1 = new DateTime(date).minusMonths(month);
}
DateTime lastDay = dt1.dayOfMonth().withMinimumValue().
withHourOfDay(0).withMinuteOfHour(0).withSecondOfMinute(0);
return lastDay.toDate();
}
public static Date addDay(Date date, int offset) {
DateTime dt1;
if (date == null) {
dt1 = new DateTime().plusDays(offset);
return dt1.toDate();
}
dt1 = new DateTime(date).plusDays(offset);
return dt1.toDate();
}
/**
* 传入日期时间与当前系统日期时间的比较,
* 若日期相同，则根据时分秒来返回 ,
* 否则返回具体日期
* @return 日期或者 xx小时前||xx分钟前||xx秒前
*/
@Nullable
public static String getNewUpdateDateString(Date now, Date createDate) {
if (now == null || createDate == null) {
return null;
}
Long time = (now.getTime() - createDate.getTime());
if (time > (24 * 60 * 60 * 1000)) {
return time / (24 * 60 * 60 * 1000) + "天前";
} else if (time > (60 * 60 * 1000)) {
return time / (60 * 60 * 1000) + "小时前";
} else if (time > (60 * 1000)) {
return time / (60 * 1000) + "分钟前";
} else if (time >= 1000) {
return time / 1000 + "秒前";
}
return "刚刚";
}
public static void main(String[] args) throws Throwable {
// System.out.println(format(day00(1,null)));
// System.out.println(format(day59(1,null)));
// System.out.println(lastDay(new Date(),2));
// System.out.println(firstDay(null,0));
// TimeZone zone1=TimeZone.getTimeZone("GMT+8");
// TimeZone zone2=TimeZone.getTimeZone("GMT-5");
// System.out.println(format(new Date(),zone1,FORMAT_TIME));
// System.out.println(format(new Date(),zone2,FORMAT_TIME));
//
// System.out.println(format(day00(0,"2017-5-11","GMT+0")));
// System.out.println(format(day00(0,"2017-5-11","GMT+8")));
// System.out.println(format(day00(0,"2017-5-11","GMT-8")));
// Date date1 =parse("2017-05-11 17:53:52");
//
// System.out.println(diffDay(date1,new Date()));
// DateTime dateTime = new DateTime().withDayOfWeek(1);
//
// DateTime dateTime1 = new DateTime().withDayOfWeek(7).withTime(0, 0, 0, 0);
// System.out.println(format(dateTime.toDate()));
//
// System.out.println(format(dateTime1.toDate()));
System.out.println(format(new Date(),"MM/dd"));
}
}
分享到：
发表评论
-
Java 设计模式源码
2020-08-17 20:17 141经过一段时间学习和实践，整理了绝大多数设计模式源码demo 。 ... -
mac ngrok 使用
2018-12-20 18:22 873ngrok 是一个反向代理，通过在公共端点和本 ... -
Java元组学习
2018-12-19 15:38 619在Java 中我们平时用的接口和方法 只是单一 ... -
密码学2 密码安全注意
2018-11-30 15:11 6041.Java API支持 位于java.security包及子 ... -
base64 和 base32 源码解析
2018-11-30 14:19 1483package com.zd.demo; import ... -
maven 常用命令
2018-01-22 14:43 365mvn compile 编译源代码 mvn test-comp ... -
sql语法
2017-09-05 11:40 1按照查询in里条件排序sql SELECT * from p ... -
sql语法
2017-09-05 11:06 382按照查询in里条件排序sql SELECT * from p ... -
上传excel 通过url下载文件
2017-07-06 16:22 1058/** * 下载图片 */ ... -
idea使用,破解，mybatis plugin使用破解
2017-03-21 09:30 1173idea 最新激活方式：http://blog.csdn.ne ... -
多线程实现原理并发机制
2017-03-07 20:29 819进程： 查询百度大致可以理解为一段具有独 ... -
网络编程TCP/IP协议组
2017-03-04 13:42 557TCP/IP是个协议组： 主要可以分为4层，分别是应 ... -
Guava包的ListenableFuture解析
2016-10-09 13:40 1045package com.downjoy.test.guava. ... -
spring+guava事件异步分发处理
2016-10-09 09:56 4370Guava是Google开源的一个Java基础类库，它在Goo ... -
httpUtil工具和apche httpclient 工具类使用
2016-09-26 15:38 2408httpUtil请求网络请求工具： package demo ... -
mongodb+spring +morphia完整版框架搭建
2016-09-09 10:22 5716Morphia是一个开放源代 ... -
mongodb注解详解
2016-09-06 09:26 40541、@Entity 如果你想通过Morphia把你的对 ... -
自定义MD5加盐加密方式代码实现
2016-09-02 16:45 5061按照自己的理解对密码加盐加密。当用户注册时候会先生成盐值 ... -
密码学
2016-08-25 11:14 5711 密码学简介 2.1 ... -
kafka
2016-08-11 14:08 719Kafka is a distributed,partiti ...
相关推荐
《Joda-Time 2.9.9：时间日期处理的高效工具》 Joda-Time是Java平台上一个著名的日期和时间处理库，它弥补了Java标准库中日期时间处理的不足。在2.9.9这个版本中，我们看到了对日期时间操作的强大支持和丰富的功能...
Joda-Time，作为Java日期和时间处理的一个重要库，为开发者提供了强大的日期和时间操作功能，尤其是在Java 8之前的版本，其易用性和灵活性远超内置的java.util.Date和Calendar类。Joda-Time 2.4是该库的一个稳定版本...
总结来说，Joda-Time 2.9.9是Java开发中处理日期和时间的强大工具，它的设计理念和丰富功能弥补了Java标准库的不足。无论是在新项目还是维护旧代码，Joda-Time都能提高开发效率，提供更精确的日期时间处理。在实际...
虽然Joda-Time是一个独立的库，但它也提供了与Java内置日期时间类互操作的工具，方便迁移旧代码或与现有系统集成。 8. **性能** 相比于Java内置的日期时间API，Joda-Time在设计上更优化，性能上有一定优势。 9. ...
1. **DateTime**：这是Joda-Time中的核心类，代表一个特定的日期和时间点，包括年、月、日、小时、分钟、秒和毫秒。与`java.util.Date`相比，DateTime提供了更丰富的操作方法。 2. **LocalDate**和**LocalTime**：...
Java中处理时间与日期是很常见的操作，jdk中基础的工具类就是我们熟悉的Date和Calendar，然而这些工具类的api使用并不是很方便和强大。于是就诞生了Joda-Time这个专门处理日期时间的库。（JDK1.8的API已经重写了日期...
Joda-Money可以与其他Java库如Joda-Time（日期时间处理）配合使用，为金融应用提供完整的解决方案。例如，结合两者可以轻松计算跨越多个日期的利息。 ### 9. 最新版本特性 在JodaOrg-joda-money-bb2d8c0这个版本中...
在Java编程语言中，日期和时间的处理是一个重要的部分，特别是在开发复杂的业务逻辑或数据分析时。Joda-Time库是Java社区...通过实践和阅读博客文章"Java日期计算之Joda-Time"，开发者可以更深入地理解这个强大的工具。
Joda-Time 以其强大的功能、易用性和可扩展性成为了 Java 日期时间处理的首选工具。通过上述介绍，我们可以看到 Joda-Time 提供了许多实用的方法来帮助我们更好地处理日期和时间数据。对于任何涉及到日期时间处理的 ...
- **DateTime**: `DateTime`类是Joda-Time的主要类，它结合了日期和时间信息，支持各种操作，如加减时间周期、转换为其他时区等。 - **LocalDate**: 如果只需要日期部分，可以使用`LocalDate`，它不包含任何时间...
6. **线程安全**：Joda-Time的大部分类都是线程安全的，这在多线程环境下使用非常友好。 7. **日期间隔和时间间隔**：`Period`和`Interval`类可以用来表示日期之间的间隔和时间点之间的间隔，这在计算两个日期或...
《Joda-Time：Java日期和时间处理的利器》 在Java编程中，日期和时间的处理一直是开发者面临的一个挑战。由于Java内置的日期类（java....无论是新项目还是已有项目的升级，Joda-Time都是值得推荐的日期时间处理工具。
在Hadoop或Hive作业中，有时需要对时间序列数据进行复杂的处理，如窗口聚合、时间区间分析等，Joda-Time可以提供强大的时间操作支持，帮助开发人员更方便地处理这类问题。 4. **Joda-Time与Hive集成**：尽管Hive有...
Joda-Time提供了一组Java类包用于处理包括ISO8601标准在内的date和time。可以利用它把JDK Date和Calendar类完全替换掉，而且仍然能够提供很好的集成。 Joda-Time主要的特点包括： 1. 易于使用:Calendar让获取"正常...
对于新项目，虽然可以直接使用Java 8的API，但Joda-Time仍然提供了许多额外的功能和工具，例如更复杂的时区处理。 总之，Joda-Time为Java开发人员提供了一套强大而灵活的日期和时间处理工具，使得日期时间相关的...
总的来说，Joda-Time 2.5是Java开发者的强大工具，它提供了全面、灵活且高效的日期时间处理功能。无论是简单的日常开发，还是复杂的时间计算需求，都能游刃有余。对于那些正在寻找替代Java标准库日期时间处理方式的...
结合这些知识点，"sfm-converter-joda-time-3.0.b1.zip"可能是将Joda-Time日期和时间数据转换为LAPPS Grid兼容格式的工具，其源代码存在于"org.lappsgrid.discriminator-master"目录下，遵循开源原则，允许开发者...