`

Joda-Time 工具类使用

阅读更多
Joda-time 简单出来时间库。
导入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"));
    }

}


分享到:
评论

相关推荐

    joda-time-2.9.9

    《Joda-Time 2.9.9:时间日期处理的高效工具》 Joda-Time是Java平台上一个著名的日期和时间处理库,它弥补了Java标准库中日期时间处理的不足。在2.9.9这个版本中,我们看到了对日期时间操作的强大支持和丰富的功能...

    joda-time2.4源码及编译

    Joda-Time,作为Java日期和时间处理的一个重要库,为开发者提供了强大的日期和时间操作功能,尤其是在Java 8之前的版本,其易用性和灵活性远超内置的java.util.Date和Calendar类。Joda-Time 2.4是该库的一个稳定版本...

    joda-time-2.9.9-dist.tar.gz

    总结来说,Joda-Time 2.9.9是Java开发中处理日期和时间的强大工具,它的设计理念和丰富功能弥补了Java标准库的不足。无论是在新项目还是维护旧代码,Joda-Time都能提高开发效率,提供更精确的日期时间处理。在实际...

    joda-time源码

    虽然Joda-Time是一个独立的库,但它也提供了与Java内置日期时间类互操作的工具,方便迁移旧代码或与现有系统集成。 8. **性能** 相比于Java内置的日期时间API,Joda-Time在设计上更优化,性能上有一定优势。 9. ...

    joda-time-2.7-dist

    1. **DateTime**:这是Joda-Time中的核心类,代表一个特定的日期和时间点,包括年、月、日、小时、分钟、秒和毫秒。与`java.util.Date`相比,DateTime提供了更丰富的操作方法。 2. **LocalDate**和**LocalTime**:...

    joda-time2.10.1

    Java中处理时间与日期是很常见的操作,jdk中基础的工具类就是我们熟悉的Date和Calendar,然而这些工具类的api使用并不是很方便和强大。于是就诞生了Joda-Time这个专门处理日期时间的库。(JDK1.8的API已经重写了日期...

    Joda-Money-用于表示货币金额的Java库

    Joda-Money可以与其他Java库如Joda-Time(日期时间处理)配合使用,为金融应用提供完整的解决方案。例如,结合两者可以轻松计算跨越多个日期的利息。 ### 9. 最新版本特性 在JodaOrg-joda-money-bb2d8c0这个版本中...

    Java日期计算之Joda-Time

    在Java编程语言中,日期和时间的处理是一个重要的部分,特别是在开发复杂的业务逻辑或数据分析时。Joda-Time库是Java社区...通过实践和阅读博客文章"Java日期计算之Joda-Time",开发者可以更深入地理解这个强大的工具。

    joda-time2.0学习笔记

    Joda-Time 以其强大的功能、易用性和可扩展性成为了 Java 日期时间处理的首选工具。通过上述介绍,我们可以看到 Joda-Time 提供了许多实用的方法来帮助我们更好地处理日期和时间数据。对于任何涉及到日期时间处理的 ...

    Time工具包_Joda-Time_简介

    - **DateTime**: `DateTime`类是Joda-Time的主要类,它结合了日期和时间信息,支持各种操作,如加减时间周期、转换为其他时区等。 - **LocalDate**: 如果只需要日期部分,可以使用`LocalDate`,它不包含任何时间...

    Joda-Time标准Java日期和时间类的一个高质量替代品

    6. **线程安全**:Joda-Time的大部分类都是线程安全的,这在多线程环境下使用非常友好。 7. **日期间隔和时间间隔**:`Period`和`Interval`类可以用来表示日期之间的间隔和时间点之间的间隔,这在计算两个日期或...

    joda-time.zip

    《Joda-Time:Java日期和时间处理的利器》 在Java编程中,日期和时间的处理一直是开发者面临的一个挑战。由于Java内置的日期类(java....无论是新项目还是已有项目的升级,Joda-Time都是值得推荐的日期时间处理工具。

    joda-time-2.4-dist.zip

    在Hadoop或Hive作业中,有时需要对时间序列数据进行复杂的处理,如窗口聚合、时间区间分析等,Joda-Time可以提供强大的时间操作支持,帮助开发人员更方便地处理这类问题。 4. **Joda-Time与Hive集成**:尽管Hive有...

    joda time 工具

    Joda-Time提供了一组Java类包用于处理包括ISO8601标准在内的date和time。可以利用它把JDK Date和Calendar类完全替换掉,而且仍然能够提供很好的集成。 Joda-Time主要的特点包括: 1. 易于使用:Calendar让获取"正常...

    Joda - Time

    对于新项目,虽然可以直接使用Java 8的API,但Joda-Time仍然提供了许多额外的功能和工具,例如更复杂的时区处理。 总之,Joda-Time为Java开发人员提供了一套强大而灵活的日期和时间处理工具,使得日期时间相关的...

    joda-2.5.jar

    总的来说,Joda-Time 2.5是Java开发者的强大工具,它提供了全面、灵活且高效的日期时间处理功能。无论是简单的日常开发,还是复杂的时间计算需求,都能游刃有余。对于那些正在寻找替代Java标准库日期时间处理方式的...

    sfm-converter-joda-time-3.0.b1.zip

    结合这些知识点,"sfm-converter-joda-time-3.0.b1.zip"可能是将Joda-Time日期和时间数据转换为LAPPS Grid兼容格式的工具,其源代码存在于"org.lappsgrid.discriminator-master"目录下,遵循开源原则,允许开发者...

Global site tag (gtag.js) - Google Analytics