时间_list 排序 按时间排序 当前时间 将来时间 过往时间 - CSDN
精华内容
参与话题
  • Java 时间与日期处理

    千次阅读 2017-07-24 10:48:10
    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 | 时间处理

    2019-05-06 17:27:26
    时间处理之Python1 获取当前日期和时间2 获取指定日期和时间3 将datetime转为时间戳timestamp3.1 方法13.2 方法23.3 方法2应用3.3.1 原始数据3.3.2 将这一列时间变为时间戳的格式3.3.3 直接筛选4 从timestamp中提取...

    1 获取当前日期和时间

    from datetime import datetime
    
    time_now = datetime.now()
    print(time_now) # 直接打印会比较规整
    time_now
    
    2019-05-06 17:09:14.732634
    
    
    
    
    
    datetime.datetime(2019, 5, 6, 17, 9, 14, 732634)
    

    2 获取指定日期和时间

    dt = datetime(2019, 6, 1, 0, 0, 0)
    print(dt)
    
    2019-06-01 00:00:00
    

    3 将datetime转为时间戳timestamp

    3.1 方法1

    # 转为时间戳 
    tsmp = dt.timestamp()
    tsmp
    
    1559318400.0
    

    3.2 方法2

    import time
    def time_check(recent_time):  
        recent_stamp = time.mktime(time.strptime(recent_time, '%Y%m%d%H%M%S'))
        return int(recent_stamp)
    
    time_check('20190601000000')
    
    1559318400
    

    3.3 方法2应用

    问题:现在有一个DataFrame,我们想要看时间节点在2018年12月17号之前的样本量有多少?该如何去考虑呢?

    思路:

    • 首先将这一列时间变为时间戳的格式
    • 将2018年12月17号变为时间戳
    • 筛选小于第2个中的时间戳的DataFrame

    3.3.1 原始数据

    import pandas as pd
    card = pd.read_excel('时间处理/example_data.xlsx')
    card = card.iloc[:,:-1]
    card = card[card['提现成功']==1]
    print(card.shape)
    card.head()
    
    (2006, 5)
    
    授信状态 首借日期 完成申请 授信成功 提现成功
    4 3 2018/10/13 1 1 1
    5 3 2018/10/27 1 1 1
    8 3 2018/9/21 1 1 1
    9 3 2018/11/10 1 1 1
    13 3 2018/7/16 1 1 1

    3.3.2 将这一列时间变为时间戳的格式

    # 将时间转为时间戳
    import time
    def time_check(recent_time):
        try:
            recent_stamp = time.mktime(time.strptime(recent_time, '%Y/%m/%d'))
            # 这里的格式需要根据给定数据的情况进行改变
        except Exception as e:
            print(e)
        return int(recent_stamp)
    
    card['ts'] = card['首借日期'].map(time_check)
    print(card.shape)
    card.head()
    
    (2006, 6)
    
    授信状态 首借日期 完成申请 授信成功 提现成功 ts
    4 3 2018/10/13 1 1 1 1539360000
    5 3 2018/10/27 1 1 1 1540569600
    8 3 2018/9/21 1 1 1 1537459200
    9 3 2018/11/10 1 1 1 1541779200
    13 3 2018/7/16 1 1 1 1531670400

    3.3.3 直接筛选

    card2 = card[card['ts'] <= time_check('2018/12/17')]
    print(card2.shape)
    card2.head()
    
    (1841, 6)
    
    授信状态 首借日期 完成申请 授信成功 提现成功 ts
    4 3 2018/10/13 1 1 1 1539360000
    5 3 2018/10/27 1 1 1 1540569600
    8 3 2018/9/21 1 1 1 1537459200
    9 3 2018/11/10 1 1 1 1541779200
    13 3 2018/7/16 1 1 1 1531670400

    注意:某些编程语言(如Java和JavaScript)的timestamp使用整数表示毫秒数,这种情况下只需要把timestamp除以1000就得到Python的浮点表示方法。

    4 从timestamp中提取出月份

    4.1 提取函数

    def extract_month(time_stamp):
        time_tuple = time.localtime(time_stamp)
        mon_num = time_tuple.tm_mon
        if mon_num<10:
            mon_str = '0'+str(mon_num)
        else:
            mon_str = str(mon_num)
        return str(time_tuple.tm_year)+'-'+mon_str
    
    extract_month(time_check('20190202232359'))
    
    '2019-02'
    

    4.2 测试

    time_tuple = time.localtime(1549121039)
    time_tuple
    
    time.struct_time(tm_year=2019, tm_mon=2, tm_mday=2, tm_hour=23, tm_min=23, tm_sec=59, tm_wday=5, tm_yday=33, tm_isdst=0)
    

    5 从timestamp提取出时段

    5.1 函数

    def extract_hour(time_stamp):
        # 提取时段,每日分为12个时段
        time_tuple = time.localtime(time_stamp)
        return time_tuple.tm_hour
    
    extract_hour(1549121039)
    
    23
    

    6 从timestamp中提取出天数

    除以86400

    1549121039 / 86400 + 1
    
    17930.641655092593
    
    # 计算2019年6月1号到现在有多久
    from datetime import datetime
    dt1 = datetime(2019, 6, 1, 0, 0, 0)
    dt2 = time_now
    int((dt1.timestamp() - dt2.timestamp()) / 86400)  + 1
    
    26
    

    7 timestamp转为datetime

    7.1 方法1

    ts = datetime.fromtimestamp(tsmp)
    print(ts)
    ts
    
    2019-06-01 00:00:00
    
    
    
    
    
    datetime.datetime(2019, 6, 1, 0, 0)
    

    7.2 方法2

    '''
    上面返回的是本地时间,也就是北京时间,下面返回标准的UTC时间
    '''
    ts_utc = datetime.utcfromtimestamp(tsmp)
    print(ts_utc) # 比北京本地时间要提前8小时
    ts_utc
    
    2019-05-31 16:00:00
    
    
    
    
    
    datetime.datetime(2019, 5, 31, 16, 0)
    

    8 str转为datetime

    str_ts = '2019-2-27 23:55:59'
    dt_ts = datetime.strptime(str_ts, '%Y-%m-%d %H:%M:%S')
    print(dt_ts)
    dt_ts
    
    2019-02-27 23:55:59
    
    
    
    
    
    datetime.datetime(2019, 2, 27, 23, 55, 59)
    

    9 datetime转为str

    dt_ts_new = datetime(2022,2,22,22,22,22)
    dt_ts_str = datetime.strftime(dt_ts_new, '%Y-%m-%d %H:%M:%S')
    dt_ts_str
    
    '2022-02-22 22:22:22'
    

    10 具体时间的相加减

    from datetime import datetime
    
    from datetime import timedelta
    
    # 现在要算 2022年2月22号 晚上22点22分 退720天离现在多久?
    obj_ts = datetime(2022, 2, 22, 22, 22, 22)
    obj_ts - timedelta(days = 720)
    
    datetime.datetime(2020, 3, 4, 22, 22, 22)
    
    obj_ts = datetime(2022, 2, 22, 22, 22, 22)
    obj_ts - timedelta(days = 1090) 
    # 也就是现在还有1090天达到一个特别2的日子
    
    datetime.datetime(2019, 2, 28, 22, 22, 22)
    
    import datetime
    datetime.date(year = 2222, month = 2, day = 22)
    
    datetime.date(2222, 2, 22)
    
    展开全文
  • 获取网络时间(国家标准时间

    万次阅读 2015-12-08 10:32:04
    我们在开发中,很多应用需要读取网络时间来作为一个时间的标准,对业务逻辑进行相对可靠的校验。 下面是Java中(Android一样)读取网络时间的代码:package com.test;import java.io.IOException; import java.net....

    我们在开发中,很多应用需要读取网络时间来作为一个时间的标准,对业务逻辑进行相对可靠的校验。
    下面是Java中(Android一样)读取网络时间的代码:

    package com.test;
    
    import java.io.IOException;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.net.URLConnection;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Locale;
    
    /**
     * 读取网络时间
     *
     * @author SHANHY(365384722@QQ.COM)
     * @date   2015年11月27日
     */
    public class GetNetworkTime {
    
        public static void main(String[] args) {
            String webUrl1 = "http://www.bjtime.cn";//bjTime
            String webUrl2 = "http://www.baidu.com";//百度
            String webUrl3 = "http://www.taobao.com";//淘宝
            String webUrl4 = "http://www.ntsc.ac.cn";//中国科学院国家授时中心
            String webUrl5 = "http://www.360.cn";//360
            String webUrl6 = "http://www.beijing-time.org";//beijing-time
            System.out.println(getWebsiteDatetime(webUrl1) + " [bjtime]");
            System.out.println(getWebsiteDatetime(webUrl2) + " [百度]");
            System.out.println(getWebsiteDatetime(webUrl3) + " [淘宝]");
            System.out.println(getWebsiteDatetime(webUrl4) + " [中国科学院国家授时中心]");
            System.out.println(getWebsiteDatetime(webUrl5) + " [360安全卫士]");
            System.out.println(getWebsiteDatetime(webUrl6) + " [beijing-time]");
        }
    
        /**
         * 获取指定网站的日期时间
         * 
         * @param webUrl
         * @return
         * @author SHANHY
         * @date   2015年11月27日
         */
        private static String getWebsiteDatetime(String webUrl){
            try {
                URL url = new URL(webUrl);// 取得资源对象
                URLConnection uc = url.openConnection();// 生成连接对象
                uc.connect();// 发出连接
                long ld = uc.getDate();// 读取网站日期时间
                Date date = new Date(ld);// 转换为标准时间对象
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);// 输出北京时间
                return sdf.format(date);
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    

    网络上很多帖子差不多都说使用 www.bjtime.cn 来获取网络时间,但是通过我的实际测试(测试时间2015-11-27 23:50),此时这个 bjtime 的时间并不准,与北京时间竟然悬殊了十几秒,显然降低了可靠性。
    大家看下我测试输出的结果便一目了然,如下:

    2015-11-27 23:51:37 [bjtime]
    2015-11-27 23:50:22 [百度]
    2015-11-27 23:50:22 [淘宝]
    2015-11-27 23:50:22 [中国科学院国家授时中心]
    2015-11-27 23:50:22 [360安全卫士]
    2015-11-27 23:50:22 [beijing-time]
    

    显而易见,几个知名互联网公司的时间是一致的,所以获取网络时间的时候,建议大家选用相对比较靠谱的网站,上面测试的几个已经足够备选了(百度、淘宝、国家授时中心)。

    另外值得一提的是,该方法获取时间,只需要建立连接就可以了,不需要请求(request)与响应(response),所以比单独写接口效率要高。

    展开全文
  • golang time包 时间

    2020-08-25 16:11:25
    time类型 和 时间戳 的转换 timestamp := time.Now().Unix() //timestamp为时间戳类型 tm := time.Unix(timestamp, 0) //tm为Time类型 时间戳或time类型 转 字符串(格式化) ...tm := time.Now() //tm为Time类型 ...

    time类型 和 时间戳 的转换

    timestamp := time.Now().Unix()  //timestamp为时间戳类型
    
    tm := time.Unix(timestamp, 0)  //tm为Time类型
    

    时间戳或time类型 转 字符串(格式化)

    tm := time.Now() //tm为Time类型
    
    timestamp := time.Now().Unix() //timestamp为时间戳类型
    
    time.Now().String()  //没有格式化
    
    fmt.Println(tm.Format("2006-01-02 03:04:05 PM"))  //格式化
    fmt.Println(tm.Format("02/01/2006 15:04:05 PM"))  //24小时制
    
    也可以直接输出  fmt.Println(time.Now())  output:2017-02-27 01:20:00.567634365 +0800 CST
    
    指定时间的time类型  time.Date(2017, 02, 27, 20, 20, 20, 20, time.Local)
    

    字符串 转 time类型或时间戳

    x := "2017-02-27 17:30:20"
    p, _ := time.Parse("2006-01-02 15:04:05", x)  //p为time类型
    p.Unix() //p.Unix()为时间戳类型

    time ticker

    func main() {
        ticker := time.NewTicker(10 * time.Second)
        for i := 0; i < 10; i++ {
            time := <-ticker.C
            fmt.Println(time.String())
        }
    }

    输出:

    2015-08-24 16:22:23.590564088 +0800 CST

    2015-08-24 16:22:33.591194618 +0800 CST

    2015-08-24 16:22:43.587720967 +0800 CST

    2015-08-24 16:22:53.590231413 +0800 CST

    2015-08-24 16:23:03.591164202 +0800 CST

    ticket是一个只读的chanel。

    go和其他语言的开发思路不一样。其他语言,多是注册回调函数,定时,时间到了调用回调。go是 通过 chan的阻塞实现的。

    调用的地方,读取chan 。定时,时间到,向chan写入值,阻塞解除,调用函数。 

    Duration

    "持续时间"  https://studygolang.com/articles/12617

    时间的加减

    // 一天前
    	d, _ := time.ParseDuration("-24h")
    	d1 := now.Add(d)
    	fmt.Println(d1)
    更多:https://studygolang.com/articles/8919

    更多

    package time  https://studygolang.com/pkgdoc

    展开全文
  • C#时间/日期格式大全

    万次阅读 2018-06-08 09:52:14
    C#时间/日期格式大全(转)C#时间/日期格式大全,C#时间/日期函数大全有时候我们要对时间进行转换,达到不同的显示效果 默认格式为:2005-6-6 14:33:34 如果要换成成200506,06-2005,2005-6-6或更多的该怎么办呢?...
  • Android 系统时间

    千次阅读 2018-03-17 22:09:23
    Android系统更新时间两类方式: 1.网络提供时间(运营商SIM和WIFI) 2.GPS提供时间(GPS模块接收GPS卫星信号获得,定位成功即生效) 1.时间相关概念 1.1 GMT格林威治标准时间(Greenwich Mean Time) ...
  • 时区和时间戳

    千次阅读 2018-08-09 22:24:40
    它也被称为Unix时间(Unix time)、POSIX时间(POSIX time),是一种时间表示方式,定义为从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数。因此,严格来说,不管你处在地球上的哪个地方,任意时间点的时间戳...
  • datetime 模块详解 -- 基本的日期和时间类型 datetime 模块提供了各种类用于操作日期和时间,该模块侧重于高效率的格式化输出在 Python 中,与时间处理有关的模块包括:time,datetime 以及 calendardatetime 模块...
  • 年月日时间和64位时间的使用,以及它们之间的相互转换
  • DDR3读写时序

    2019-06-29 14:29:19
    DDR3读写时序 1.DDR3时序参数 ...意思是说,当我们选择了187E芯片的时候,他所能支持的最大速率是1066MT/s,即DDR3的时钟频率是533...tRCD指的是从ACTIVATE到READ或WRITE的时间 tRP指的是PRECHARGE的时间 CL...
  • http://tools.jb51.net/code/unixtime
  • 下面总结了一些常用的Web Service,是平时乱逛时收集的,希望对大家有用。 ============================================ 天气预报Web Service,数据来源于中国气象局 Endpoint  ...
  • 周转时间,平均周转时间,带权周转时间

    万次阅读 多人点赞 2016-11-17 14:07:27
    周转时间=作业完成时间−作业提交时间周转时间 = 作业完成时间 - 作业提交时间特别注意作业提交时间不是作业进内存的时间,而是发出请求,提交就开始计时,如果无法安排进内存,那么就等待,等待的这部分时间也要...
  • 周转时间和带权周转时间的计算

    万次阅读 多人点赞 2015-04-09 12:08:56
    周转时间=作业完成时刻—作业到达时刻; 带权周转时间=周转时间/服务时间; 平均周转时间=作业周转总时间/作业个数; 平均带权周转时间=带权周转总时间/作业个数; 例: 有4个进程A,B,C,D,设它们依次进入...
  • 若文件从创建后不曾修改过则可认为创建时间=修改时间,若文件创建后状态也不曾改变过则可认为创建时间=改变时间,若文件创建后不曾被读取过则可认为创建时间=访问时间。但是,但是,上述情况基本上是不可能的,也...
  • Java获取系统时间的四种方法

    万次阅读 多人点赞 2020-09-23 23:41:12
    1、Date day=new Date(); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); System.out.println(df.format(day));...通过Date类来获取当前时间 2、SimpleDateFormat df = new SimpleDateF
  • UTC时间与北京时间相互转换

    万次阅读 2016-11-24 00:47:44
    > public class HomeController : Controller { public ActionResult Index() { //本地时间(北京时间) DateTime dt = Convert.ToDateTime("2016-06-11 23:59:59");... //将北京时间转换成utc时间 (北京时间
  • 在Microsoft Project中有三种时间:基准计划、当前计划、实际状态。  基准计划:基线开始时间、基线完成时间、基线工期,  当前计划:开始时间、完成时间、工期  实际状态:实际开始时间、实际完成时间、实际...
  • 几种Python执行时间的计算方法

    万次阅读 多人点赞 2017-01-09 10:22:42
    首先说一下我遇到的坑,生产上遇到的问题,我调度Python脚本执行并监控这个进程,python脚本运行时间远远大于python脚本中自己统计的程序执行时间。 监控python脚本执行的时间是36个小时,而python脚本中统计自己...
  • 当新增记录的时候,mysql自动将系统的当前时间set到创建时间和更新时间这两个字段中。 当更新记录的时候,mysql只update更新时间字段的时间,而不修改创建时间字段对应的值。方案: 找到表中对应的创建时间和更新...
1 2 3 4 5 ... 20
收藏数 8,202,417
精华内容 3,280,966
关键字:

时间