精华内容
下载资源
问答
  • Java时间时区

    万次阅读 2017-12-14 11:08:58
    0. 前言:时间格式://世界标准时间,其中T表示时分秒的开始(或者日期与...2017-12-13T09:47:07.153//含有时区信息的时间,+08:00表示时间是由世界标准时间加了8个小时得到的,[Asia/Shanghai]表示时区 2017-12-13

    0. 前言:

    时间格式:

    //世界标准时间,其中T表示时分秒的开始(或者日期与时间的间隔),Z表示这是一个世界标准时间
    2017-12-13T01:47:07.081Z
    
    //本地时间,也叫不含时区信息的时间,末尾没有Z
    2017-12-13T09:47:07.153
    
    //含有时区信息的时间,+08:00表示该时间是由世界标准时间加了8个小时得到的,[Asia/Shanghai]表示时区
    2017-12-13T09:47:07.153+08:00[Asia/Shanghai]
    

    其中最难理解的是本地时间,2017-12-13T09:47:07.153时间本身是不含有时区信息的,但是“本地”这两个字含有时间信息。所以我认为这个翻译并不好,不应该叫做“本地时间”,应该直接翻译为“不含时区信息的时间”。

    协调世界时,又称世界统一时间、世界标准时间、国际协调时间。由于英文(CUT)和法文(TUC)的缩写不同,作为妥协,简称UTC。
    世界时UT即格林尼治平太阳时间,是指格林尼治所在地的标准时间,也是表示地球自转速率的一种形式。以地球自转为基础的时间计量系统。

    1. 先来看Java8:

    表示时间的主要有4类String、Instant、LocalDateTime、ZonedDateTime

    String是格式化的时间,Instant是时间戳,LocalDateTime是不含时区信息的时间,ZonedDateTime是含有时区信息的时间。

    1.1 它们之间的关系是:

    1.1.1 String与LocalDateTime是等价的

    符合格式的String可以直接解析为LocalDateTime,如下:

    System.out.println(LocalDateTime.parse("2017-12-13 10:10:10",DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
    
    输出:
    2017-12-13T10:10:10
    

    辨析LocalDateTime最好的办法就是不要把它当成“本地时间”,它就是“不含时区信息的时间”。它只是存储了年月日时分秒,没有存储任何时区信息,具体表示哪里的时间全靠输入和输出时进行解释。与String完全等价,本质上是对String的解析,只是年月日时分秒格式化的存储到了对象当中,方便取用。

    1.1.2 Instant与ZonedDateTime是等价的

    Instant是时间戳,是指世界标准时格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数,Instant本身实际上就指明时区了,0时区。
    ZonedDateTime是含有时区信息的时间,本质上是根据时区对Instant的格式化显示。

    ZonedDateTime ztime1=ZonedDateTime.ofInstant(Instant.now(),ZoneId.systemDefault());
    System.out.println(ztime1);
    System.out.println(ztime1.toInstant()); //1
    System.out.println(ztime1.toLocalDateTime()); //3
    ZonedDateTime ztime2=ZonedDateTime.ofInstant(Instant.now(),ZoneId.of("Australia/Darwin"));
    System.out.println(ztime2);
    System.out.println(ztime2.toInstant()); //2
    System.out.println(ztime2.toLocalDateTime()); //4
    
    输出:
    2017-12-13T13:24:55.932+08:00[Asia/Shanghai]
    2017-12-13T05:24:55.932Z
    2017-12-13T13:24:55.932
    2017-12-13T14:54:55.933+09:30[Australia/Darwin]
    2017-12-13T05:24:55.933Z
    2017-12-13T14:54:55.933
    

    注释1、2输出相同,说明ZonedDateTime的存储本质是Instant;
    注释3、4输出不同,说明ZonedDateTime会根据创建ZonedDateTime对象时传入的时区,进行格式化显示。

    相同的Instant,在不同的时区有不同的展示时间,所以在用Instant构造ZonedDateTime的时候需要传入时区;ZonedDateTime可以直接转化为Instant,并且不同的ZonedDateTime可能会生成同样的Instant。

    1.2 如何构造时间对象:

    1.2.1 直接定义

    System.out.println(Instant.ofEpochMilli(System.currentTimeMillis()));
    System.out.println(LocalDateTime.of(2017,12,13,10,0,0,0));
    System.out.println(ZonedDateTime.of(2017,12,13,10,0,0,0,ZoneId.systemDefault()));
    
    输出:
    2017-12-13T06:22:06.581Z
    2017-12-13T10:00
    2017-12-13T10:00+08:00[Asia/Shanghai]
    

    1.2.2 获取系统当前时间now()

    System.out.println(Instant.now()); //世界标准时间
    System.out.println(LocalDateTime.now()); //会把世界标准时间转换为本时区的时间,但是时区信息会被丢弃
    System.out.println(ZonedDateTime.now()); //会把世界标准时间转换为本时区的时间,但是时区信息会被保留
    
    System.out.println(LocalDateTime.now(ZoneId.of("+00:00"))); //0时区的现在时间
    System.out.println(ZonedDateTime.now(ZoneId.of("+00:00"))); //0时区的现在时间
    
    输出:
    2017-12-14T02:53:05.830Z
    2017-12-14T10:53:05.904
    2017-12-14T10:53:05.906+08:00[Asia/Shanghai]
    2017-12-14T02:53:05.906
    2017-12-14T02:53:05.906Z
    

    1.2.3 解析String

    System.out.println(Instant.parse("2007-12-03T10:15:30Z")); //只能解析这种格式,不能自己指定
    System.out.println(LocalDateTime.parse("2017-12-13 11:51:12.083", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
    System.out.println(ZonedDateTime.parse("2017-12-13 11:51:12.083 +04:30", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS ZZZZZ")));
    
    输出:
    2007-12-03T10:15:30Z
    2017-12-13T11:51:12.083
    2017-12-13T11:51:12.083+04:30
    

    1.3 时间对象之间的转换:

    1.3.1 Instant与LocalDateTime、ZonedDateTime之间的转换

    Instant instant=Instant.now();
    LocalDateTime localDateTime=LocalDateTime.ofInstant(instant,ZoneId.systemDefault());
    ZonedDateTime zonedDateTime=ZonedDateTime.ofInstant(instant,ZoneId.systemDefault());
    
    System.out.println(instant);
    System.out.println(localDateTime);
    System.out.println(zonedDateTime);
    
    System.out.println(ZoneOffset.systemDefault());
    System.out.println(ZoneOffset.UTC);
    System.out.println(ZoneOffset.MIN);
    System.out.println(ZoneOffset.of("+08:00"));
    System.out.println(localDateTime.toInstant(ZoneOffset.UTC)); //在把LocalDateTime转换为Instant时,需要明确指定当前这个时间指的是那个时区的时间
    System.out.println(localDateTime.toInstant(ZoneOffset.of("+08:00")));
    System.out.println(zonedDateTime.toInstant());
    
    输出:
    2017-12-14T01:50:26.098Z
    2017-12-14T09:50:26.098
    2017-12-14T09:50:26.098+08:00[Asia/Shanghai]
    Asia/Shanghai
    Z
    -18:00
    +08:00
    2017-12-14T09:50:26.098Z
    2017-12-14T01:50:26.098Z
    2017-12-14T01:50:26.098Z
    

    1.3.2 LocalDateTime、ZonedDateTime之间的转换

    Instant instant=Instant.now();
    LocalDateTime localDateTime=LocalDateTime.ofInstant(instant,ZoneId.systemDefault());
    ZonedDateTime zonedDateTime=ZonedDateTime.ofInstant(instant,ZoneId.systemDefault());
    
    System.out.println(instant);
    System.out.println(localDateTime);
    System.out.println(zonedDateTime);
    
    System.out.println(ZonedDateTime.of(localDateTime,ZoneId.systemDefault())); //LocalDateTime转ZonedDateTime 
    System.out.println(zonedDateTime.toLocalDateTime()); //ZonedDateTime转LocalDateTime
    
    输出:
    2017-12-14T02:01:45.145Z
    2017-12-14T10:01:45.145
    2017-12-14T10:01:45.145+08:00[Asia/Shanghai]
    2017-12-14T10:01:45.145+08:00[Asia/Shanghai]
    2017-12-14T10:01:45.145
    

    1.4 时区之间的转换

    时区转换时要特别注意的是:用户输入的String类型的时间是没有时区信息的,需要人为指定解析。
    解析的步骤分2步:

    1. 先结合语境,分析用户时区,把用户输入的时间转化为世界标准时间;
    2. 再把世界标准时间转为需要的时区。

    1.5 关于时间的陷阱

    1.5.1 问题

    因为存在时区的概念,所以会造成2个问题:

    1. 不同时区的用户,对时间的理解不同,不同时区的同一个时间String不是同一个时间戳;
    2. 不同时区的服务器,对时间的理解也不同,比如,同一份程序运行在不同时区的服务器上,当这些程序同时调用LocalDateTime.now()时,返回的结果并不同,如果操作不当很容易出现问题;
    3. 如果前台和后台程序分别部署在不同时区的服务器上,情况会更加复杂。如果用户、前台和后台程序都不在相同时区,……。

    1.5.2 解决办法

    1. 建议在系统当中统一使用时间戳,包括前后台传输和数据库存储,只有在展示的时候再转化为字符串;
    2. 如果为了处理方便建议把所有的时间都转化到0时区进行处理。

    2. Java8以前的时间API

    JAVA API系列----日期和时间相关的类
    【总结】java.util.Date vs. java.sql.Date
    java.util.Date、java.sql.Date、java.sql.Time、java.sql.Timestamp区别和总结
    时区转换:java new Date() 变成GMT&& GMT时间与CST时间转换

    2.1 Date与时区

    Date对象中,有一个默认时区,取得是操作系统的默认时区。可以通过下面的代码进行修改:

    TimeZone.setDefault(TimeZone.getTimeZone("GMT")); // 将默认时区转化为GMT时区
    TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));// 将默认时区转化为东八区时区
    

    3. 新旧时间API的转换

    新旧时间API连接的桥梁是Date类和Instant类,这两个都是世界标准时间,但是Date打印的时候会转化为本地时间。

    Date date=Date.from(Instant.now());
    Instant instant=date.toInstant();
    System.out.println(date);
    System.out.println(date.getTime()); //1
    System.out.println(instant);
    System.out.println(instant.toEpochMilli()); //2
    
    输出:
    Thu Dec 14 11:45:58 CST 2017
    1513223158588
    2017-12-14T03:45:58.588Z
    1513223158588
    

    注释1、2输出相同,说明Date类和Instant类是等价的;


    4. 追加:Java8中计算日期时间差

    请参考此文:Java8中计算日期时间差,为查阅方便整理记录如下。
    在Java8中,我们可以使用以下类来计算日期时间差异:

    4.1 Period

    内部使用年、月、日进行存储,只支持用年、月、日来初始化,也只支持返回年、月、日这三种单位。

    public final class Period
            implements ChronoPeriod, Serializable {
    
        private final int years;
    
        private final int months;
    
        private final int days;
    
    	//-----------------------------------------------------------------------
      
        public int getYears() {
            return years;
        }
    
       
        public int getMonths() {
            return months;
        }
    
        public int getDays() {
            return days;
        }
    
    }
    

    4.2 Duration

    内部使用秒、纳秒进行存储,支持用天、小时、分钟、秒、毫秒、纳秒来初始化,也支持返回天、小时、分钟、秒、毫秒、纳秒这几种单位。

    public final class Duration
            implements TemporalAmount, Comparable<Duration>, Serializable {
    
    
        private final long seconds;
    
        private final int nanos;
        
        //-----------------------------------------------------------------------
       
        public long getSeconds() {
            return seconds;
        }
    
        public int getNano() {
            return nanos;
        }
    
        //-----------------------------------------------------------------------
    
        public long toDays() {
            return seconds / SECONDS_PER_DAY;
        }
    
        public long toHours() {
            return seconds / SECONDS_PER_HOUR;
        }
    
        public long toMinutes() {
            return seconds / SECONDS_PER_MINUTE;
        }
    
        public long toMillis() {
            long millis = Math.multiplyExact(seconds, 1000);
            millis = Math.addExact(millis, nanos / 1000_000);
            return millis;
        }
        
        public long toNanos() {
            long totalNanos = Math.multiplyExact(seconds, NANOS_PER_SECOND);
            totalNanos = Math.addExact(totalNanos, nanos);
            return totalNanos;
        }
    
    }
    

    演示:

    public static void main(String[] args) {
            long l = Duration.ofDays(3).toNanos() + 5;
            Duration duration = Duration.ofNanos(l);
            System.out.println(l); // 259200000000005
            System.out.println(duration.toDays()); // 3
            System.out.println(duration.toHours()); // 72
            System.out.println(duration.toMinutes()); // 4320
            System.out.println(duration.getSeconds()); // 259200
            System.out.println(duration.toMillis()); // 259200000
            System.out.println(duration.getNano()); // 5 (注意:这一行与下一行的区别,getNano表示获取nanos变量存的值)
            System.out.println(duration.toNanos()); // 259200000000005 (toNanos表示将区间转换为纳秒单位)
        }
    

    4.3 ChronoUnit:

    本职工作是提供时间单位,但是其提供了一个between方法,所以也可以用来测量时间段(并且可以指定单位)。
    如,间隔几小时:

    		Instant a = Instant.now();
            Instant b = Instant.now().plus(1, ChronoUnit.HOURS);
            System.out.println(ChronoUnit.HOURS.between(a, b));
    

    实际上是包装了until函数:

    	public long between(Temporal temporal1Inclusive, Temporal temporal2Exclusive) {
    		return temporal1Inclusive.until(temporal2Exclusive, this);
       }
    

    4.4 until:

    如果已经有了两个时间点,建议直接使用时间点的until函数。

    		Instant a = Instant.now();
            Instant b = Instant.now().plus(1, ChronoUnit.HOURS);
            System.out.println(a.until(b, ChronoUnit.HOURS));
    

    5. 后台接口中的时间参数

    5.1 无配置接收

    1. yyyy-[m]m-[d]d hh:mm:ss[.f…]
      可以使用java.sql.Timestamp接收
    2. yyyy-[m]m-[d]d
      可以使用java.sql.Date接收
    3. Sat, 12 Aug 1995 13:30:00 GMT
      可以使用java.util.Date接收

    5.2 有配置接收

    自己编写convert类,并注册到spring框架中
    参见:
    [1] springboot Date解析String类型的参数
    [2] @DateTimeFormat格式化JSON日期时间(Date或timestamp)无效的原因 / Spring格式化json日期时间(Date或timestamp)的方法

    5.3 自定义时间类

    自己编写可以作为参数的时间类
    参见:Annotation Type QueryParam

    被@QueryParam注解的参数,必须满足一下条件中的一个:

    1. 原始类型
    2. 有一个构造函数接受一个String参数
    3. 有一个名为valueOf或fromString的静态方法,它接受一个String参数(例如,参见Integer.valueOf(String))
    4. 列表< T>,< T>或SortedSet T,其中T满足上述2或3。生成的集合是只读的。
    展开全文
  • lua时区时间

    万次阅读 2017-04-05 19:14:16
    lua时间库 一、时间的三种格式 ...这里的 1131286477 是一个以秒单位的 格林威志时间(gmt),注意不同时区的时差 关于时间戳: 时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日

    参考链接:1 2,请点击连接查看原文,尊重楼主版权。本文自己加了点总结和新手保护机制。

    lua中的时间库


    1. os.time()

    原型:os.time ([table])
    解释:按table的内容返回一个时间值(数字),若不带参数则使用当前时间(本时区此刻时间)作为table内容,其中table中可以包含的字段有:year, month, day, hour, min, sec, isdst,其他字段将会被忽略。

    案例:

    local nowtime = os.time();
    print("nowtime = "..nowtime)
    --nowtime = 1494833502
    
    local exampletime = os.time({year=2008,month=8,day=8,hour=20,min=0,sec=0});
    print("exampletime = "..exampletime)
    --exampletime = 1218196800
    
    local origintime = os.time({year=1970,month=1,day=1,hour=8,min=0,sec=0});
    print("origintime = "..origintime)
    --origintime = 0
    
    -- 错误的时间
    local errortime = os.time({year=1970,month=1,day=1,hour=0,min=0,sec=0});
    print("errortime = "..(errortime or "nil"))
    --errortime = nil
    
    -- 完整日期
    local testtime1 = os.time({year=2008,month=1,day=1,hour=8,min=0,sec=0,isdst=false});
    print("testtime1 = "..testtime1)
    --testtime1 = 1199145600
    
    -- 去掉isdst
    local testtime2 = os.time({year=2008,month=1,day=1,hour=8,min=0,sec= 0});
    print("testtime2 = "..testtime2)
    --testtime2 = 1199145600
    
    -- 去掉sec
    local testtime3 = os.time({year=2008,month=1,day=1,hour=8,min=0});
    print("testtime3 = "..testtime3)
    --testtime3 = 1199145600
    
    -- 去掉min
    local testtime4 = os.time({year=2015,month=1,day=1,hour=8});
    print("testtime4 = "..testtime4)
    --testtime4 = 1420070400
    
    -- photo纪念日:年月日
    local testtime5 = os.time({year=2016,month=7,day=17});
    print("testtime5 = "..testtime5)
    --testtime5 = 1468728000
    
    -- 去掉day
    --local testtime6 = os.time({year=2016,month=7});
    --print("testtime6 = "..testtime6) --报错

    总结:

    -1- os.time()不加参数表示当前时间的时间戳,这个函数在任意时区下获取到结果一致,因为都表示格林尼治时间1970.01.01-00:00:00到现在这个点格林尼治时间经过的秒数。不管你的时区是什么,这个值是一个绝对的值。


    -2- os.time(table)得到格林尼治时间为1970.01.01-00:00:00时本时区的时间(北京为8点)到本时区table时刻,经过的秒数。

    --这个函数返回一个值意味着它依赖于你的操作系统,在POSIX ,Windows和一些其他的操作系统上,这个数字是记录了时间原点(1970-01-01)到指点时间的秒数,在个别的系统上结果未定义。


    -3- 由origintime可以看出时间从原点到1970-1-1 08:00:00返回的时间居然是0,其实这是由于时区导致的,北京时间的1970-1-1 08:00:00恰好是0时区时间的1970-1-1 00:00:00,所以返回的时间是0;如果做运算的系统时区是0时区,则os.time({year=1970,month=1,day=1,hour=8,min=0,sec=0})将返回8*3600.


    -4- 明白了origintime相信你就会知道errortime为什么会返回nil了,因为那个时间还没开始计时呢,理论上应该是负值。


    -5- 从结果上来看,最后的一次调用造成了程序的出错,那是因为table的几个字段中year, month, day是必填的,而hour, min, sec, isdst是可选的。


    -6- 还有一点hour, min, sec这几个值的范围不一定是正常的时间,甚至可以是负数,比如时间08:62:-10就代表了09:01:50。


    2. os.date()

    原型:os.date ([format [, time]])
    解释:返回一个按format格式化日期、时间的字串或表。

    参数格式:

    简单理解:

    没有"!":格林尼治时间0点时候的本地时间,加上第二个参数的秒数,得到的新的本地时间;如:os.date("*t", os.time())表示本地现在时间table

    有"!":格林尼治时间0点,加上第二个参数的秒数的时间。如:os.date("!*t", os.time())表示此时格林尼治时间。

    由原型可以看出可以省略第二个参数也可以省略两个参数,只省略第二个参数函数会使用当前时间(当前本地时间戳)作为第二个参数,如果两个参数都省略则按当前系统的设置返回格式化的字符串,做以下等价替换 os.date() <=> os.date("%c")。

    如果format以“!”开头,则按格林尼治时间进行格式化。
    如果format是一个“*t”,将返一个带year(4位),month(1-12), day (1--31), hour (0-23), min (0-59),sec (0-61),wday (星期几, 星期天为1), yday (年内天数)和isdst (是否为日光节约时间(夏令时)true/false)的带键名的表;

    使用format "*t"返回的table中wday如果是1表示星期天,而使用通用格式时%w用0表示星期天。


    如果format不是“*t”,os.date会将日期(2参数没有则为本地时间)格式化为一个字符串,具体如下:


    print(os.date("today is %c, in %A"))         --today is 05/16/17 11:43:16, in Tuesday
    print(os.date("1060004s is %x", 1060004)) --1060004s is 01/13/70


    3. os.difftime()

    原型:os.difftime (t2, t1)

    解释:返回以秒计算的时刻t1到 t2 的差值。 在Windows,和其它一些系统中,这个值就等于 t2-t1。

    -- 奥运会的时间
    local tab = {year=2008, month=8, day=8, hour=20}
    local pretime = os.time(tab)
    print(os.date("08 Olympic Games time is %x", pretime))
    --08 Olympic Games time is 08/08/08
    
    -- 现在的时间
    local timetable = os.date("*t"); 
    local nowtime = os.time(timetable)
    print(os.date("now time is %c", nowtime))
    --now time is 05/16/17 13:33:13
    
    local difft = os.difftime(nowtime, pretime);
    print("from 08 Olympic Games to now cost time "..difft.."s");
    --from 08 Olympic Games to now cost time 276715993s


    4.常用方法:

    1/ 获取客户端当前时间戳、时间table: os.time()  、 os.date("*t",os.time())


    2/ 获取格林尼治此刻时间table :  os.date("!*t", os.time()) 


    3/ 获取客户端当前时区:os.difftime(now, os.time(os.date("!*t", os.time())))/3600

    解释: os.time(os.date("!*t", os.time())表示先记下这个格林尼治时间,返回本时区是这个时间table的时候的时间戳。
    os.difftime(now, os.time(os.date("!*t", os.time()))) --前面减去后面表示当前时区时间比格林尼治时间大的秒数;
    --除以3600就是大的小时数,1时区1小时,所以表示比0时区大的时区数.


    4/ 获取服务器目前时间table:

    local cur_time=os.time()+3600*(服务器时区-客户端时区)

    --本时区目前时间table
     local now_time_table=os.date("*t",cur_time)


    5/ 夏令时:夏令时,又称“日光节约时制”和“夏令时间”,是一种为节约能源而人为规定地方时间的制度,在这一制度实行期间所采用的统一时间称为“夏令时间”。

    夏令时 一种法定的时间。夏天太阳升起得比较早,白天时间很长。为了节约能源和充分利用白天的宝贵时间,世界上不少国家都采用法律规定的形式,每到夏天就将这个国家使用的时间提前一小时,也有提前半小时或几小时的;到了冬季,又将拨快的时间拨回来。这样的时间就是“夏令时”,是一种法定时间。我国曾于1986年到1991年每年从四月的第二个星期天早上2点钟,到九月的第二个星期天早上2点钟,在这段时期内,全国都将时间拨快1小时,实行夏令时。从九月的第二个星期天早上2点钟起,又将拨快的时间重新拨回来,直到第二年四月的第二个星期天早上2点钟。现在中国已取消夏令时,有些国家还在用。

    返回客户端是否夏令时:local now_time_table=os.date("*t",os.time());   return now_time_table.isdst;

    如果是夏令时,则计算时间时可以client_time_zone=client_time_zone+1以后一个时区时间计算,否则client_time_zone=client_time_zone。


    6/ 传入活动结束时间的时间戳,显示时间(根据客户端时区不同,会显示不同)

    function get_format_time(time)   --根据时间戳获取时间,排布
        local format = os.date("*t", time) --获取当时本地时间
        local format_time = string.format("%d/%d/%d %02d:%02d:%02d",format.year,format.month,format.day,format.hour,format.min,format.sec)
             return format_time
    end


    --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------



    一、时间的三种格式

    1、用数值表示时间值 (时间戳)
    用数字值来表示时间值,
    实际上时间值的本质就是一个数字值。
    例如:
    d = 1131286477 
    这里的 1131286477 是一个以秒为单位的 格林威志时间(gmt),注意不同时区的时差

    关于时间戳:

    时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。

    2、用字符串表示时间 (string)
    用字符串来来表示时间。
    例如:
    d = "2005-11-06 22:18:30" --2005年11月6日 22点18分30秒
    d = "11/06/2005 22:18:30" --即2005年11月6日 22点18分30秒


    3、时间的列表格式 (table)
    用table对象来表示时间
    例如:
    d = {year=2005, month=11, day=6, hour=22,min=18,sec=30,isdst=false}
    --同样表示2005年11月6日 22点18分30秒,其中isdst=false表示不使用夏令时
    --夏时制,夏时令(Daylight Saving Time:DST),又称“日光节约时制”和“夏令时间”,是一种为节约能源而人为规定地方时间的制度,在这一制度实行期间所采用的统一时间称为“夏令时间”。一般在天亮早的夏季人为将时间提前一小时,可以使人早起早睡,减少照明量,以充分利用光照资源,从而节约照明用电。各个采纳夏时制的国家具体规定不同。目前全世界有近110个国家每年要实行夏令时。
    我们可以这样访问时间列表 d.year = 2005;


    二、取得数值(number)格式的时间值 (转换为时间戳)
    time = os.time()返回一个标准的number(数值)格式的时间值,这也是最原始的时间值
    os.time()返回的时间是以秒为单位的。

    1、获取当前时间数值
    time = os.time(); 
    --如果没有指定任何参数,则返回当前时间

    2、通过table参数指定时间,获取指定的时间数值
    time = os.time(tab);通过一个table参数,指定一个时间,返回时间的数值格式.
    例如:
    local tab = {year=2005, month=11, day=6, hour=22,min=18,sec=30,isdst=false}
    --year表示年,month表示月,day表示日期,hour表示小时,min表示分钟,sec表示秒,isdst表示是否夏令时 
    time = os.time(tab) -->返回值为1131286710

    三、取得列表(table)格式的时间(时间戳转换为table)
    tab = os.date("*t",time)
    可以将一个数值格式的时间转换为字符串或者列表
    其中第一个参数指定返回的格式,如果第一个参数指定为"*t" 则返回一个table格式的时间。
    第二个参数指定一个时间数值时间戳(以秒为单位)

    1、获取当前时间的table格式
    tab = os.date("*t") 如果不指定os.date的第二个参数,则返回当前时间的table表示格式

    2、通过时间数值,获取指定时间的table格式
    tab = os.date("*t", time)通过os.date函数的第二个参数指定一个时间数值。
    例如:
    local tab = os.date("*t", 1131286710);
    --返回值 tab 的数据 {year=2005, month=11, day=6, hour=22,min=18,sec=30}
    --year表示年,month表示月,day表示日期,hour表示小时,min表示分钟,sec表示秒,isdst表示是否夏令时 
    --tab成包括一些其他的成员 tab.yday 表示一年中的第几天 tab.wday 表示星期几(星期天为1)
    time = os.time(tab) -->返回值为1131286710
    二、取得数值(number)格式的时间值 (转换为时间戳)
    time = os.time()返回一个标准的number(数值)格式的时间值,这也是最原始的时间值
    os.time()返回的时间是以秒为单位的。
    四、取得时间的字符串(string)格式
    tab = os.date(format,time)
    实际上与取得table格式的时间一样,同样是使用os.date参数,不同的是第一个参数
    如果第一个参数不是"*t" os.date返回字符串

    os.date 的用法与 string.ftime 完全相同
    例如:
    win.consoleOpen()
    print(  os.date("today is %A, in %B")  )
    print(  os.date("%x", 906000490)  )
    --输出类似这样的字符串 09/16/1998
    1、获取当前时间的字符串(string)格式
    如果不指定os.date的第二个参数,则返回当前时间的table表示格式
    例如:
    str= os.date("*x")

    2、通过时间数值,获取指定时间的(string)格式
    通过os.date函数的第二个参数指定一个时间数值。
    例如:
    str= os.date("*x",1131286710)

    3、获取时间的指定部份的(string)格式
    例如:
    str = os.date("%M") --返回当前时间分钟部份的字符串格式

    五、时间数值与字符串之间的转换
    请参考:string.time string.ftime 函数用法

    六、计算时间值间隔
    int = os.difftime(t2,t1);

    t2,t1都是数值格式的时间值,返回值也是一个数值表示间隔的时间。


    参数以及返回的时间值都是以秒为单位的数值格式。
    local tab = {year=2005, month=11, day=6, hour=22,min=18,sec=30,isdst=false}
    t1 = os.time(tab)
    tab.day = tab.day +1;--前进一天
    t2 = os.time(tab)
    int = os.difftime(t2,t1);
    win.messageBox(int.."秒","时间差"

    七、系统时钟
    int = os.tick();
    读取系统时钟,以毫秒为单位。表示从系统启动到当前时刻所过去的毫秒数。
    int = os.clock()
    读取系统时钟,以秒为单位。表示从系统启动到当前时刻所过去的秒数。
    注意 :
    因为内部实现的差异,os.tick 与 os.clock()的返回值并不完全一致。


    local getTime = os.date(“%c”);

    其中的%c可以是以下的一种:(注意大小写)


    %a abbreviated weekday name (e.g., Wed)
    %A full weekday name (e.g., Wednesday)
    %b abbreviated month name (e.g., Sep)
    %B full month name (e.g., September)
    %c date and time (e.g., 09/16/98 23:48:10)
    %d day of the month (16) [01-31]
    %H hour, using a 24-hour clock (23) [00-23]
    %I hour, using a 12-hour clock (11) [01-12]
    %M minute (48) [00-59]
    %m month (09) [01-12]
    %p either “am” or “pm” (pm)
    %S second (10) [00-61]
    %w weekday (3) [0-6 = Sunday-Saturday]
    %x date (e.g., 09/16/98)
    %X time (e.g., 23:48:10)
    %Y full year (1998)
    %y two-digit year (98) [00-99]
    %% the character ‘%’
    如获取当前年月日时分秒:local date=os.date(“%Y-%m-%d %H:%M:%S”);

    os.time()
    获取当前秒


    展开全文
  • Java时间时区__java

    千次阅读 2019-01-11 14:21:53
    前言: 时间格式: //世界标准时间,其中T表示时分秒的开始(或者日期与时间的间隔),Z表示这是一个世界标准时间 2017-12-13T01:47:07.081Z //本地时间,也叫不含时区信息的时间时间格式: //世界标准时间,...

         转:https://yq.aliyun.com/ziliao/245667

         摘要: 本文讲的是Java中的时间与时区__java, 0. 前言: 时间格式: //世界标准时间,其中T表示时分秒的开始(或者日期与时间的间隔),Z表示这是一个世界标准时间 2017-12-13T01:47:07.081Z //本地时间,也叫不含时区信息的时间。

    时间格式:

    //世界标准时间,其中T表示时分秒的开始(或者日期与时间的间隔),Z表示这是一个世界标准时间 
    
    
    2017-12-13T01:47:07.081Z 
    
    //本地时间,也叫不含时区信息的时间,末尾没有Z 
    
    2017-12-13T09:47:07.153 
    
    //含有时区信息的时间,+08:00表示该时间是由世界标准时间加了8个小时得到的,[Asia/Shanghai]表示时区 
       
    2017-12-13T09:47:07.153+08:00[Asia/Shanghai]

          其中最难理解的是本地时间,2017-12-13T09:47:07.153时间本身是不含有时区信息的,但是“本地”这两个字含有时间信息。所以我认为这个翻译并不好,不应该叫做“本地时间”,应该直接翻译为“不含时区信息的时间”。

         协调世界时,又称世界统一时间、世界标准时间、国际协调时间。由于英文(CUT)和法文(TUC)的缩写不同,作为妥协,简称UTC。 
    世界时UT即格林尼治平太阳时间,是指格林尼治所在地的标准时间,也是表示地球自转速率的一种形式。以地球自转为基础的时间计量系统。 

    1. 先来看Java8:

          表示时间的主要有4类String、Instant、LocalDateTime、ZonedDateTime

          String是格式化的时间,Instant是时间戳,LocalDateTime是不含时区信息的时间,ZonedDateTime是含有时区信息的时间。 

    1.1 它们之间的关系

    1.1.1 String与LocalDateTime是等价的

           符合格式的String可以直接解析为LocalDateTime,如下:

    System.out.println(LocalDateTime.parse("2017-12-13 10:10:10",DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); 
    输出: 2017-12-13T10:10:10

           辨析LocalDateTime最好的办法就是不要把它当成“本地时间”,它就是“不含时区信息的时间”。它只是存储了年月日时分秒,没有存储任何时区信息,具体表示哪里的时间全靠输入和输出时进行解释。与String完全等价,本质上是对String的解析,只是年月日时分秒格式化的存储到了对象当中,方便取用。

     1.1.2 Instant与ZonedDateTime是等价的

         Instant是时间戳,是指世界标准时格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数,Instant本身实际上就指明时区了,0时区。 
         ZonedDateTime是含有时区信息的时间,本质上是根据时区对Instant的格式化显示。

    ZonedDateTime ztime1=ZonedDateTime.ofInstant(Instant.now(),ZoneId.systemDefault()); 
    System.out.println(ztime1); System.out.println(ztime1.toInstant()); 
    System.out.println(ztime1.toLocalDateTime()); 
    ZonedDateTime ztime2=ZonedDateTime.ofInstant(Instant.now(),ZoneId.of("Australia/Darwin")); 
    System.out.println(ztime2); 
    System.out.println(ztime2.toInstant()); 
    System.out.println(ztime2.toLocalDateTime()); 
     输出: 
    2017-12-13T13:24:55.932+08:00[Asia/Shanghai] 
    2017-12-13T05:24:55.932Z 
    2017-12-13T13:24:55.932 
    2017-12-13T14:54:55.933+09:30[Australia/Darwin] 
    2017-12-13T05:24:55.933Z 
    ​​​​​​​2017-12-13T14:54:55.933

    注释1、2输出相同,说明ZonedDateTime的存储本质是Instant; 
    注释3、4输出不同,说明ZonedDateTime会根据创建ZonedDateTime对象时传入的时区,进行格式化显示。

    相同的Instant,在不同的时区有不同的展示时间,所以在用Instant构造ZonedDateTime的时候需要传入时区;ZonedDateTime可以直接转化为Instant,并且不同的ZonedDateTime可能会生成同样的Instant。 

    1.2 如何构造时间对象:1.2.1 直接定义

    System.out.println(Instant.ofEpochMilli(System.currentTimeMillis())); System.out.println(LocalDateTime.of(2017,12,13,10,0,0,0)); System.out.println(ZonedDateTime.of(2017,12,13,10,0,0,0,ZoneId.systemDefault())); 
    输出: 2017-12-13T06:22:06.581Z 2017-12-13T10:00 2017-12-13T10:00+08:00[Asia/Shanghai]

    1.2.2 获取系统当前时间now()

    System.out.println(Instant.now()); //世界标准时间 
    System.out.println(LocalDateTime.now()); //会把世界标准时间转换为本时区的时间,但是时区信息会被丢弃 System.out.println(ZonedDateTime.now()); //会把世界标准时间转换为本时区的时间,但是时区信息会被保留 System.out.println(LocalDateTime.now(ZoneId.of("+00:00"))); //0时区的现在时间 System.out.println(ZonedDateTime.now(ZoneId.of("+00:00"))); //0时区的现在时间 
    输出: 2017-12-14T02:53:05.830Z 
    2017-12-14T10:53:05.904 
    2017-12-14T10:53:05.906+08:00[Asia/Shanghai] 
    2017-12-14T02:53:05.906 2017-12-14T02:53:05.906Z

    1.2.3 解析String

    System.out.println(Instant.parse("2007-12-03T10:15:30Z")); //只能解析这种格式,不能自己指定 System.out.println(LocalDateTime.parse("2017-12-13 11:51:12.083", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"))); 
    System.out.println(ZonedDateTime.parse("2017-12-13 11:51:12.083 +04:30", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS ZZZZZ"))); 
    输出: 
    2007-12-03T10:15:30Z 
    2017-12-13T11:51:12.083 
    2017-12-13T11:51:12.083+04:30

    1.3 时间对象之间的转换: 1.3.1 Instant与LocalDateTime、ZonedDateTime之间的转换

    Instant instant=Instant.now(); 
    LocalDateTime localDateTime=LocalDateTime.ofInstant(instant,ZoneId.systemDefault()); 
    ZonedDateTime zonedDateTime=ZonedDateTime.ofInstant(instant,ZoneId.systemDefault()); 
    System.out.println(instant); 
    System.out.println(localDateTime); 
    System.out.println(zonedDateTime); 
    System.out.println(ZoneOffset.systemDefault()); 
    System.out.println(ZoneOffset.UTC); 
    System.out.println(ZoneOffset.MIN); 
    System.out.println(ZoneOffset.of("+08:00")); 
    System.out.println(localDateTime.toInstant(ZoneOffset.UTC)); 
    //在把LocalDateTime转换为Instant时,需要明确指定当前这个时间指的是那个时区的时间 System.out.println(localDateTime.toInstant(ZoneOffset.of("+08:00"))); System.out.println(zonedDateTime.toInstant()); 
    输出: 
    2017-12-14T01:50:26.098Z
    2017-12-14T09:50:26.098 
    2017-12-14T09:50:26.098+08:00[Asia/Shanghai] 
    Asia/Shanghai Z -18:00 +08:00 
    2017-12-14T09:50:26.098Z 
    2017-12-14T01:50:26.098Z 
    2017-12-14T01:50:26.098Z

    1.3.2 LocalDateTime、ZonedDateTime之间的转换

    Instant instant=Instant.now(); 
    LocalDateTime localDateTime=LocalDateTime.ofInstant(instant,ZoneId.systemDefault()); 
    ZonedDateTime zonedDateTime=ZonedDateTime.ofInstant(instant,ZoneId.systemDefault()); 
    System.out.println(instant); 
    System.out.println(localDateTime); 
    System.out.println(zonedDateTime); 
    System.out.println(ZonedDateTime.of(localDateTime,ZoneId.systemDefault())); //LocalDateTime转ZonedDateTime System.out.println(zonedDateTime.toLocalDateTime()); //ZonedDateTime转LocalDateTime 
    输出: 
    2017-12-14T02:01:45.145Z 
    2017-12-14T10:01:45.145 
    2017-12-14T10:01:45.145+08:00[Asia/Shanghai] 
    2017-12-14T10:01:45.145+08:00[Asia/Shanghai] 
    2017-12-14T10:01:45.145

    1.4 时区之间的转换

        时区转换时要特别注意的是:用户输入的String类型的时间是没有时区信息的,需要人为指定解析。 
    解析的步骤分2步: 先结合语境,分析用户时区,把用户输入的时间转化为世界标准时间; 再把世界标准时间转为需要的时区。 

    1.5 关于时间的陷阱 1.5.1 问题

        因为存在时区的概念,所以会造成2个问题: 不同时区的用户,对时间的理解不同,不同时区的同一个时间String不是同一个时间戳; 不同时区的服务器,对时间的理解也不同,比如,同一份程序运行在不同时区的服务器上,当这些程序同时调用LocalDateTime.now()时,返回的结果并不同,如果操作不当很容易出现问题; 如果前台和后台程序分别部署在不同时区的服务器上,情况会更加复杂。如果用户、前台和后台程序都不在相同时区,……。 

    1.5.2 解决办法 建议在系统当中统一使用时间戳,包括前后台传输和数据库存储,只有在展示的时候再转化为字符串; 如果为了处理方便建议把所有的时间都转化到0时区进行处理。

     2. Java8以前的时间API

    JAVA API系列—-日期和时间相关的类 
    时区转换:java new Date() 变成GMT&& GMT时间与CST时间转换 

    3. 新旧时间API的转换

    新旧时间API连接的桥梁是Date类和Instant类,这两个都是世界标准时间,但是Date打印的时候会转化为本地时间。

    Date date=Date.from(Instant.now()); 
    Instant instant=date.toInstant(); 
    System.out.println(date); 
    System.out.println(date.getTime()); //1 
    System.out.println(instant); 
    System.out.println(instant.toEpochMilli()); //2 
    输出: Thu Dec 14 11:45:58 CST 2017 
    1513223158588 
    2017-12-14T03:45:58.588Z 
    1513223158588

    注释1、2输出相同,说明Date类和Instant类是等价的;

         以上是Java中的时间与时区__java的全部内容,在云栖社区的博客、问答、云栖号、人物、课程等栏目也有Java中的时间与时区__java的相关内容,欢迎继续使用右上角搜索按钮进行搜索java , java8 , 日期 时间 ,以便于您获取更多的相关知识。

    展开全文
  • linuxc++时间时区简介

    千次阅读 2013-09-03 17:48:01
    GMT时间叫做格林威治时间,也就是UTC时间,这个时间有点特殊,它所在时区为0,在这个时区内,本地时间和GMT时间完全一致,地球上其他地方的时间都得在这个时间基础上加一个时区,这才是其他地方的本地时间。...

     c++中时间主要分为GMT时间和本地时间。GMT时间叫做格林威治时间,也就是UTC时间,这个时间有点特殊,它所在时区为0,在这个时区内,本地时间和GMT时间完全一致,地球上其他地方的时间都得在这个时间基础上加一个时区,这才是其他地方的本地时间。地球被分为24个时区,相邻时区相差一个小时。比如中国上海是+8区,意思就是,假如格林威治现在是27日1点0分0秒,而中国上海就是27日早上9点0分0秒。我们比格林威治早8个小时进入27号。具体的时区信息请看《 http://zh.wikipedia.org/wiki/时区列表 》,(时区从UTC-12到UTC+14)

        时区信息存放在/usr/share/zoneinfo/中,如上海时区文件就是/usr/share/zoneinfo/Asia/Shanghai中。时区可以由环境变量TZ设置,上海的就可以export TZ="Asia/Shanghai"。在c++程序中调用tzset()函数可以由环境变量TZ初始化时区信息。如果没有环境变量TZ,tzset()还会使用/etc/localtime来初始化时区信息。TZ环境变量可以指向绝对路径,也可以是相对路径。如果是相对路径则以/usr/share/zoneinfo/为基准路径。
        日光节约时间(daylight saving time; DST)又称夏令时间或夏时制,由于夏季太阳升起的时间比冬季早(特别是高纬度地区),人们为了充分利用日照来节省照明用电,因此特地将时间提起一个小时让民众能够早睡早期,这个制度叫做日光节约时间。世界上一百多个国家或地区实行,包含台湾,香港,日本,美国,欧洲,但中国大陆好像没有实行。在struct tm中有一项tm_isdst表示日光节约时间,当为0时,表示没有日光节约时间,当小于0时表示根据系统的时区信息来判断是否执行日光节约时间。当大于0时,表示应该加的日光节约时间,单位为秒。
        在c++中有一个时间点比较重要,那就是GMT的1970-01-01 00:00:00 +0000 (UTC)。这是在0时区的时间,即格林威治时间或UTC时间,这个时间学名叫做Epoch,新纪元。为什么这个时间比较特殊?因为如果你在那个时刻调用time()函数,你会发现返回的值是0! 现在我们随便去调一把,返回的都是10位数了。我刚才调了一下是1309164941,是UTC时间的2011-06-27 08:55:41 +0000 (UTC),也是中国时间的2011-06-27 16:55:41 +7080 (CST)。7080是16进制数,等于10进制的28800秒,即8个小时。
        c++的时间中,有几个数据结构比较常用,struct tm。
    1. struct tm {  
    2.     int tm_sec;         /* seconds */  
    3.     int tm_min;         /* minutes */  
    4.     int tm_hour;        /* hours */  
    5.     int tm_mday;        /* day of the month */  
    6.     int tm_mon;         /* month */  
    7.     int tm_year;        /* year */  
    8.     int tm_wday;        /* day of the week */  
    9.     int tm_yday;        /* day in the year */  
    10.     int tm_isdst;       /* daylight saving time */  
    11. };  
    12. struct timeval {  
    13.     time_t      tv_sec;     /* seconds */  
    14.     suseconds_t tv_usec;    /* microseconds */  
    15. };  
    16. struct timezone {  
    17.     int tz_minuteswest;     /* minutes west of Greenwich */  
    18.     int tz_dsttime;         /* type of DST correction */  
    19. };  

        下面介绍c++中的几个重要时间函数。
    1. time_t time(time_t *t);  

        这大概能算是最常用的一个时间函数了,该函数返回从Epoch开始的秒数,如果t != NULL,则返回值填充到t所指的内存中。注意:返回的是UTC标准的秒数,如果你在格林威治和上海同时调用这个函数,则这2个值是一样的,都是格林威治的当前秒数,并没有算时区。

    1. int gettimeofday(struct timeval *tv, struct timezone *tz);  
    2. int settimeofday(const struct timeval *tv, const struct timezone *tz);  

        这个timeval是相对time_t更精确的时间,包含了微妙数。tv_usec最大为999999,再加1则为1秒,超过1秒就进位到tv_sec。timezone一般传入NULL,linux没有处理timezone中的tz_dsttime信息。

    1. struct tm *gmtime(const time_t *timep);  
    2. struct tm *gmtime_r(const time_t *timep, struct tm *result);  

        这两个函数意思一样,将time_t这个秒数转换成以UTC时区为标准的年月日时分秒时间。gmtime_r是线程安全的,推荐使用这个。gmtime返回的是一个struct tm*,这个指针指向一个静态的内存,这块区域是会经常被改动的。你刚调用gmtime(),执行了其他几条命令,然后想使用刚才gmtime()得到struct tm,会发现内容不对了,所以很危险,我就被搞得一头雾水,再gdb了多次之后,发现是这么个情况,改用gmtime_r后就没有问题,gmtime_r会将结果保存到你传入的内存中。

    1. struct tm *localtime(const time_t *timep);  
    2. struct tm *localtime_r(const time_t *timep, struct tm *result);  

        这两个函数意思也一样,会根据时区信息得到本地时间,在上海同时调用localtime_r 和gmtime_r会发现,localtime_r得到小时数会多8,因为我们是+8区。同样建议使用localtime_r版本。

    1. time_t mktime(struct tm *tm);  

        将已经根据时区信息计算好的struct tm转换成time_t的秒数。计算出的秒数是以UTC时间为标准的,跟调用time()得到的秒数是同一个概念。这个struct tm是本地时间,如:上海时间2011-08-20 13:20:40,struct tm中各个值就是此时间的对应值,因为这个时间中已经包含了时区信息。如果在格林威治和上海对同一个struct tm调用这个函数,返回的值是不一样的,上海的值会比格林威治少8个小时。

        再介绍一下本地时间和UTC时间之间的转换。本地时间是在UTC时间基础上根据时区和日光节约时间调整得到。<time.h>中如下函数和变量起到了转换本地时间和UTC时间的作用。
    1. void tzset (void);  
    2. extern char *tzname[2];  
    3. extern long timezone;  
    4. extern int daylight;  

        具体代码:
    1. #include <time.h>  
    2. tzset ();  
    3. time_t current_timet;  
    4. time(¤t_timet);//得到当前时间秒数  
    5. struct tm utc_tm;  
    6. gmtime_r (¤t_timet, &utc_tm);//得到GMT,即UTC时间  
    7. struct tm local_tm;  
    8. localtime_r(¤t_timet, &local_tm);//得到本地时间,根据如下打印看出两者相差8小时。  
    9. printf ("current_timet: %d, timezone info:[%d / %d]\n", current_timet, timezone, daylight);  
    10. printf ("utc_tm: %d-%d-%d %d:%d:%dZ\n", utc_tm.tm_year, utc_tm.tm_mon, utc_tm.tm_mday, utc_tm.tm_hour, utc_tm.tm_min, utc_tm.tm_sec);  
    11. printf ("local_tm: %d-%d-%d %d:%d:%d\n", local_tm.tm_year, local_tm.tm_mon, local_tm.tm_mday, local_tm.tm_hour, local_tm.tm_min, local_tm.tm_sec);  
    12. struct tm local_tm2 = utc_tm;  
    13. local_tm2.tm_sec -= timezone;  
    14. local_tm2.tm_isdst = daylight; //将utc时间转换成本地时间  
    15. time_t local_timet2 = mktime(&local_tm2);//得到秒数  
    16. printf ("\nlocal_timet2=%d\n", local_timet2);//可以看出,和一开始得到的当前时间秒数相同。daylight部分没有仔细测。  


        痛苦的回顾,我曾经写过如下代码
    1. time_t now;  
    2. time(&now);  
    3. DEBUG ("now:%d",now)  
    4. struct tm* timeNow = gmtime (&now);  
    5.     DEBUG ("timeNOw:sec=%d, min=%d, hour=%d, mday=%d, mon=%d, year=%d, wday=%d, yday=%d, isdst=%d",  
    6.            timeNow->tm_sec, timeNow->tm_min, timeNow->tm_hour, timeNow->tm_mday, timeNow->tm_mon,  
    7.            timeNow->tm_year, timeNow->tm_wday, timeNow->tm_yday, timeNow->tm_isdst);  
    8. struct tm tm1 = *timeNow;  
    9.     DEBUG ("tm1    :sec=%d, min=%d, hour=%d, mday=%d, mon=%d, year=%d, wday=%d, yday=%d, isdst=%d",  
    10.            tm1.tm_sec, tm1.tm_min, tm1.tm_hour, tm1.tm_mday, tm1.tm_mon,  
    11.            tm1.tm_year, tm1.tm_wday, tm1.tm_yday, tm1.tm_isdst);  

    结果,打印出来的出乎意料。我认为timeNow和tm1的内容应该是一样的,可是tm_hour竟然相差8。后来发现DEBUG()中有时间处理的,使得静态内存被修改了。但类似DEBUG()这种函数的问题谁会很关注。所以,时间方面最好使用可重入版本。

    1. /******************************************************************* 
    2. • 此文章解释权归windsome所有,如要转载无须联系本人。 
    3. • QQ: 35327864 
    4. • msn: fgwf1@hotmail.com 
    5. • mail: agooou@gmail.com 
    6.  ********************************************************************/  

    展开全文
  • 方法一:SimpleDateFormat dff = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); dff.setTimeZone(TimeZone.getTimeZone("GMT+08"));...这个方法不随手机时间的变动而变动。
  • odoo12:获取当前时区时间(带时区)

    千次阅读 2019-01-24 20:01:17
    获取当前时区时间 有时候我们默认获取当前时间会出错,我们通常自己写一个方法,然后调用它,下面分享一个当前时区时间的代码: def get_location_time(self): """ 获取当前时区时间(带时区) :...
  • Oracle 数据库时间 时区

    千次阅读 2014-06-07 22:54:32
    时区有三种表示方法,全名、缩写和相对于标准时间(格林威治时间)的固定偏移,比如标准时间相应的三种表示方法分别:Etc/Greenwich、GMT和+00:00。 select c.owner || '.' || c.table_name || '(' || c....
  • 1、将mysql安装文件写的bin目录的路径,添加到电脑的系统变量path路径下 2、在windows的cmd窗口下,首先启动服务, ... 然后,输入如下命令 mysql -hlocalhost -uroot -proot ...3、时区本地化 > set global...
  • 时间时区

    千次阅读 2014-11-19 22:16:03
    在格林威治子午线上的平太阳时称为世界时(UTC),又叫格林威治平时(GMT),两者仅称呼的区别 1.TimeZone表示时区偏移量,...例如北京时间可以表示为GMT+8:00。 TimeZone.getRawOffset()方法可以用来得到当前时区
  • 在PHP开发,我们经常会在时间问题上被搞糊涂,比如我们希望显示一个北京时间,但是当我们使用date函数进行输出时,却发现少了8个小时。几乎所有的php猿类都必须对php几个重要的时间转换等方法进行研究。本文就来...
  • 1、时区的概念为了解决世界各地在时间...其中中时区就是格林尼治标准时间,以它基准,东加西减。我国统一采用北京时间,也就是东八区。2、日期时间标准日期标准——公元纪年,是纪念犹太人耶稣(基督)的诞生。...
  • 使用sqlite进行时间的插入的时候,使用了 DateTime.ToString("s") //s: 2008-06-15T21:15:07  插入到数据库之后,发现时间被加了8个小时 ...有两种方式处理时区的时差   Times a...
  • 最近在编程遇到了时间时区相关的问题,整理在这里  我的程序是一个在hadoop上运行的分布式程序,从mysql数据库取数据,经过处理之后输出 一. 基本概念  时区 :time zone 1884年国际经线会议规定,全球按...
  • JAVA 获取零时区时间

    千次阅读 2018-11-02 17:59:10
    * 得到指定时间的UTC0时间 * @param beforeDate * @param dataFormat 格式"yyyy-MM-dd HH:mm:ss" * @return */ public static String getUTCTimeStr(Date beforeDate, String dataFormat) { ...
  • Linux系统的时区时间设置

    千次阅读 2017-02-27 14:42:38
    时区时间的概念 CST:中国标准时间(China Standard Time),这个解释可能是针对RedHat Linux。 UTC:协调世界时,又称世界标准时间,简称UTC,从英文国际时间/法文协调时间“Universal Time/Temps Cordonné”...
  • 从世界需要统一时间标准出发,讲述为什么引入时区时区的设计,进一步介绍时间的测量;涉及概念包括:世界时、本地时、原子时,time zone/UT/GMT/UTC/TAI等; 顺带介绍数据库时间、UNIX时间
  • 时区转换,时间格式转换

    千次阅读 2019-07-05 00:29:29
    GMT - 格林尼治标准时间/格林威治平均时间 UTC - 协调世界时 LT - 本地时间 这篇文章解释的都很详细 一些时间的概念与区分(UTC、GMT、LT、TAI等) 我们一般认为GMT和UTC是一样的,都与英国伦敦的本地时相同。 UTC...
  • 本文专门解决开发获取系统时间,发现时间不准确,会早/晚N个小时,我在开发遇到过几次,后来尝试用时区的办法获取当地时间,可以完美解决时间不准确的问题,不用担心服务器时间准不准确的问题。 /** * 取北京...
  • Ubuntu系统的时区时间日期

    千次阅读 2018-06-07 16:44:50
    Ubuntu系统的时区时间日期UTC是格林威治时间,CST是中国标准时间,很显然CST=UTC+8查看当前时间date查看系统硬件时钟hwclock --show设置硬件时间hwclock --set --date="06/18/14 14:55" (月/日/年时:分:秒...
  • 关于Android 实际开放,涉及时间转换问题,还是很有必要详细知晓一下,...在开发Android的过程,出现过几次由于日期时间导致的问题,而且主要是由于时区的原因导致,所以一直想总结一下,形成一个良好的开发规...
  • 最近发现自己搭的项目时间总是比当前时间少8小时,后来排查发现,是数据库没有设置相应的时区...如果 system_time_zone CST 表示此时数据库设置的时区非东八区。 命令修改时区: set global time_zone =...
  • java8 日期 时间 时区

    千次阅读 2015-04-11 14:19:05
    java8 时间 日期 时区
  • ios 时区时间格式NSDate

    万次阅读 2016-12-13 13:53:28
    在iOS开发,经常会遇到各种各样的时间问题,8小时时差,时间戳,求时间间隔,农历等等。解决办法网上比比皆是,但大多零零散散,很多资料并没有说明其中问题。这里集中总结一下,以便于以后查阅和供大家参考。有我...
  • //getTimezoneOffset()方法的负返回值表示当地时间在全球标准时间(UTC)之前,而正返回值则表示当地时间在全球标准时间(UTC)之后。 // console.log(d.getTimezoneOffset()); //将本地时间与本地时区偏移值相加...
  • 目录 一、查看时区或者时间 二、设置时区或者时间 ...其中:+0800表示时区,东八区,即我们所在的时区,前面代表的是时间 星期五 50号 5月 2019年 二、设置时区或者时间 1、设置时区(设置上海时区为例) ...
  • 时间时区处理问题

    千次阅读 2016-12-13 11:47:07
    日期和时间在程序应用广泛,每种程序开发语言都自带处理日期和时间的相关函数,很多开发者把日期和时间存入数据库,但是,一旦涉及到跨时区的日期和时间的处理时,大多数开发者根本就不明白如何正确地处理日期和...
  • openwrt正确设置时间时区

    千次阅读 2020-08-25 09:59:59
    问题 cornd执行时间不符合预期。查看日志发现系统时间不对。 openwrt选择的时区是Asia/Shanghai没错 ssh登入终端 使用date -u查看UTC...搜索发现,zoneinfo 的 etc/GTM表示方法是以西正。则东8区应etc/GMT-8 在l

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,833
精华内容 31,133
关键字:

中时区时间表示为什么