全面解析Java日期时间API

时区

• gmt（greenwich mean time）：格林尼治时间，格林尼治标准时间的正午是指当太阳横穿格林尼治子午线时（也就是在格林尼治上空最高点时）的时间。
• utc（universal time coordinated）：统一协调时间，其以原子时秒长为基础，在时刻上尽量接近于格林尼治标准时间，标准 utc 时间格式 yyyy-mm-dd't'hh:mm:ss.sssxxx。

格林尼治时间已经不再被作为标准时间使用，utc 是最主要的世界时间标准。

java提供了获取当前时间的方法

• system.currenttimemillis()，返回当前时间，以毫秒为单位，表示的就是当前时刻至 1970-01-01 00:00:00.000 的毫秒差值。返回的long值可以用来初始化java.util.date, java.sql.date, java.sql.timestamp和java.util.gregoriancalendar对象。
• system.nanotime()，返回一个时间值(系统计时器的当前值)，精确到纳秒。它是由 jvm 提供的一个时间，主要用来精确衡量两个时间段之间的时间

例如，要测量一些代码需要执行多长时间，实现如下，

long starttime = system.nanotime();
//...the code being measured
long estimatedtime = system.nanotime() - starttime;

时间粒度
事实上system.currenttimemillis()方法的时间粒度是大于1毫秒的。如果你反复执行这个方法，你会发现短时间内得到的结果是相同的，随后又突然在某一次结果增加了几十毫秒（也可能更多）。这是很正常的，毕竟这个方法肯定不是世界上最精密的计时器。

旧的时间api

旧的时间api存在诸多问题，例如

• java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。
• java.util.date同时包含日期和时间，而java.sql.date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。
• 对于时间、时间戳、格式化以及解析，并没有一些明确定义的类。对于格式化和解析的需求，我们有java.text.dateformat抽象类，但通常情况下，simpledateformat类被用于此类需求。
• 所有的日期类都是可变的，因此他们都不是线程安全的，这是java日期类最大的问题之一。
• 日期类并不提供国际化，没有时区支持，因此java引入了java.util.calendar和java.util.timezone类，但他们同样存在上述所有的问题。

java.util.date类

java.util.date类用于封装日期及时间信息，一般仅用它显示某个日期，不对他作任何操作处理，作处理推荐用calendar类，计算方便。以下已过时的方法没有列出，可自行查看jdk文档

构造方法

• date() ：分配 date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

• date(long date)：分配 date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 gmt）以来的指定毫秒数。

//1、使用date类获取当前系统时间
date date = new date();
system.out.println(date);
//由于date类覆盖了tostring()方法，所以可以直接输出date类型的对象
//输出结果为fri may 31 10:51:18 gmt+08:00 2019

/*给date设置年份需要减去 1900
*输出结果tue jul 01 00:00:00 gmt+08:00 3919
*原来这里存在一个起始年份 1900，实际年份是要在你的年份参数上加上个起始年份。
*/
date date1 = new date(2019,5,31);
system.out.println(date1);

//2.分配 date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 gmt）以来的指定毫秒数。
date date2 = new date(system.currenttimemillis());//参数为19701月1日以来的毫秒数
date date3 = new date(1559284293556l); //long类型要加l
system.out.println(date2);
system.out.println(date3);
//其他date方法摘要可查看api

calendar类与gregoriancalendar

java.util.calendar类用于封装日历信息，其主作用在于其方法可以对时间分量进行运算。calendar类是一个抽象类，它为特定瞬间与一组诸如 year、month、day_of_month、hour 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

由于calendar类是抽象类，且calendar类的构造方法是protected的，所以无法使用calendar类的构造方法来创建对象，api中提供了getinstance方法用来创建对象。

java只提供java.util.gregoriancalendar这一种java.util.calendar的实现类，可以直接新建出来使用：

calendar calendar = new gregoriancalendar();//新建出来的calendar默认时间为当前时间，或者说创建出这个对象的时间。

通过calendar的静态方法获取一个实例该方法会根据当前系统所在地区来自行决定时区，帮我们创建calendar实例，这里要注意，实际上根据不同的地区，calendar有若干个子类实现。而calendar本身是抽象类，不能被实例化！我们不需要关心创建的具体实例为哪个子类，我们只需要根据calendar规定的方法来使用就可以了。

日历类所解决的根本问题是简化日期的计算，要想表示某个日期还应该使用date类描述。calendar是可以将其描述的时间转化为date的，我们只需要调用其gettime()方法就可以获取描述的日期的date对象了。

通过日历类计算时间：为日历类设置时间，日历类设置时间使用通用方法set。set(int field,int value)，field为时间分量，calendar提供了相应的常量值，value为对应的值。

只有月份从0开始：0为1月，以此类推，11为12月，其他时间是正常的从1开始。也可以使用calendar的常量 calendar.november……等。

calendar.day_of_month  月里边的天---号；
calendar.day_of_week    星期里的天---星期几
calendar.day_of_year     年里的天
calendar calendar=calendar.getinstance();//构造出来表示当前时间的日历类
date now=calendar.gettime();//获取日历所描述的日期
calendar.set(calendar.year, 2019);//设置日历表示2019年 calendar.set(calendar.day_of_month,15);//设置日历表示15号
calendar.add(calendar.day_of_year, 22);//想得到22天以后是哪天
calendar.add(calendar.day_of_year, -5);//5天以前是哪天
calendar.add(calendar.month, 1);得到1个月后是哪天
system.out.println(calendar.gettime());

获取当前日历表示的日期中的某个时间单位可以使用get方法。

int year = calendar.get(calendar.year);
int month = calendar.get(calendar.month)
int day = calendar.get(calendar.day_of_month);
system.out.println(year+"年"+(month+1)+"月"+day+"日");//month要处理

simpledateformat类

常用构造方法

simpledateformat(string pattern)，pattern -为描述日期和时间格式的模式

用给定的模式和默认语言环境的日期格式符号构造 simpledateformat。 注：此构造方法可能不支持所有语言环境。要覆盖所有语言环境，请使用 dateformat 类中的工厂方法。

常用方法

public final string format(date date)将一个 date 格式化为日期/时间字符串
public date parse(string source)throws parseexception从给定字符串的开始解析文本，以生成一个日期。

字符串转成date对象

//创建一个simpledateformat并且告知它要读取的字符串格式
simpledateformat sdf = new simpledateformat("yyyy-mm-dd");
string dateformat = "2019-05-31";//创建一个日期格式字符串
//将一个字符串转换为相应的date对象
date date = sdf.parse(dateformat);//要先捕获异常
system.out.println(date);//输出这个date对象

date对象转成字符串

simpledateformat sdf = new simpledateformat("yyyy-mm-dd");  
date date = new date(); 
string datestr = sdf.format(date);//把日期对象传进去，继承自dateformat类的方法。将一个date格式化为日期/时间字符串

在日期格式中，-和空格无特殊意义。无特殊含义的都原样输出

//将当前系统时间转换为2012/05/14 17:05:22的效果
simpledateformat format1 = new simpledateformat("yyyy/mm/dd hh:mm:ss");
datestr=format1.format(date);
system.out.println(datestr);

dateformat类

java.text.dateformat类（抽象类）是simpledateformat类的父类，用的少，没simpledateformat灵活。

java.sql.date

java.sql.date继承java.util.date,为了把前者转为后者，需要以下代码

date date = new date();
//java.sql.date 不支持date参数的构造器，传入long类型的时间
java.sql.date d = new java.sql.date(date.gettime());
system.out.println(d);
system.out.println(d.gethours());

输出结果

2019-05-31
exception in thread "main" java.lang.illegalargumentexception
    at java.sql.date.gethours(unknown source)
    at datetest.datetest1.main(datetest1.java:40)

这是由于java.sql.date是sql中的单纯的日期类型，没有时分秒。故一般通过jdbc插入java.sql.date数据时，会发现时分秒都没有。因此，如果同时需要日期和时间，应该使用timestamp。它也是 java.util.date 的子类，timestamp 则包含时间戳的完整信息。

java.sql.timestamp是java.util.date的派生类（继承），所以在java.util.date上能做的事，也可以在java.sql.timestamp上做。
如果当前是2019-06-01 14:35，你创建一个java.sql.date 将只记下2019-06-01这个信息。若你需要保留时间进行jdbc操作，请使用java.sql.timestamp代替。

long time = system.currenttimemillis();
java.sql.timestamp timestamp = new java.sql.timestamp(time);
timestamp.setnanos(123456);
int nanos = timestamp.getnanos(); // nanos = 123456

现在的date类中大部分方法已经弃用，现在一般使用旧的api，date只负责存储一个时间，并对calendar和dateformat提供操作接口。calendar获取date中特定的信息，对日期时间进行操作，simpledateformat对日期时间进行格式化输入输出。

总的来说，date、calendar 和 dateformat 已经能够处理一般的时间日期问题了。但是不可避免的是，它们依然很繁琐，不好用并且这些日期类都是可变且线程不安全的

joda-time

详情请查看https://www.ibm.com/developerworks/cn/java/j-jodatime.html

java 8 时间日期api

特性

• 不变性：新的日期/时间api中，所有的类都是不可变的，这对多线程很有好处。
• 关注点分离：借鉴了joda库的一些优点，新的api将人可读的日期时间和机器时间（unix timestamp）明确分离，它为日期（date）、时间（time）、日期时间（datetime）、时间戳（unix timestamp）以及时区定义了不同的类。
• 清晰：在所有的类中，方法都被明确定义用以完成相同的行为。例如要拿到当前实例我们可以使用now()方法，在所有的类中都定义了format()和parse()方法，而不是像以前那样专门有一个独立的类。为了更好的处理问题，所有的类都使用了工厂模式和策略模式，一旦你使用了其中某个类的方法，与其他类协同工作并不困难。
• 实用操作：所有新的日期/时间api类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从日期/时间中提取单独部分，等等。
• 可扩展性：新的日期/时间api是工作在iso-8601日历系统上的，但我们也可以将其应用在非ios的日历上。

java8日期时间的默认格式如下：yyyy-mm-dd-hh-mm-ss.zzz

几个主要的核心类：

• localdate：日期类，不带时间
• localtime：时间类，不带日期
• localdatetime：日期和时间类
• zoneddatetime：时区日期时间类
• offsetdatetime：按utc时间偏移来得到日期时间
• clock：获取某个时区下当前的瞬时时间，日期或者时间
• instant：unix时间，代表时间戳，比如 2018-01-14t02:20:13.592z
• duration：两个时间之间，表示一个绝对的精确跨度，使用毫秒为单位
• period：两个日期之间
• zoneid：时区
• datetimeformatter：格式化输出
• temporaladjusters：获得指定日期时间等，如当月的第一天、今年的最后一天等等

下面看看这些类具体如何使用

localdate、localtime、localdatetime

localdate是不变的日期时间对象代表一个日期，往往被视为年月日。其他日期字段，如一年中的一天，一周和一周的一天，也可以访问。例如，“2007年10月2日”的值可以被存储在一个localdate。

localtime是不变的日期时间对象代表一个时间，往往被视为小时分钟秒。时间为代表的纳秒级精度。例如，值“13:45.30.123456789”可以存储在一个localtime。

localdatetime是不变的日期时间对象代表一个日期时间，往往被视为年、月、日、时、分、秒。其他日期和时间字段，如一年中的一天，一周和一周的一天，也可以访问。时间为代表的纳秒级精度。例如，值“2007年10月2日在13:45.30.123456789”可以存储在一个localdatetime。

//now()在默认时区中从系统时钟获取当前日期。
localdate today = localdate.now();
localdate nextweek = today.plus(1, chronounit.weeks); //等价于 today.plusweeks(1)

//of(int year, int month, int dayofmonth) 获得 localdate实例从一年、月、日。 
localdate date = localdate.of(2019,5,31);
localtime time = localtime.of(20,31,20);

//of(localdate date, localtime time) 获得 localdatetime实例的日期和时间。 
localdatetime datetime = localdatetime.of(date,time);
system.out.println(datetime);

//localdate结合localtime成一个localdatetime
localdatetime datetime2 = date.attime(time);
system.out.println(datetime2); //2019-05-31t20:31:20

datetimeformatter

格式器用于解析日期字符串和格式化日期输出，创建格式器最简单的方法是通过 datetimeformatter 的静态工厂方法以及常量。创建格式器一般有如下三种方式：

1. 常用 iso 格式常量，如 iso_local_date
2. 字母模式，如 ofpattern("yyyy/mm/dd")
3. 本地化样式，如 oflocalizeddate(formatstyle.medium)

和旧的 java.util.dateformat 相比较，所有的 datetimeformatter 实例都是线程安全的。

使用datetimeformatter完成格式化

//获取默认时区中从系统时钟获取当前日期时间。
localdatetime localdatetime = localdatetime.now();
//创建一个格式化程序使用指定的模式。
datetimeformatter formatter = datetimeformatter.ofpattern("yyyy-mm-dd hh:mm:ss");
string formatdatetime = localdatetime.format(formatter);
system.out.println(formatdatetime);

//datetimeformatter提供了一些默认的格式化器，datetimeformatter.iso_local_date_time 格式 yyyy-mm-ddthh:mm:ss.sss
string datetime2 = localdatetime.format(datetimeformatter.iso_local_date_time);
system.out.println(datetime2);

使用datetimeformatter完成解析字符串

//获得 localdate实例,从使用特定格式的文本字符串解析，文字使用格式化程序解析，返回一个日期。
localdate localdate = localdate.parse("2018/11/11",datetimeformatter.ofpattern("yyyy/mm/dd"));
system.out.println(localdate); //2018-11-11

instant

instant 表示时间线上的一点（与 date 类似），它只是简单地表示自 1970 年 1 月 1 日 0 时 0 分 0 秒（utc）开始的秒数。

instant 由两部分组成，一是从原点开始到指定时间点的秒数 s， 二是距离该秒数 s 的纳秒数。它以 unix 时间戳的形式存储日期时间，不提供处理人类意义上的时间单位（年月日等）。

你可以通过instant类的工厂方法创建一个instant实例

//调用instant.now()来创建一个确切的表达当前时间的instant对象.另外也有一些其它方法能创建instant，具体请查阅java官方文档。
instant now = instant.now();
instant later = now.plusseconds(3);
instant earlier = now.minusseconds(3);

//第一个参数是秒，第二个是纳秒参数，纳秒的存储范围是0至999,999,999
//2s之后的在加上100万纳秒（1s）
instant instant = instant.ofepochsecond(2,1000000000);
system.out.println(instant); //1970-01-01t00:00:03z

instant instant1 = instant.now();
system.out.println(instant1); //2019-05-31t16:19:28.719z

instant instant2 = instant.parse("2018-11-11t10:12:35.342z");
system.out.println(instant2); //2018-11-11t10:12:35.342z

//java.util.date与instant可相互转换
instant timestamp = new date().toinstant();
date.from(instant.now());

//为了更好的显示，代码改写为
date date = new date();
instant timestamp = date.toinstant();
system.out.println(date);
system.out.println(timestamp);
instant now1 = instant.now();
date date1 = date.from(now1);
system.out.println(now1);
system.out.println(date1);
//输出结果
sat jun 01 00:29:42 gmt+08:00 2019
2019-05-31t16:29:42.566z
2019-05-31t16:29:42.588z
sat jun 01 00:29:42 gmt+08:00 2019

clock

clock用于查找当前时刻，可以用来获取某个时区下当前的日期和时间，也可以用来代替旧的system.currenttimemillis()方法和timezone.getdefault()方法。

//返回系统默认时间
clock clock = clock.systemdefaultzone();
system.out.println(clock.instant().tostring());

//世界协调时utc
clock clock = clock.systemutc();  
//通过clock获取当前时刻  
system.out.println("当前时刻为：" + clock.instant());  
//获取clock对应的毫秒数，与system.currenttimemillis()输出相同  
system.out.println(clock.millis());  
system.out.println(system.currenttimemillis());  

duration

一个duration实例是不可变的，当创建出对象后就不能改变它的值了。你只能通过duration的计算方法，来创建出一个新的durtaion对象。你会在之后的教程中见到的。一个duration对象表示两个instant间的一段时间。

创建duration实例，使用duration类的工厂方法来创建一个duration对象

instant first = instant.now();
// wait some time while something happens
instant second = instant.now();
duration duration = duration.between(first, second);

//获得duration表示秒数，然后获得在此期间的分钟数、小时数、天数
duration d = duration.ofseconds(6000);  
system.out.println("6000秒相当于" + d.tominutes() + "分");  
system.out.println("6000秒相当于" + d.tohours() + "小时");  
system.out.println("6000秒相当于" + d.todays() + "天");  

访问duration的时间
一个duration对象里有两个域：纳秒值（小于一秒的部分），秒钟值（一共有几秒），他们的组合表达了时间长度。注意与使用system.getcurrenttimemillis()时不同，duration不包含毫秒这个属性。
你可以通过以下两个方法得到它们的值：getseconds()和getnano()

period

period 是以年月日来衡量一个时间段，用于计算两个日期间隔，所以 between() 方法只能接收 localdate 类型的参数。

localdate start = localdate.of(2018, month.january, 1);
localdate end = localdate.of(2020, month.november, 11);
system.out.println("相隔月数："+period.between(start, end).getmonths());
system.out.println("相隔天数："+period.between(start, end).getdays());
//输出结果
相隔月数：10
相隔天数：10

值得注意的是，period 得到的是差值的绝对值（对应年月日直接计算数学上的差值），而并不表示真正的区间距离。

long distancemonth = start.until(end, chronounit.months);
long  distanceday= start.until(end, chronounit.days);
system.out.println("相隔月数"+distancemonth);
system.out.println("相隔天数"+distanceday);
//输出结果
相隔月数：34
相隔天数：1045

zoneddatetime和zonedid

zoneddatetime类是java 8中日期时间功能里，用于表示带时区的日期与时间信息的类。zoneddatetime 类的值是不可变的，所以其计算方法会返回一个新的zoneddatetime 实例。

java 使用 zoneid 来标识不同的时区，从基准 utc 开始的一个固定偏移。

创建一个zoneddatetime实例

//使用当前时间作为值新建对象
zoneddatetime datetime = zoneddatetime.now();

//使用指定的年月日、时分、纳秒以及时区id来新建对象
//时区是用zoneid类表示的，可以使用zoneid.now()或zoneid.of(“xxx”)来实例化：
//传给of()方法的参数是时区的id，如“utc+1”指距离utc（格林威治时间）有一小时的时差
zoneid zoneid = zoneid.of("utc+1");
zoneddatetime datetime2 = zoneddatetime.of(2019, 6, 1, 14, 40, 48, 1234, zoneid);

//也可以使用另一种方式表示zone id，即使用地区名字
zoneid zoneid2 = zoneid.of("europe/copenhagen");

//gregoriancalendar与zoneddatetime相互转换
zoneddatetime zoneddatetime = new gregoriancalendar().tozoneddatetime();
gregoriancalendar.from(zoneddatetime);

temporaladjusters

有的时候，你需要进行一些更加复杂的操作，比如，将日期调整到下个周日、下个工作日，或者是本月的最后一天。

简单应用例子

localdate localdate = localdate.now();  
// 1. 本月第一天
localdate firstdayofmonth = localdate.with(temporaladjusters.firstdayofmonth());
// 2. 本月最后一天
localdate lastdayofmonth = localdate.with(temporaladjusters.lastdayofmonth());
// 3. 本年第一天
localdate firstdayofyear = localdate.with(temporaladjusters.firstdayofyear());
// 4. 下个月第一天
localdate firstdayofnextmonth = localdate.with(temporaladjusters.firstdayofnextmonth());
// 5. 本年度最后一天
localdate lastdayofyear = localdate.with(temporaladjusters.lastdayofyear());
system.out.println(firstdayofmonth);
system.out.println(lastdayofmonth);
system.out.println(firstdayofyear);
system.out.println(firstdayofnextmonth);
system.out.println(lastdayofyear);

这时，你可以使用重载版本的with方法，向其传递一个提供了更多定制化选择的temporaladjuster对象,更加灵活地处理日期。temporaladjusters类通过静态方法提供了大量的常用的temporaladjuster的实现供我们使用。

/**
 * 时间校正器temporaladjuster
 */
@test
public void test() {
    localdatetime now1 = localdatetime.now();
    //获取月中的第一天
    now1.with(temporaladjusters.firstdayofmonth());
    //获取下一年的第一天   
    now1.with(temporaladjusters.firstdayofnextyear());
    //获取年中第一天
    now1.with(temporaladjusters.lastdayofyear());
    //获取月中最后一天
    now1.with(temporaladjusters.lastdayofmonth());
    //获取下个星期一
    now1.with(temporaladjusters.next(dayofweek.monday));
    //自定时时间：下一个工作日，因为这里需要一个接口，所以完全可以自定义方法
    now1.with((e) -> {
        localdatetime now = (localdatetime)e; 
        dayofweek dow = now.getdayofweek();
        if (dow.equals(dayofweek.friday)) 
            return now.plusdays(3);
        else if (dow.equals(dayofweek.saturday))
            return now.plusdays(2);
        return  now.plusdays(1);
    });
}

转换

java.util.date 与 localdate、localtime、localdatetime 转换

将date转换为localdate，localtime，localdatetime可以借助于zoneddatetime和instant，实现如下：

date date = new date();
system.out.println("current date: " + date);

// date -> localdatetime
localdatetime localdatetime = date.toinstant().atzone(zoneid.systemdefault()).tolocaldatetime();
system.out.println("localdatetime by instant: " + localdatetime);

// date -> localdate
localdate localdate = date.toinstant().atzone(zoneid.systemdefault()).tolocaldate();
system.out.println("localdate by instant: " + localdate);
// date -> localtime
localtime localtime = date.toinstant().atzone(zoneid.systemdefault()).tolocaltime();
system.out.println("localtime by instant: " + localtime);

//2. date -> localdatetime
localdatetime = localdatetime.ofinstant(date.toinstant(), zoneid.systemdefault());
system.out.println("localdatetime by ofinstant: " + localdatetime);

由于jdk8实现了向下兼容，所以date里在jdk8版本引入了2个方法，from和
toinstant，所以我们可以借助这两个方法来实现localdatetime到date的转换。将localdatetime转为date如下：

localdatetime localdatetime = localdatetime.now();
system.out.println("localdatetime: " + localdatetime);

// localdatetime -> date
date date = date.from(localdatetime.atzone(zoneid.systemdefault()).toinstant());
system.out.println("localdatetime -> current date: " + date);

// localdate -> date，时间默认都是00
localdate localdate = localdate.now();
date = date.from(localdate.atstartofday(zoneid.systemdefault()).toinstant());
system.out.println("localdate -> current date: " + date);

日期与字符串的转换

通过localdate，localtime，localdatetime的parse方法和datetimeformatter来实现：

//字符串->日期
localdate localdate = localdate.parse("2018-09-09", datetimeformatter.ofpattern("yyyy-mm-dd"));
localdatetime localdatetime = localdatetime.parse("2018-09-10 12:12:12", datetimeformatter.ofpattern("yyyy-mm-dd hh:mm:ss"));

//日期->字符串
string localdate = localdate.now().format(datetimeformatter.ofpattern("yyyy-mm-dd"));
string localdatetime = localdatetime.now().format(datetimeformatter.ofpattern("yyyy-mm-dd hh:mm:ss"));
// 也可以通过datetimeformatter的format方法
datetimeformatter datetimeformatter = datetimeformatter.ofpattern("yyyy-mm-dd hh:mm:ss");
localdatetime = datetimeformatter.format(localdatetime.now());

时间戳与localdatetime转换

具体实现如下：

//时间戳->localdatetime
public static localdatetime converttodate(long timestamp) {
   // ofepochsecond 以秒为单位， ofepochmilli 以毫秒为单位
   // instant.ofepochsecond(timestamp);
   instant instant = instant.ofepochmilli(timestamp);
   return localdatetime.ofinstant(instant, zoneid.systemdefault());
}

//localdatetime->时间戳
public static long converttotimestamp() {
   localdatetime localdatetime = localdatetime.now();
   return localdatetime.atzone(zoneid.systemdefault()).toinstant().toepochmilli();
}

总结

• 所有新的日期时间 api 类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从日期/时间中提取单独部分。
• java 8 中新的时间与日期 api 中的所有类都是不可变且线程安全的，任何修改操作都会返回一个新的实例。
• 新的 api 区分各种日期时间概念并且各个概念使用相似的方法定义模式，这种相似性非常有利于 api 的学习。总结一下一般的方法或者方法前缀：
  • of：静态工厂方法，用于创建实例
  • now：静态工厂方法，用当前时间创建实例
  • parse：静态工厂方法，从字符串解析得到对象实例
  • get：获取时间日期对象的部分状态。
  • is：检查某些东西的是否是 true，例如比较时间前后
  • with：返回一个部分状态改变了的时间日期对象拷贝
  • plus：返回一个时间增加了的、时间日期对象拷贝
  • minus：返回一个时间减少了的、时间日期对象拷贝
  • to：转换到另一个类型
  • at：把这个对象与另一个对象组合起来，例如 date.attime(time)
  • format：提供格式化时间日期对象的能力

更多方法使用请参考java api文档

参考文章：

http://www.importnew.com/14140.html

https://docs.oracle.com/javase/8/docs/api/

https://www.jianshu.com/p/f4abe1e38e09