Joda Time出现的背景

在java1.0中，对日期和时间的支持只能依赖java.util.Date类。正如类名所表达的，这个类无法表示日期，只能以毫秒的精度表示时间。更糟糕的是它的易用性，由于某些未知的设计决策，这个类的易用性被深深的损害了，比如：年份的起始日期选择是1990年，月份的起始从0开始。在java1.1中，Date类中的很多方法被废弃了，取而代之的是java.util.Calendar类。Calendar类也有类似的问题和设计缺陷，导致使用这些方法写出的代码非常容易出错。比如月份依旧是从0开始计算（拿掉了由1990年开始计算年份这一设计）。更糟的是，有的特性只在某一个类有提供，比如用于语言无关方式格式化和解析日期或时间的DateFormat方法就只在Date类有。
DateFormat不是线程安全的，二个线程同时使用formatter解析日期，你可能会得到无法预期的结果。
在jdk1.8之前，这些问题使得用户们使用了第三方日期和时间库，比如Joda Time。jdk1.8大量借鉴了Joda Time特任。

Joda Time项目

Joda Time项目

Java SE 8之前的标准日期和时间类很差。 通过解决这个问题，Joda-Time在Java SE 8之前成为Java的实际标准日期和时间库。请注意，从Java SE 8起，用户被要求迁移到java.time（JSR-310） - JDK的核心部分，取代了这个项目。如果我们工作中的jdk版本是1.8版本之前可以使用Joda Time项目，Joda项目中其实包括的不止Joda Time，还包括Joda-Money ，Joda-Beans，Joda-Convert ，Joda-Collect，Joda Primitives项目，有兴趣可以在Joda官网地址中了解一下。

pom依赖：

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

第一个demo

package com.zhihao.joda;


import org.joda.time.DateTime;
import org.joda.time.LocalDate;

public class JodaTest2 {
    public static void main(String[] args) {
        DateTime today = new DateTime();
        DateTime datetorrow = today.plusDays(1);

        System.out.println(today.toString("yyyy-MM-dd"));//2017-06-26
        System.out.println(today.toString("yyyy-MM-dd HH:mm:ss"));//2017-06-26 22:04:03
        System.out.println(datetorrow.toString("yyyy-MM-dd"));//2017-06-27

        System.out.println("......................");

        //获得一个时间的副本，将day设置成自己制定的时间,不改变月份，只改变日期
        DateTime d1 = today.withDayOfMonth(1);
        System.out.println(d1.toString("yyyy-MM-dd"));//2017-06-01

        System.out.println("......................");

        LocalDate localDate = new LocalDate();
        System.out.println(localDate);//2017-06-26

        System.out.println("........................");

        //获取当前时间三个月后的月份的最后一天
        localDate = localDate.plusMonths(3).dayOfMonth().withMaximumValue();
        System.out.println(localDate);//2017-09-30

        System.out.println("........................");


        //计算二年前第三个月最后一天的日期
        DateTime dateTime = new DateTime();
        DateTime dateTime2 = dateTime.minusYears(2).monthOfYear().setCopy(3).
                dayOfMonth().withMinimumValue();
        System.out.println(dateTime2.toString("yyyy-MM-dd"));//2017-09-30

    }
}

import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.joda.time.format.DateTimeFormat;

import java.util.Date;

public class JodaTest3 {

    //将utc时间转换成java中的Date格式
    public static Date convertUTC2Date(String utcDate){
        try{
            DateTime dateTime =DateTime.parse(utcDate, DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSSZ"));
            return dateTime.toDate();
        }catch (Exception ex){
            return null;
        }
    }

    //将java中的date格式的时间转换成utc时间标准
    public static String ConvertDate2UTC(Date javaDate){
        DateTime dateTime = new DateTime(javaDate, DateTimeZone.UTC);
        return dateTime.toString();
    }

    //将Date类型转换成字符串
    public static String convertDate2LocalByDateformat(Date javaDate,String dateFormat){
        DateTime dateTime = new DateTime(javaDate);
        return dateTime.toString(dateFormat);
    }


    public static void main(String[] args) {
        System.out.println(JodaTest3.convertUTC2Date("2010-12-1T11:22:33.567Z"));//Wed Dec 01 19:22:33 CST 2010
        System.out.println(JodaTest3.ConvertDate2UTC(new Date()));//2017-06-26T14:09:53.606Z
        System.out.println(JodaTest3.convertDate2LocalByDateformat(new Date(),"yyyy-MM-dd HH:mm:ss"));//2017-06-26 22:09:53
    }
}

什么是UTC时间？
没有时区概念，比如utc时间 为2010-12-1T11:22:33.567Z，如果是表示时区概念一般2010-12-1T11:22:33.567+08:00

关于Joda Time其他的日期和时间api可以看其依赖包下的具体类，具体使用方式也很简单看齐javadoc即可。

java8时间api

LocalDate，LocalTime

LocalDate类的实例是一个不可变的对象，只提供了简单的日期，并不包含当前的时间信息（只关注与年月日）。也不附带任何与时区相关的信息。
LocalTime类关注时分秒。

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.MonthDay;

public class Java8TimeTest {
    public static void main(String[] args) {
        //关注与年月日
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate);  //2017-06-26

        System.out.println(localDate.getYear()); //2017，年
        System.out.println(localDate.getMonthValue()); //6，月
        System.out.println(localDate.getDayOfMonth()); //26，日
        System.out.println(localDate.getDayOfWeek()); //MONDAY,星期几
        System.out.println(localDate.lengthOfMonth()); //30,返回当前月份的长度
        System.out.println(localDate.isLeapYear());//false,是否是闰年

        System.out.println("------------------");

        LocalDate localDate2 = LocalDate.of(2017,4,1);
        System.out.println(localDate2); //2017-04-01

        System.out.println("------------------");

        //MonthDay关注月份和日
        LocalDate localDate3 = LocalDate.of(2017,3,25);
        MonthDay monthDay = MonthDay.of(localDate3.getMonth(),localDate3.getDayOfMonth());
        System.out.println(monthDay); //--03-25
        MonthDay monthDay2 = MonthDay.from(LocalDate.of(2014,3,25));
        System.out.println(monthDay2); //--03-25

        if(monthDay.equals(monthDay2)){
            System.out.println("equal");
        }else{
            System.out.println("not equal");
        }

        //关注与时分秒
        LocalTime time = LocalTime.now();
        System.out.println(time); //22:30:01.512
        System.out.println(time.getHour()); //22,时
        System.out.println(time.getMinute()); //30，分
        System.out.println(time.getSecond());  //01，秒

        LocalTime time2 = time.plusHours(3).plusMinutes(40);
        System.out.println(time2);  //02:10:01.512
    }
}

package com.zhihao.date;


import java.time.LocalDate;

public class Java8TimeTest1 {
    public static void main(String[] args) {
        //LocalDate的parse只能转换2007-12-03这样的格式的,不能解析的也会抛出一个RuntimeException
        //或者DateTimeParseException
        LocalDate date = LocalDate.parse("2014-03-18");
        LocalDate date2 = LocalDate.parse("2017-03-18");
        System.out.println(date);
        System.out.println(date2);

        LocalDate nowdate = LocalDate.now();
        String date3 = nowdate.toString();
        System.out.println(date3); //2017-06-26
    }
}

import java.time.*;
import java.time.temporal.ChronoUnit;

public class Java8TimeTest2 {
    public static void main(String[] args) {
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate); //2017-06-27

        //当前日期的二周后
        LocalDate localDate2 = localDate.plus(2, ChronoUnit.WEEKS);
        System.out.println(localDate2); //2017-07-11
        System.out.println("............");

        //当前时间的二个月之前
        LocalDate localDate3 = localDate.minus(2,ChronoUnit.MONTHS); 
        System.out.println(localDate3);//2017-04-27
        System.out.println("..............");

        Clock clock = Clock.systemDefaultZone(); //当前时区的时刻
        System.out.println(clock.millis()); //获得当前的毫秒数,1498529786982


        LocalDate localDate5 = LocalDate.now();
        LocalDate localDate6 = LocalDate.of(2017,4,12);
        System.out.println(localDate5.isBefore(localDate6));  //判断时间在什么时间之前
        System.out.println(localDate5.isAfter(localDate6)); //判断时间在什么时间之后
        System.out.println(localDate5.isEqual(localDate6)); //判断时间和什么时间相等
        System.out.println("..............");

    }
}

LocalDateTime

一个没有时区概念的日期-时间类在ISO-8601 日期系统中，比如2007-12-03T10:15:30

package com.zhihao.date;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;

public class Java8TimeTest11 {
    public static void main(String[] args) {
        LocalDateTime dt1 = LocalDateTime.of(2017, Month.APRIL,18,13,45,20);
        System.out.println(dt1);
        LocalDate date1 = dt1.toLocalDate(); //通过LocalDateTime获得LocalDate
        LocalTime time1 = dt1.toLocalTime(); //通过LocalDateTime获得LocalTime
        System.out.println("date1======="+date1+"time1===="+time1);
        
        LocalDate date = LocalDate.of(2014,02,26);
        LocalTime time = LocalTime.of(12,23,20);
        LocalDateTime dt2 = LocalDateTime.of(date,time);
        System.out.println(dt2);

        //LocalDate结合LocalTime成一个LocalDateTime
        LocalDateTime dt3 = date.atTime(13,45,20);
        System.out.println(dt3); //2014-02-26T13:45:20

        //LocalDate结合LocalTime成一个LocalDateTime
        LocalDateTime dt4 = date.atTime(time);
        System.out.println(dt4); //2014-02-26T12:23:20

        //LocalTime结合LocalDate成LocalDateTime
        LocalDateTime dt5 = time.atDate(date);
        System.out.println(dt5); //2014-02-26T12:23:20
    }
}

机器的日期和时间格式

作为人，我们习惯与以星期几，几号，几点，几分这样的方式理解日期和时间。对于计算机来说，建模时间最自然的格式是表示一个持续时间段上某个点的单一大整型数。这也是新的java.time.Instant类对时间建模的方式，基本上它是以Unix元年时间（传统的设定为UTC时区1970年1月1日午夜时分）开始经历的秒数进行计算。

package com.zhihao.date;
import java.time.Instant;

public class InstantTest {
    public static void main(String[] args) {
        Instant instant1 = Instant.ofEpochSecond(3);
        System.out.println(instant1);//1970-01-01T00:00:03Z

        //第一个参数是秒，第二个是纳秒参数，纳秒的存储范围是0至999,999,999
        Instant instant2 = Instant.ofEpochSecond(3,0);
        System.out.println(instant2);//1970-01-01T00:00:03Z

        //2s之后的在加上100万纳秒（1s）
        Instant instant3 = Instant.ofEpochSecond(2,1000000000);
        System.out.println(instant3); //1970-01-01T00:00:03Z

        Instant instant4 = Instant.ofEpochSecond(4,-1000000000);
        System.out.println(instant4); //1970-01-01T00:00:03Z

        Instant instant = Instant.now();
        System.out.println(instant);
    }
}

Duration与Period

package com.zhihao.date;

import java.time.*;

public class DurationTest {
    public static void main(String[] args) {
        LocalTime time1 = LocalTime.of(18,23,45);
        LocalTime time2 = LocalTime.of(23,34,56);

        Duration d1 = Duration.between(time1,time2);
        System.out.println(d1.getSeconds()); //18671


        LocalDateTime localDateTime1 = LocalDateTime.of(2016,Month.MAY,12,11,13,11);
        LocalDateTime localDateTime2 = LocalDateTime.of(2017, Month.AUGUST,18,23,45,20);

        Duration d2 = Duration.between(localDateTime1,localDateTime2);
        System.out.println(d2.getSeconds()); //40048329


        Instant instant1 = Instant.ofEpochSecond(3);
        Instant instant2 = Instant.ofEpochSecond(6);

        Duration d3 = Duration.between(instant1,instant2);
        System.out.println(d3.getSeconds()); //3

    }
}

以年，月，日方式建模，可以使用Period类。

import java.time.Instant;
import java.time.LocalDate;
import java.time.Period;

public class Java8TimeTest4 {
    public static void main(String[] args) {
        //LocalDate localDate1 = LocalDate.now();
        LocalDate localDate1 = LocalDate.of(2017,4,12);
        LocalDate localDate2 = LocalDate.of(2018,3,16);

        Period period = Period.between(localDate1,localDate2);
        System.out.println(period.getYears()); //获取相隔的年份差 0
        System.out.println(period.getMonths()); //获取相隔的月份差 11
        System.out.println(period.getDays()); //获取相隔的日子差 4

        System.out.println("...............");

        System.out.println(Instant.now()); //表示当前的不带时区的UTC标准时间,2017-04-12T14:40:29.309Z
    }
}

关于二者其他的api可以对照java api文档进行查看，比较浅显。

ZoneId和ZonedDateTime

新的java.time.ZoneId替代了老版本的java.util.TimeZone.

package com.zhihao.date;

import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Set;
import java.util.TreeSet;

public class Java8TimeTest3 {
    public static void main(String[] args) {
        //时区
        Set<String> sets = ZoneId.getAvailableZoneIds();

        //sets.stream().forEach(System.out::println);

        //构建一个TreeSet的匿名内部类,然后里面是个代码块表示在实例创建的时候执行这个代码块
        TreeSet<String> treeSet = new TreeSet<String>(){
            {
                addAll(sets);
            }
        };

        treeSet.stream().forEach(System.out::println);

        System.out.println("........................");

        ZoneId zoneId = ZoneId.of("Asia/Shanghai");
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);//2017-04-12T22:05:22.500

        ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime,zoneId);
        System.out.println(zonedDateTime); //2017-04-12T22:05:22.500+08:00[Asia/Shanghai]

        System.out.println("..................");

        YearMonth yearMonth = YearMonth.now();
        System.out.println(yearMonth); //2017-06
        System.out.println(yearMonth.lengthOfMonth());  //当月有多少天,30
        System.out.println(yearMonth.isLeapYear()); //是否是闰年,false

        System.out.println(".............");

        YearMonth yearMonth2 = YearMonth.of(2016,2);
        System.out.println(yearMonth2); //2016-02
        System.out.println(yearMonth2.lengthOfMonth()); //当前的月有多少天,29
        System.out.println(yearMonth2.lengthOfYear()); //一年有多少天,366
        System.out.println(yearMonth2.isLeapYear()); //是否是闰年,true

    }
}

package com.zhihao.date;

import java.time.LocalDateTime;
import java.time.Month;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;

public class ZoneOffsetTest {
    public static void main(String[] args) {
        ZoneOffset zoneOffset = ZoneOffset.of("-05:00");

        LocalDateTime dateTime = LocalDateTime.of(2014, Month.MARCH,18,13,45);
        OffsetDateTime offsetDateTime = OffsetDateTime.of(dateTime,zoneOffset);
        System.out.println(offsetDateTime); //2014-03-18T13:45-05:00
    }
}

java8还提供了一些别的日历系统，这些日历系统中的每一个都有一个ThaiBuddhistDate，MinguoDate，JapaneseDate对应的日志类。这边不做介绍。

格式化与解析时间对象DateTimeFormatter

创建格式器最简单的方法是通过DateTimeFormatter的静态工厂方法以及常量。像BASIC_ISO_DATE 和ISO_LOCAL_DATE这 样 的 常 量 是DateTimeFormatter类 的 预 定 义 实 例 。 所 有 的 DateTimeFormatter实例都能用于以一定的格式创建代表特定日期或时间的字符串。

和老的java.util.DateFormat相比较，所有的DateTimeFormatter实例都是线程安全的。所以，你能够以单例模式创建格式器实例，就像DateTimeFormatter所定义的那些常量，并能在多个线程间共享这些实例。DateTimeFormatter类还支持一个静态工厂方法，它可以按照某个特定的模式创建格式器.

package com.zhihao.date;

import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;

public class DateUtil {
    public static void main(String[] args) {
        Date date = new Date();
        Instant instant = date.toInstant();
        ZoneId zone = ZoneId.systemDefault();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
        DateTimeFormatter formatter =DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formatdate = localDateTime.format(formatter);
        System.out.println(formatdate);

        System.out.println("...........");
        LocalDate localDate = LocalDate.of(2017,3,17);
        //BASIC_ISO_DATE格式，20111203
        String str = localDate.format(DateTimeFormatter.BASIC_ISO_DATE);
        System.out.println(str);

        //DateTimeFormatter.ISO_LOCAL_DATE 格式 2017-03-17
        String str2 = localDate.format(DateTimeFormatter.ISO_LOCAL_DATE);
        System.out.println(str2);

        //定义
        String str3 = localDate.format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
        System.out.println(str3);

        LocalDate localDate1 = LocalDate.parse("20111203",DateTimeFormatter.BASIC_ISO_DATE);
        System.out.println(localDate1); //2011-12-03

        LocalDate localDate2 = LocalDate.parse("2017-03-17",DateTimeFormatter.ISO_LOCAL_DATE);
        System.out.println(localDate2); //2017-03-17

    }
}

使用TemporalAdjuster类更精确的操纵日期

使用TemporalAdjuster类更精确的操纵日期，不在局限于一次只能改变它的一个只，并且你还可以按照需求定义自己的日期转换器。

TemporalAdjusters工厂类为我们提供了很多便捷的操作。

package com.zhihao.date;

import java.time.DayOfWeek;
import java.time.LocalDate;
import static java.time.temporal.TemporalAdjusters.*;

public class TemporalAdjusterTest {
    public static void main(String[] args) {
        LocalDate localDate = LocalDate.of(2017,6,20);
        System.out.println(localDate); //2017-06-20

        //下一周的星期天
        LocalDate newdata = localDate.with(nextOrSame(DayOfWeek.SUNDAY));
        System.out.println(newdata); //2017-06-25

        LocalDate lastDate = localDate.with(lastDayOfMonth());
        System.out.println(lastDate); //2017-06-30

        //表示当前月的第二周的星期天
        LocalDate date1 = localDate.with(dayOfWeekInMonth(2,DayOfWeek.SUNDAY));
        System.out.println(date1); //2017-06-11

        //当前月的第一天
        LocalDate date2 = localDate.with(firstDayOfMonth());
        System.out.println(date2);

        //下个月的第一天
        LocalDate date3 = localDate.with(firstDayOfNextMonth());
        System.out.println(date3); //2017-07-01

        //明年的第一天
        LocalDate date4 = localDate.with(firstDayOfNextYear());
        System.out.println(date4); //2018-01-01

        //当前的以一天
        LocalDate date5 = localDate.with(firstDayOfYear());
        System.out.println(date5); //2017-01-01

        //本月第一个满足星期三的日期
        LocalDate date6 =localDate.with(firstInMonth(DayOfWeek.WEDNESDAY));
        System.out.println(date6); //2017-06-07

        //今年的最后一天
        LocalDate date7 = localDate.with(lastDayOfYear());
        System.out.println(date7); //2017-12-31

        //当月最后一个满足是星期四的日期
        LocalDate date8 = localDate.with(lastInMonth(DayOfWeek.TUESDAY));
        System.out.println(date8); //2017-06-30

        //下个星期天的日期
        LocalDate date9 = localDate.with(next(DayOfWeek.SUNDAY));
        System.out.println(date9); //2017-06-25
        System.out.println("localDate======="+localDate); //localDate=======2017-06-20
        LocalDate localDate2 = LocalDate.of(2017,6,20);
        LocalDate date13 = localDate2.with(nextOrSame(DayOfWeek.SUNDAY));
        System.out.println(date13);
        System.out.println("localDate2==="+localDate2);

        //上个星期天的日期
        LocalDate date10 = localDate.with(previous(DayOfWeek.SUNDAY));
        System.out.println(date10); //2017-06-18


        LocalDate date11 = localDate.with(previousOrSame(DayOfWeek.SUNDAY));
        System.out.println(date11); //2017-06-18

        LocalDate localDate1 = LocalDate.of(2017,6,7); //为本月第一个星期三
        LocalDate date12 = localDate1.with(previousOrSame(DayOfWeek.WEDNESDAY));
        System.out.println(date12); //2017-06-07
    }
}

next/previous 创建一个新的日期，并将其值设定为日期调整后或者调整前，第一个符合指定星 期几要求的日期。
nextOrSame/previousOrSame 创建一个新的日期，并将其值设定为日期调整后或者调整前，第一个符合指定星 期几要求的日期，如果该日期已经符合要求，直接返回该对象。

总结

java8提供的日期-时间对象是不可变的。操作的结果总是返回一个新的实列，老的日期时间对象不会发生改变。所以提供的这些类都很简单，但是需要我们多去使用它。