Date类型
ECMAScript中的Date类型是在早期Java中java.util.Date类基础上构建的。为此，Date类型使用UTC (Coordinated Universal Time，国际协调时间[又称世界统一时间]) 1970年1月1日午夜(零时)开始经过的毫秒来保存日期。在使用这种数据存储格式的条件下，Date类型保存的日期能够精确到1970年1月1日之前或之后的285616年。

 

创建一个日期对象，使用new运算符和Date构造方法(构造函数)即可。

var box = new Date(); //创建一个日期对象

 

在调用Date构造方法而不传递参数的情况下，新建的对象自动获取当前的时间和日期。

alert(box); //不同浏览器显示不同

 

ECMAScript提供了两个方法，Date.parse()和Date.UTC()。Date.parse()方法接收一个表示日期的字符串参数，然后尝试根据这个字符串返回相应的毫秒数。ECMA-262没有定义Date.parse()应该支持哪种日期格式，因此方法的行为因实现而异，因地区而异。默认通常接收的日期格式如下：

'月/日/年'，如6/13/2011;
	
'英文月名 日, 年'，如 May 25, 2004;
	
'英文星期几 英文月名 日 年 时:分:秒 时区'，如 Tue May 25 2004 00:00:00 GMT-070
alert(Date.parse('6/13/2016')); //1307894400000

 

如果Date.parse()没有传入或者不是标准的日期格式，那么就会返回NaN。

alert(Date.parse()); //NaN

 

如果想输出指定的日期，那么把Date.parse()传入Date构造方法里。

var box = new Date(Date.parse('6/13/2011'));//Mon Jun 13 2011 00:00:00 GMT+0800

var box = new Date('6/13/2011');  //直接传入，Date.parse()后台被调用

 

PS：Date对象及其在不同浏览器中的实现有许多奇怪的行为。其中有一种倾向是将超出的范围的值替换成当前的值，以便生成输出。例如，在解析“January 32, 2007”时，有的浏览器会讲其解释为“February 1, 2007”。而Opera则倾向与插入当前月份的当前日期。

 

Date.UTC()方法同样也返回表示日期的毫秒数，但它与Date.parse()在构建值时使用不同的信息。(年份，基于0的月份[0表示1月，1表示2月]，月中的哪一天[1-31]，小时数[0-23]，分钟，秒以及毫秒)。只有前两个参数是必须的。如果没有提供月数，则天数为1；如果省略其他参数，则统统为0.

alert(Date.UTC(2011,11)); //1322697600000

 

如果Date.UTC()参数传递错误，那么就会出现负值或者NaN等非法信息。

alert(Date.UTC()); //负值或者NaN

 

如果要输出指定日期，那么直接把Date.UTC()传入Date构造方法里即可。

var box = new Date(Date.UTC( ));

 

 

通用的方法
与其他类型一样，Date类型也重写了toLocaleString()、toString()和valueOf()方法；但这些方法返回值与其他类型中的方法不同。

var box = new Date(Date.UTC(2011,11, 5, 15, 13, 16));

alert('toString:' + box.toString());

alert('toLocaleString:' + box.toLocaleString()); //按本地格式输出

 

PS：这两个方法在不同浏览器显示的效果又不一样，但不用担心，这两个方法只是在调试比较有用，在显示时间和日期上，没什么价值。valueOf()方法显示毫秒数。

 

 

日期格式化方法
Date类型还有一些专门用于将日期格式化为字符串的方法。

 

var box = new Date();

alert(box.toDateString()); //以特定的格式显示星期几、月、日和年

alert(box.toTimeString()); //以特定的格式显示时、分、秒和时区

alert(box.toLocaleDateString()); //以特定地区格式显示星期几、月、日和年

alert(box.toLocaleTimeString()); //以特定地区格式显示时、分、秒和时区

alert(box.toUTCString()); //以特定的格式显示完整的UTC日期。

 

 

 

组件方法
组件方法，是为我们单独获取你想要的各种时间/日期而提供的方法。需要注意的时候，这些方法中，有带UTC的，有不带UTC的。UTC日期指的是在没有时区偏差的情况下的日期值。
alert(box.getTime()); //获取日期的毫秒数，和valueOf()返回一致

alert(box.setTime(100)); //以毫秒数设置日期，会改变整个日期

alert(box.getFullYear()); //获取四位年份

alert(box.setFullYear(2012)); //设置四位年份，返回的是毫秒数

alert(box.getMonth()); //获取月份，没指定月份，从0开始算起

alert(box.setMonth(11)); //设置月份

alert(box.getDate()); //获取日期

alert(box.setDate(8)); //设置日期，返回毫秒数

alert(box.getDay()); //返回星期几，0表示星期日，6表示星期六

alert(box.setDay(2)); //设置星期几

alert(box.getHours()); //返回时

alert(box.setHours(12)); //设置时

alert(box.getMinutes()); //返回分钟

alert(box.setMinutes(22)); //设置分钟

alert(box.getSeconds()); //返回秒数
alert(box.setSeconds(44)); //设置秒数

alert(box.getMilliseconds()); //返回毫秒数

alert(box.setMilliseconds()); //设置毫秒数

alert(box.getTimezoneOffset()); //返回本地时间和UTC时间相差的分钟数

给你一个时间，输出下一秒的时间，输入格式为：yyyy/mm/dd hh:mm:ss
 
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int main(){
	int n,y,r,s,f,m;
	while(scanf("%d/%d/%d %d:%d:%d",&n,&y,&r,&s,&f,&m)!=EOF){
		m++;
		if(m==60){
			m=0;
			f++;
		}
		if(f==60){
			f=0;
			s++;
		}
		if(s==24){
			s=0;
			r++;
		}
		if((n%4==0&&n%100!=0)||n%400==0){
			if(y==2){
				if(r==30){
					r=1;
					y++;
				}
			}
			else if(y==4||y==6||y==9||y==11){
				if(r==31){
					r=1;
					y++;
				}
			}
			else{
				if(r==32){
					r=1;
					y++;
				}
			}
		}
		else{
			if(y==2){
				if(r==29){
					r=1;
					y++;
				}
			}
			else if(y==4||y==6||y==9||y==11){
				if(r==31){
					r=1;
					y++;
				}
			}
			else{
				if(r==32){
					r=1;
					y++;
				}
			}
		}
		if(y==13){
			y=1;
			n++;
		}
		printf("%d/%02d/%02d %02d:%02d:%02d\n",n,y,r,s,f,m);
	}
	return 0;
} 


 

python下的日期与时间
一、在Python中，时间主要有三种表示形式，


1.时间戳（TimeStamp）：1970年1月1日之后的秒


2.时间元组格式化形式 包含了：年、日、星期 得到time.struct_time（tm_year=2017, tm_mon=10, tm_mday=14…）


3.可视化的字符串 2017-11-11 11：44


import time
#1 时间戳：1970年1月1日之后的秒
print('1.时间戳形式:{}'.format(time.time()))

1.时间戳形式:1542765908.295993

时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。
2.时间戳科学的解释
最初计算机操作系统是32位，而时间也是用32位表示。32位能表示的最大值是2147483647。另外1年365天的总秒数是31536000，2147483647/31536000 = 68.1，也就是说32位能表示的最长时间是68年，而实际上到2038年01月19日03时14分07秒，便会到达最大时间，过了这个时间点，所有32位操作系统时间便会变为10000000 00000000 00000000 00000000，也就是1901年12月13日20时45分52秒，这样便会出现时间回归的现象，很多软件便会运行异常了。

到这里，我想问题的答案已经出来了:因为用32位来表示时间的最大间隔是68年，而最早出现的UNIX操作系统考虑到计算机产生的年代和应用的时限综合取了1970年1月1日作为UNIX TIME的纪元时间(开始时间)，至于时间回归的现象相信随着64为操作系统的产生逐渐得到解决，因为用64位操作系统可以表示到292,277,026,596年12月4日15时30分08秒，相信我们的N代子孙，哪怕地球毁灭那天都不用愁不够用了，因为这个时间已经是千亿年以后了。
为什么是1970，因为这个设计时候是　７０　年代
#2 元组格式化形式 包含了：年、日、星期  得到time.struct_time（tm_year=2017, tm_mon=10, tm_mday=14...）
print('2.元组格式化形式:{}'.format(time.gmtime()))

2.元组格式化形式:time.struct_time(tm_year=2018, tm_mon=11, tm_mday=21, tm_hour=2, tm_min=5, tm_sec=9, tm_wday=2, tm_yday=325, tm_isdst=0)

什么是时间元组？
很多Python函数用一个元组装起来的9组数字处理时间:


序号
字段
值

0
4位数年
2008
1
月
1 到 12
2
日
1到31
3
小时
0到23
4
分钟
0到59
5
秒
0到61 (60或61 是闰秒)
6
一周的第几日
0到6 (0是周一)
7
一年的第几日
1到366 (儒略历)
8
夏令时
-1, 0, 1, -1是决定是否为夏令时的旗帜

也就是struct_time元组。这种结构具有如下属性：


序号
属性
值

0
tm_year
2008
1
tm_mon
1 到 12
2
tm_mday
1 到 31
3
tm_hour
0 到 23
4
tm_min
0 到 59
5
tm_sec
0 到 61 (60或61 是闰秒)
6
tm_wday
0到6 (0是周一)
7
tm_yday
1 到 366(儒略历)
8
tm_isdst
-1, 0, 1, -1是决定是否为夏令时的旗帜

#3 可视化的字符串 2017-11-11 11：44
print('3.可视化的字符串:{}'.format(time.strftime("%Y-%m-%d %H:%M:%S")))

3.可视化的字符串:2018-11-21 10:05:10

python中时间日期格式化符号：

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

二、三种时间的转化
1.时间戳------->时间元组:
UTC是国际时，UTC+8就是国际时加八小时，是东八区时间，也就是北京时间。
#用time.localtime()方法，将一个时间戳转换为当前时区的struct_time。
time1 = time.time()
tuple1 = time.localtime(time1) # UTC + 8 时间
tuple1

time.struct_time(tm_year=2018, tm_mon=11, tm_mday=21, tm_hour=10, tm_min=5, tm_sec=11, tm_wday=2, tm_yday=325, tm_isdst=0)


time1 = time.time()
tuple1 = time.gmtime(time1)  # UTC时间
tuple1

time.struct_time(tm_year=2018, tm_mon=11, tm_mday=21, tm_hour=2, tm_min=5, tm_sec=11, tm_wday=2, tm_yday=325, tm_isdst=0)

2.时间元组-------->时间戳:
tuple2 = time.localtime()
time2 = time.mktime(tuple2)
time2

1542765912.0

3.时间元组--------->字符串:
-strftime(format[, tuple])
将指定的struct_time(默认为当前时间)，根据指定的格式化字符串输出
tuple3 = time.localtime()
strTime = time.strftime("%Y-%m-%d %H:%M:%S",tuple3)
strTime

‘2018-11-21 10:20:27’
strTime1 = time.strftime("%Y{y}%m{m}%d{d} %H{h}%M{m1}%S{s}",tuple3).format(y="年",m="月",d="日",h="时",m1="分",s="秒")
strTime1

'2018年11月21日 10时05分12秒'

4、asctime()方法
time.asctime([t]))

参数

t – 9个元素的元组(time.struct_time)或者通过函数 gmtime() 或 localtime() 返回的时间值。

返回值

返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
t = time.localtime()
print(type(t),t)
time.asctime(t)

<class 'time.struct_time'> time.struct_time(tm_year=2018, tm_mon=11, tm_mday=21, tm_hour=10, tm_min=5, tm_sec=13, tm_wday=2, tm_yday=325, tm_isdst=0)





'Wed Nov 21 10:05:13 2018'

5、把时间戳---->time.asctime()
t=time.time()
print(type(t),t)
time.ctime(time.time())

<class 'float'> 1542765913.8286655





'Wed Nov 21 10:05:13 2018'

三、时间戳计算时间差
#根据时间戳来计算（注意时间戳时秒还是毫秒）

#1、天数
time.time()+86400*7 #当前时间的后7天

#2、小时
time.time()+3600*7 #当前时间的后7小时

#3、分钟
time.time()+60*7 #当前时间的后7分钟


1542766334.2900052

三、字符串形式计算时间差
#字符串时间差
import datetime

start ="2018-06-19 17:37:31"
end = "2019-07-30 17:37:31"
start=time.strptime(start, "%Y-%m-%d %H:%M:%S")
end=time.strptime(end, "%Y-%m-%d %H:%M:%S")
userStart=datetime.datetime(start[0],start[1],start[2])
userEnd=datetime.datetime(end[0],end[1],end[2])
print ((userEnd-userStart).days) # 0 天数
# print (end-start).total_seconds() # 30.029522 精确秒数
# print (end-start).seconds # 30 秒数
# print (end-start).microseconds # 29522 毫秒数


406
<div align="center">

 

Python不断更新，如果发现有最新方法欢迎留言交流。同时欢迎加入Python资源分享Q群：867300100

Java 时间与日期处理
王下邀月熊
18 小时前


Java 时间与日期处理 从属于笔者的现代
 Java 开发系列文章，涉及到的引用资料声明在 Java 学习与实践资料索引中。
Java 时间与日期处理
在 Java 8 之前，我们最常见的时间与日期处理相关的类就是 Date、Calendar 以及 SimpleDateFormatter 等等。不过 java.util.Date 也是被诟病已久，它包含了日期、时间、毫秒数等众多繁杂的信息，其内部利用午夜 12 点来区分日期，利用 1970-01-01 来计算时间；并且其月份从 0 开始计数，而且用于获得年、月、日等信息的接口也是太不直观。除此之外，java.util.Date与 SimpleDateFormatter 都不是类型安全的，而 JSR-310
 中的 LocalDate 与 LocalTime 等则是不变类型，更加适合于并发编程。JSR 310 实际上有两个日期概念。第一个是 Instant，它大致对应于 java.util.Date 类，因为它代表了一个确定的时间点，即相对于标准 Java 纪元（1970年1月1日）的偏移量；但与 java.util.Date 类不同的是其精确到了纳秒级别。另一个则是 LocalDate、LocalTime 以及 LocalDateTime 这样代表了一般时区概念、易于理解的对象。
Class / TypeDescriptionYearRepresents a year.YearMonthA month within a specific year.LocalDateA date without an explicitly specified time zone.LocalTimeA time without an explicitly specified time zone.LocalDateTimeA combination date and time without an explicitly
 specified time zone.
最新 JDBC 映射将把数据库的日期类型和 Java 8 的新类型关联起来：
SQLJavadateLocalDatetimeLocalTimetimestampLocalDateTimedatetimeLocalDateTime
时间与日期基础概念
标准时间
GMT 即「格林威治标准时间」( Greenwich Mean Time，简称 G.M.T. )，指位于英国伦敦郊区的皇家格林威治天文台的标准时间，因为本初子午线被定义为通过那里的经线。然而由于地球的不规则自转，导致 GMT 时间有误差，因此目前已不被当作标准时间使用。UTC 是最主要的世界时间标准，是经过平均太阳时(以格林威治时间 GMT 为准)、地轴运动修正后的新时标以及以「秒」为单位的国际原子时所综合精算而成的时间。UTC 比 GMT 来得更加精准。其误差值必须保持在 0.9 秒以内，若大于 0.9
 秒则由位于巴黎的国际地球自转事务中央局发布闰秒，使 UTC 与地球自转周期一致。不过日常使用中，GMT 与 UTC 的功能与精确度是没有差别的。协调世界时区会使用 “Z” 来表示。而在航空上，所有使用的时间划一规定是协调世界时。而且 Z 在无线电中应读作 “Zulu”（可参见北约音标字母），协调世界时也会被称为 “Zulu time”。
TimeZone&UTC Offsets: 时区与偏移
人们经常会把时区与 UTC 偏移量搞混，UTC 偏移量代表了某个具体的时间值与 UTC 时间之间的差异，通常用 HH:mm 形式表述。而 TimeZone 则表示某个地理区域，某个 TimeZone 中往往会包含多个偏移量，而多个时区可能在一年的某些时间有相同的偏移量。譬如 America/Chicago, America/Denver, 以及 America/Belize 在一年中不同的时间都会包含 -06:00 这个偏移。
时间戳
Unix 时间戳表示当前时间到 1970 年 1 月 1 日 00:00:00 UTC 对应的秒数。注意，JavaScript 内的时间戳指的是当前时间到 1970 年 1 月 1 日 00:00:00 UTC 对应的毫秒数，和 Unix 时间戳不是一个概念，后者表示秒数，差了 1000 倍。
时间数字字符串格式
RFC2822

YYYY/MM/DD HH:MM:SS ± timezone(时区用4位数字表示)
// eg 1992/02/12 12:23:22+0800


ISO 8601
国际标准化组织的国际标准 ISO 8601 是日期和时间的表示方法，全称为《数据存储和交换形式·信息交换·日期和时间的表示方法》。目前最新为第三版 ISO8601:2004，第一版为 ISO8601:1988，第二版为 ISO8601:2000。年由 4 位数组成，以公历公元 1 年为 0001 年，以公元前 1 年为 0000 年，公元前 2 年为 -0001 年，其他以此类推。应用其他纪年法要换算成公历，但如果发送和接受信息的双方有共同一致同意的其他纪年法，可以自行应用。

YYYY-MM-DDThh:mm:ss ± timezone(时区用HH:MM表示)
1997-07-16T08:20:30Z
// “Z”表示UTC标准时区，即"00:00",所以这里表示零时区的`1997年7月16日08时20分30秒`
//转换成位于东八区的北京时间则为`1997年7月17日16时20分30秒`
1997-07-16T19:20:30+01:00
// 表示东一区的1997年7月16日19时20秒30分，转换成UTC标准时间的话是1997-07-16T18:20:30Z


时间戳
在 Java 8 之前，我们使用 java.sql.Timestamp 来表示时间戳对象，可以通过以下方式创建与获取对象：

// 利用系统标准时间创建
Timestamp timestamp = new Timestamp(System.currentTimeMillis());

// 从 Date 对象中创建
new Timestamp((new Date()).getTime());

// 获取自 1970-01-01 00:00:00 GMT 以来的毫秒数
timestamp.getTime();


在 Java 8 中，即可以使用 java.time.Instant 来表示自从 1970-01-01T00:00:00Z 之后经过的标准时间：

// 基于静态函数创建
Instant instant = Instant.now();

// 基于 Date 或者毫秒数转换
Instant someInstant = someDate.toInstant();
Instant someInstant = Instant.ofEpochMilli(someDate.getTime());

// 基于 TimeStamp 转换
Instant instant = timestamp.toInstant();

// 从 LocalDate 转化而来
LocalDate.now().atStartOfDay().toInstant(ZoneOffset.UTC)

// 从 LocalDateTime 转化而来
ldt.atZone(ZoneId.systemDefault()).toInstant();

// 获取毫秒
long timeStampMillis = instant.toEpochMilli();

// 获取秒
long timeStampSeconds = instant.getEpochSecond();


Clock 方便我们去读取当前的日期与时间。Clock 可以根据不同的时区来进行创建，并且可以作为System.currentTimeMillis()的替代。这种指向时间轴的对象即是Instant类。Instants 可以被用于创建java.util.Date对象。

Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();

Instant instant = clock.instant();
Date legacyDate = Date.from(instant);   // legacy java.util.Date


Date

// 默认创建
Date date0 = new Date();

// 从 TimeStamp 中创建
Date date1 = new Date(time);

// 基于 Instant 创建
Date date = Date.from(instant);

// 从格式化字符串中获取
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
java.util.Date dt=sdf.parse("2005-2-19");

// 从 LocalDateTime 中转化而来
Date out = Date.from(ldt.atZone(ZoneId.systemDefault()).toInstant());


基于 Date 的日期比较常常使用以下方式：
使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。
使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
使用 compareTo() 方法，它是由 Comparable 接口定义的，Date 类实现了这个接口。
Calendar
Date 用于记录某一个含日期的、精确到毫秒的时间。重点在代表一刹那的时间本身。 Calendar 用于将某一日期放到历法中的互动——时间和年、月、日、星期、上午、下午、夏令时等这些历法规定互相作用关系和互动。我们可以通过 Calendar 内置的构造器来创建实例：

Calendar.Builder builder =new Calendar.Builder();
Calendar calendar1 = builder.build();
Date date = calendar.getTime();


在 Calendar 中我们则能够获得较为直观的年月日信息：

// 2017，不再是 2017 - 1900 = 117
int year =calendar.get(Calendar.YEAR);

int month=calendar.get(Calendar.MONTH)+1;

int day =calendar.get(Calendar.DAY_OF_MONTH);

int hour =calendar.get(Calendar.HOUR_OF_DAY);

int minute =calendar.get(Calendar.MINUTE);

int seconds =calendar.get(Calendar.SECOND);    


除此之外，Calendar 还提供了一系列 set 方法来允许我们动态设置时间，还可以使用 add 等方法进行日期的加减。
SimpleDateFormat
SimpleDateFormat 用来进行简单的数据格式化转化操作：

Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");


LocalDateTime
LocalDate

// 取当前日期：
LocalDate today = LocalDate.now();

// 根据年月日取日期，12月就是12：
LocalDate crischristmas = LocalDate.of(2017, 5, 15); 

// 根据指定格式字符串取
LocalDate endOfFeb = LocalDate.parse("2017-05-15"); // 严格按照ISO yyyy-MM-dd验证，02写成2都不行，当然也有一个重载方法允许自己定义格式
LocalDate.parse("2014-02-29"); // 无效日期无法通过：DateTimeParseException: Invalid date

// 通过自定义时间字符串格式获取
DateTimeFormatter germanFormatter =
    DateTimeFormatter
        .ofLocalizedDate(FormatStyle.MEDIUM)
        .withLocale(Locale.GERMAN);

LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas);   // 2014-12-24

// 获取其他时区下日期
LocalDate localDate = LocalDate.now(ZoneId.of("GMT+02:30"));

// 从 LocalDateTime 中获取实例
LocalDateTime localDateTime = LocalDateTime.now();
LocalDate localDate = localDateTime.toLocalDate();


日期操作

// 取本月第1天
LocalDate firstDayOfThisMonth = today.with(TemporalAdjusters.firstDayOfMonth()); // 2014-12-01

// 取本月第2天
LocalDate secondDayOfThisMonth = today.withDayOfMonth(2); // 2014-12-02

// 取本月最后一天，再也不用计算是28，29，30还是31
LocalDate lastDayOfThisMonth = today.with(TemporalAdjusters.lastDayOfMonth()); // 2014-12-31

// 取下一天
LocalDate firstDayOf2015 = lastDayOfThisMonth.plusDays(1); // 变成了2015-01-01

// 取2015年1月第一个周一
LocalDate firstMondayOf2015 = LocalDate.parse("2015-01-01").with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY)); // 2015-01-05


LocalTime

// 获取其他时区下时间
LocalTime localTime = LocalTime.now(ZoneId.of("GMT+02:30"));

// 从 LocalDateTime 中获取实例
LocalDateTime localDateTime = LocalDateTime.now();
LocalTime localTime = localDateTime.toLocalTime();


- 12:00
- 12:01:02
- 12:01:02.345


LocalDateTime

// 通过时间戳创建
LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochSecond(1450073569l), TimeZone.getDefault().toZoneId());

// 通过 Date 对象创建
Date in = new Date();
LocalDateTime ldt = LocalDateTime.ofInstant(in.toInstant(), ZoneId.systemDefault());

// 通过解析时间字符串创建
DateTimeFormatter formatter =
    DateTimeFormatter
        .ofPattern("MMM dd, yyyy - HH:mm");

LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
String string = formatter.format(parsed);
System.out.println(string);     // Nov 03, 2014 - 07:13


获取年、月、日等信息

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);

DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek);      // WEDNESDAY

Month month = sylvester.getMonth();
System.out.println(month);          // DECEMBER

long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay);    // 1439


时间格式化展示

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
LocalDateTime dateTime = LocalDateTime.of(1986, Month.APRIL, 8, 12, 30);
String formattedDateTime = dateTime.format(formatter); // "1986-04-08 12:30"


时间操作

localDateTime.plusDays(1);
localDateTime.minusHours(2);


时区转换
Timezones 以 ZoneId 来区分。可以通过静态构造方法很容易的创建，Timezones 定义了 Instants 与 Local Dates 之间的转化关系：

System.out.println(ZoneId.getAvailableZoneIds());
// prints all available timezone ids

ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");
System.out.println(zone1.getRules());
System.out.println(zone2.getRules());

// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00]
LocalDateTime ldt = ...
ZonedDateTime zdt = ldt.atZone(ZoneId.systemDefault());
Date output = Date.from(zdt.toInstant());
ZoneId losAngeles = ZoneId.of("America/Los_Angeles");
ZoneId berlin = ZoneId.of("Europe/Berlin");

// 2014-02-20 12:00
LocalDateTime dateTime = LocalDateTime.of(2014, 02, 20, 12, 0);

// 2014-02-20 12:00, Europe/Berlin (+01:00)
ZonedDateTime berlinDateTime = ZonedDateTime.of(dateTime, berlin);

// 2014-02-20 03:00, America/Los_Angeles (-08:00)
ZonedDateTime losAngelesDateTime = berlinDateTime.withZoneSameInstant(losAngeles);

int offsetInSeconds = losAngelesDateTime.getOffset().getTotalSeconds(); // -28800

// a collection of all available zones
Set<String> allZoneIds = ZoneId.getAvailableZoneIds();

// using offsets
LocalDateTime date = LocalDateTime.of(2013, Month.JULY, 20, 3, 30);
ZoneOffset offset = ZoneOffset.of("+05:00");

// 2013-07-20 03:30 +05:00
OffsetDateTime plusFive = OffsetDateTime.of(date, offset);

// 2013-07-19 20:30 -02:00
OffsetDateTime minusTwo = plusFive.withOffsetSameInstant(ZoneOffset.ofHours(-2));


时差
Period 类以年月日来表示日期差，而 Duration 以秒与毫秒来表示时间差；Duration 适用于处理 Instant 与机器时间。



// periods

LocalDate firstDate = LocalDate.of(2010, 5, 17); // 2010-05-17
LocalDate secondDate = LocalDate.of(2015, 3, 7); // 2015-03-07
Period period = Period.between(firstDate, secondDate);

int days = period.getDays(); // 18
int months = period.getMonths(); // 9
int years = period.getYears(); // 4
boolean isNegative = period.isNegative(); // false

Period twoMonthsAndFiveDays = Period.ofMonths(2).plusDays(5);
LocalDate sixthOfJanuary = LocalDate.of(2014, 1, 6);

// add two months and five days to 2014-01-06, result is 2014-03-11
LocalDate eleventhOfMarch = sixthOfJanuary.plus(twoMonthsAndFiveDays);


// durations

Instant firstInstant= Instant.ofEpochSecond( 1294881180 ); // 2011-01-13 01:13
Instant secondInstant = Instant.ofEpochSecond(1294708260); // 2011-01-11 01:11

Duration between = Duration.between(firstInstant, secondInstant);

// negative because firstInstant is after secondInstant (-172920)
long seconds = between.getSeconds();

// get absolute result in minutes (2882)
long absoluteResult = between.abs().toMinutes();

// two hours in seconds (7200)
long twoHoursInSeconds = Duration.ofHours(2).getSeconds();