精华内容
下载资源
问答
  • 时间与日期

    2018-11-21 15:26:35
    为此,Date类型使用UTC (Coordinated Universal Time,国际协调时间[又称世界统一时间]) 1970年1月1日午夜(零时)开始经过的毫秒来保存日期。在使用这种数据存储格式的条件,Date类型保存的日期能够精确到1970年1月...
    • 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()应该支持哪种日期格式,因此方法的行为因实现而异,因地区而异。默认通常接收的日期格式如下:

    1. '月/日/年',如6/13/2011;
    2. '英文月名 日, 年',如 May 25, 2004;
    3. '英文星期几 英文月名 日 年 时:分:秒 时区',如 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时间相差的分钟数

    展开全文
  • 一秒的日期与时间

    2016-09-30 12:45:30
    给你一个时间,输出一秒的时间,输入格式为:yyyy/mm/dd hh:mm:ss   #include #include #include 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)!=...

    给你一个时间,输出下一秒的时间,输入格式为: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_...

    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,因为这个设计时候是 70 年代

    #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组数字处理时间:

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

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

    序号属性
    0tm_year2008
    1tm_mon1 到 12
    2tm_mday1 到 31
    3tm_hour0 到 23
    4tm_min0 到 59
    5tm_sec0 到 61 (60或61 是闰秒)
    6tm_wday0到6 (0是周一)
    7tm_yday1 到 366(儒略历)
    8tm_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 时间与日期处理

    千次阅读 2017-07-24 10:46:11
    Java 时间与日期处理 王邀月熊 18 小时前 Java 时间与日期处理 从属于笔者的现代 Java 开发系列文章,涉及到的引用资料声明在 Java 学习与实践资料索引中。 Java 时间与日期处理 在 Java 8 之前,我们...

    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();
    
    展开全文
  • 今天我们一起来看Python的时间和日期,做过编程的同学都知道,很多开发语言中都有自带的时间与日期相关的类和函数方法,他们的我们不去一一赘述,我们先来看Python的时间和日期相关的知识点。 首先我们来了解...
  • Unix下时间日期

    千次阅读 2017-08-06 22:41:27
    时间日期历程UNIX内核提供的...UNIX在这方面其他操作系统的区别是:1)以协调统一时间而非本地时间计时;2)可自动进行转换,如变换到夏令时;3)将时间日期作为一个量值保存。time函数:返回当前时间日期。#i
  • cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
  • 安卓日期与时间控件

    2017-11-28 09:50:56
    安卓项目中,使用的日期与时间控件,自定义ViewDialog,可以上下滚动
  • 主要介绍了C++ boost 时间与日期处理详细介绍的相关资料,这里提供实例代码,及实现效果,需要的朋友可以参考
  • 主要介绍了Delphi实现读取系统时间与日期完整实例,需要的朋友可以参考
  • C++ —— 时间与日期

    2016-12-02 15:22:00
    在平时编程中有时需要获取当前的时间或者日期,然而不同的平台不同的场景,有时使用的API也不尽相同。一般来说,C/C++中关于时间的标准库函数在不同的平台的都可以使用,可一些平台相关的函数就只能在特定的平台...
  • 今天我们一起来看Python的时间和日期,做过编程的同学都知道,很多开发语言中都有自带的时间与日期相关的类和函数方法,他们的我们不去一一赘述,我们先来看Python的时间和日期相关的知识点。首先我们来了解...
  • Linux修改系统时间一般使用 date -s 命令。 比如将系统时间设定成今天:2010年08月11日,命令如下: # date -s 08/11/2010 将系统时间设定成17点49分0秒,命令如下: # date -s 17:49:00 注意:这里...
  • 前言: 在项目开发中,一些业务表字段经常使用日期时间...处理日期时间字段的函数有很多,有的经常会在查询中使用到,下面介绍几个相关函数的使用方法。 CURDATE 和 CURRENT_DATE 两个函数作用相同,返回当前
  • 详解Spring data 定义默认时间与日期的实例 前言: 需求是这样的: 1. 创建时间与更新时间只能由数据库产生,不允许在实体类中产生,因为每个节点的时间/时区不一定一直。另外防止人为插入自定义时间时间。 2. 插入...
  • 今天我们一起来看Python的时间和日期,做过编程的同学都知道,很多开发语言中都有自带的时间与日期相关的类和函数方法,他们的我们不去一一赘述,我们先来看Python的时间和日期相关的知识点。首先我们来了解...
  • 最近一直在头疼怎样在修改Settings-----Date&Time---Choose data format 后通知更新桌面时钟 AppWidget的日期格式跟着Setting的改变而改变... 想实现的效果就是如下: 原先日期格式是这样, 当点击修改Settings-----...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,743
精华内容 1,497
关键字:

下时间与日期