时间_时间复杂度 - 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();
    
    展开全文
  • C#时间/日期格式大全

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

    C#时间/日期格式大全(转)

    C#时间/日期格式大全,C#时间/日期函数大全

    有时候我们要对时间进行转换,达到不同的显示效果  

    默认格式为:2005-6-6 14:33:34  

    如果要换成成200506,06-2005,2005-6-6或更多的该怎么办呢?

    我们要用到:

    DateTime.ToString的方法(String, IFormatProvider)    

    using System;  

    using System.Globalization;

    String format="D";  

    DateTime date=DataTime,Now;  

    Response.Write(date.ToString(format, DateTimeFormatInfo.InvariantInfo));

    结果输出  Thursday, June 16, 2005

    参数format格式详细用法:

    格式字符             关联属性/说明  

    d                          ShortDatePattern  

    D                        LongDatePattern  

    f                          完整日期和时间(长日期和短时间)  

    F                         FullDateTimePattern(长日期和长时间)  

    g                          常规(短日期和短时间)  

    G                         常规(短日期和长时间)  

    m、M                  MonthDayPattern  

    r、R                    FC1123Pattern  

    s                          使用当地时间的 SortableDateTimePattern(基于 ISO 8601)  

    t                          ShortTimePattern  

    T                         LongTimePattern  

    u                          UniversalSortableDateTimePattern 用于显示通用时间的格式  

    U                         使用通用时间的完整日期和时间(长日期和长时间)  

    y、Y                    YearMonthPattern    

    下表列出了可被合并以构造自定义模式的模式。

    这些模式是区分大小写的;例如,识别“MM”,但不识别“mm”。

    如果自定义模式包含空白字符或用单引号括起来的字符,

    则输出字符串页也将包含这些字符.

    未定义为格式模式的一部分或未定义为格式字符的字符按其原义复制。

    格式模式      说明

    d                   月中的某一天。一位数的日期没有前导零。  

    dd                 月中的某一天。一位数的日期有一个前导零。  

    ddd               周中某天的缩写名称,在 AbbreviatedDayNames 中定义。  

    dddd             周中某天的完整名称,在 DayNames 中定义。  

    M                 月份数字。一位数的月份没有前导零。  

    MM              月份数字。一位数的月份有一个前导零。  

    MMM           月份的缩写名称,在 AbbreviatedMonthNames 中定义。  

    MMMM        月份的完整名称,在 MonthNames 中定义。  

    y                   不包含纪元的年份。如果不包含纪元的年份小于 10,则显示不具有前导零的年份。  

    yy                 不包含纪元的年份。如果不包含纪元的年份小于 10,则显示具有前导零的年份。  

    yyyy             包括纪元的四位数的年份。  

    gg                 时期或纪元。如果要设置格式的日期不具有关联的时期或纪元字符串,则忽略该模式。  

    h                   12 小时制的小时。一位数的小时数没有前导零。  

    hh                 12 小时制的小时。一位数的小时数有前导零。  

    H                  24 小时制的小时。一位数的小时数没有前导零。  

    HH                      24 小时制的小时。一位数的小时数有前导零。  

    m                  分钟。一位数的分钟数没有前导零。  

    mm               分钟。一位数的分钟数有一个前导零。  

    s                   秒。一位数的秒数没有前导零。  

    ss                  秒。一位数的秒数有一个前导零。  

    f                   秒的小数精度为一位。其余数字被截断。  

    ff                  秒的小数精度为两位。其余数字被截断。  

    fff                 秒的小数精度为三位。其余数字被截断。  

    ffff                      秒的小数精度为四位。其余数字被截断。  

    fffff              秒的小数精度为五位。其余数字被截断。  

    ffffff             秒的小数精度为六位。其余数字被截断。  

    fffffff            秒的小数精度为七位。其余数字被截断。  

    t                   在 AMDesignator 或 PMDesignator 中定义的 AM/PM 指示项的第一个字符(如果存在)。  

    tt                  在 AMDesignator 或 PMDesignator 中定义的 AM/PM 指示项(如果存在)。  z                     时区偏移量(“+”或“-”后面仅跟小时)。一位数的小时数没有前导零。例如,太平洋标准时间是“-8”。  

    zz                 时区偏移量(“+”或“-”后面仅跟小时)。一位数的小时数有前导零。例如,太平洋标准时间是“-08”。  

    zzz               完整时区偏移量(“+”或“-”后面跟有小时和分钟)。一位数的小时数和分钟数有前导零。例如,太平洋标准时间是“-08:00”。  

    :                   在 TimeSeparator 中定义的默认时间分隔符。  

    /                   在 DateSeparator 中定义的默认日期分隔符。  

    % c               其中 c 是格式模式(如果单独使用)。如果格式模式与原义字符或其他格式模式合并,则可以省略“%”字符。  

    \ c                 其中 c 是任意字符。照原义显示字符。若要显示反斜杠字符,请使用“\\”。

     只有上面第二个表中列出的格式模式才能用于创建自定义模式;

    在第一个表中列出的标准格式字符不能用于创建自定义模式。

    自定义模式的长度至少为两个字符;

    例如,DateTime.ToString("d") 返回 DateTime 值;

    “d”是标准短日期模式。

    DateTime.ToString( "%d") 返回月中的某天;

    “%d”是自定义模式.

    DateTime.ToString( "d ") 返回后面跟有一个空白字符的月中的某天;

    “d”是自定义模式。    

    比较方便的是,上面的参数可以随意组合,并且不会出错,多试试,肯定会找到你要的时间格式如要得到2005年06月 这样格式的时间

    可以这样写: date.ToString("yyyy年MM月", DateTimeFormatInfo.InvariantInfo)如此类推

    复制代码
    DateTime dt = DateTime.Now;
    Label1.Text = dt.ToString();//2005-11-5 13:21:25
    Label2.Text = dt.ToFileTime().ToString();//127756416859912816
    Label3.Text = dt.ToFileTimeUtc().ToString();//127756704859912816
    Label4.Text = dt.ToLocalTime().ToString();//2005-11-5 21:21:25
    Label5.Text = dt.ToLongDateString().ToString();//2005年11月5日
    Label6.Text = dt.ToLongTimeString().ToString();//13:21:25
    Label7.Text = dt.ToOADate().ToString();//38661.5565508218
    Label8.Text = dt.ToShortDateString().ToString();//2005-11-5
    Label9.Text = dt.ToShortTimeString().ToString();//13:21
    Label10.Text = dt.ToUniversalTime().ToString();//2005-11-5 5:21:25
    ?2005-11-5 13:30:28.4412864
    Label1.Text = dt.Year.ToString();//2005
    Label2.Text = dt.Date.ToString();//2005-11-5 0:00:00
    Label3.Text = dt.DayOfWeek.ToString();//Saturday
    Label4.Text = dt.DayOfYear.ToString();//309
    Label5.Text = dt.Hour.ToString();//13
    Label6.Text = dt.Millisecond.ToString();//441
    Label7.Text = dt.Minute.ToString();//30
    Label8.Text = dt.Month.ToString();//11
    Label9.Text = dt.Second.ToString();//28
    Label10.Text = dt.Ticks.ToString();//632667942284412864
    Label11.Text = dt.TimeOfDay.ToString();//13:30:28.4412864
    Label1.Text = dt.ToString();//2005-11-5 13:47:04
    Label2.Text = dt.AddYears(1).ToString();//2006-11-5 13:47:04
    Label3.Text = dt.AddDays(1.1).ToString();//2005-11-6 16:11:04
    Label4.Text = dt.AddHours(1.1).ToString();//2005-11-5 14:53:04
    Label5.Text = dt.AddMilliseconds(1.1).ToString();//2005-11-5 13:47:04
    Label6.Text = dt.AddMonths(1).ToString();//2005-12-5 13:47:04
    Label7.Text = dt.AddSeconds(1.1).ToString();//2005-11-5 13:47:05
    Label8.Text = dt.AddMinutes(1.1).ToString();//2005-11-5 13:48:10
    Label9.Text = dt.AddTicks(1000).ToString();//2005-11-5 13:47:04
    Label10.Text = dt.CompareTo(dt).ToString();//0
    //Label11.Text = dt.Add(?).ToString();//问号为一个时间段
    Label1.Text = dt.Equals("2005-11-6 16:11:04").ToString();//False
    Label2.Text = dt.Equals(dt).ToString();//True
    Label3.Text = dt.GetHashCode().ToString();//1474088234
    Label4.Text = dt.GetType().ToString();//System.DateTime
    Label5.Text = dt.GetTypeCode().ToString();//DateTime
    Label1.Text = dt.GetDateTimeFormats('s')[0].ToString();//2005-11-05T14:06:25
    Label2.Text = dt.GetDateTimeFormats('t')[0].ToString();//14:06
    Label3.Text = dt.GetDateTimeFormats('y')[0].ToString();//2005年11月
    Label4.Text = dt.GetDateTimeFormats('D')[0].ToString();//2005年11月5日
    Label5.Text = dt.GetDateTimeFormats('D')[1].ToString();//2005 11 05
    Label6.Text = dt.GetDateTimeFormats('D')[2].ToString();//星期六 2005 11 05
    Label7.Text = dt.GetDateTimeFormats('D')[3].ToString();//星期六 2005年11月5日
    Label8.Text = dt.GetDateTimeFormats('M')[0].ToString();//11月5日
    Label9.Text = dt.GetDateTimeFormats('f')[0].ToString();//2005年11月5日 14:06
    Label10.Text = dt.GetDateTimeFormats('g')[0].ToString();//2005-11-5 14:06
    Label11.Text = dt.GetDateTimeFormats('r')[0].ToString();//Sat, 05 Nov 2005 14:06:25 GMT
    Label1.Text =? string.Format("{0:d}",dt);//2005-11-5
    Label2.Text =? string.Format("{0:D}",dt);//2005年11月5日
    Label3.Text =? string.Format("{0:f}",dt);//2005年11月5日 14:23
    Label4.Text =? string.Format("{0:F}",dt);//2005年11月5日 14:23:23
    Label5.Text =? string.Format("{0:g}",dt);//2005-11-5 14:23
    Label6.Text =? string.Format("{0:G}",dt);//2005-11-5 14:23:23
    Label7.Text =? string.Format("{0:M}",dt);//11月5日
    Label8.Text =? string.Format("{0:R}",dt);//Sat, 05 Nov 2005 14:23:23 GMT
    Label9.Text =? string.Format("{0:s}",dt);//2005-11-05T14:23:23
    Label10.Text = string.Format("{0:t}",dt);//14:23
    Label11.Text = string.Format("{0:T}",dt);//14:23:23
    Label12.Text = string.Format("{0:u}",dt);//2005-11-05 14:23:23Z
    Label13.Text = string.Format("{0:U}",dt);//2005年11月5日 6:23:23
    Label14.Text = string.Format("{0:Y}",dt);//2005年11月
    Label15.Text = string.Format("{0}",dt);//2005-11-5 14:23:23?
    Label16.Text = string.Format("{0:yyyyMMddHHmmssffff}",dt);
    //yyyymm等可以设置,比如Label16.Text = string.Format("{0:yyyyMMdd}",dt);
    展开全文
  • 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)
    
    展开全文
  • JS时间的处理集锦

    2020-04-30 18:07:09
    //获取当前日期 function getCurrDate() { var myDate = new Date; var year = myDate.getFullYear(); //获取当前年 var mon = myDate.getMonth() + 1 > 9 ? myDate.getMont...

    1,获取当前日期

        //获取当前日期
            function getCurrDate() {
                var myDate = new Date;
                var year = myDate.getFullYear(); //年
                var mon = check(myDate.getMonth()+ 1)   //月
                var date =check(myDate.getDate())  ; //日
                var Hours = check( myDate.getHours());       // 获取当前小时数(0-23)
                var Minutes =check( myDate.getMinutes()) ;     // 获取当前分钟数(0-59)
                var Seconds = check(myDate.getSeconds());     // 获取当前秒数(0-59)
                return year + "-" + mon + "-" + date+ " "+Hours +":"+ Minutes +":"+ Seconds;
            }   
     
           function check(a){  
            if(a<9){   return "0"+a ; }
               else{  return a;      }	
            }  

    2,获取前后几天

    //获取当前日期后五天,
            function getCurrDate() {
                var myDate = new Date;
                myDate.setDate(myDate.getDate()+5);  //加上了五天
                var year = myDate.getFullYear(); //获取当前年
                var mon = check(myDate.getMonth()+ 1)   //获取当前月
                var date =check(myDate.getDate())  ; //获取当前日
                var Hours = check(myDate.getHours());       // 获取当前小时数(0-23)
                var Minutes =check(myDate.getMinutes()) ;     // 获取当前分钟数(0-59)
                var Seconds = check(myDate.getSeconds());     // 获取当前秒数(0-59)
                return year + "-" + mon + "-" + date+ " "+Hours +":"+ Minutes +":"+ Seconds;
            }    
    
         function check(a){  if(a<9){ return "0"+a }else{ return a}	  }   

    3,UTC时间格式转换

    var d = new Date();  
    var UTCStr= d.toUTCString();  //得到UTC时间 
    new Date(UTCStr).toLocaleDateString()   //转为本地时间,转为UTC也是同样的

    4,时间戳转换

    var timestamp = Date.parse(new Date()); //1,精确到秒 
    new Date(parseInt(n) * 1000).toLocaleString();   //转为本地时间 
    
    var timestamp = (new Date()).valueOf(); //2,精确到毫秒
     new Date(parseInt(n) * 1000).toLocaleString().substr(0,17) //转为本地时间 
    
    var timestamp=new Date().getTime(); //3,精确到毫秒 
    new Date(parseInt(timestamp) * 1000).toLocaleString(); // 转为本地时间 

    5,处理后台响应的datetime时间

    //转为时间戳
    function ConvertJSONDateToJSDateObject(jsondate) { 
        var date = new Date(parseInt(jsondate.replace("/Date(", "").replace(")/", ""), 10));
        return date ;
    }
    
    

     

     

     

     

     

     

     

     

    展开全文
  • .NET中,经常用到两个时间的比较,如,新闻列表后显示(5分钟前)要比显示(2010-2-22 12:50)这样的时间格式直观得多了。显示结果如: ,以下是详细类代码. using System;using System.Data;using System....
  • 时区和时间戳

    千次阅读 2018-08-09 22:24:40
    它也被称为Unix时间(Unix time)、POSIX时间(POSIX time),是一种时间表示方式,定义为从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数。因此,严格来说,不管你处在地球上的哪个地方,任意时间点的时间戳...
  • 建立时间和保持时间概念

    万次阅读 多人点赞 2018-05-01 22:53:49
     时序图如下:建立时间(Tsu:set up time) 是指在触发器的时钟信号上升沿到来以前,数据稳定不变的时间,如果建立时间不够,数据将不能在这个时钟上升沿被稳定的打入触发器,Tsu就是指这个最小的稳定时间。...
  • datetime 模块详解 -- 基本的日期和时间类型 datetime 模块提供了各种类用于操作日期和时间,该模块侧重于高效率的格式化输出在 Python 中,与时间处理有关的模块包括:time,datetime 以及 calendardatetime 模块...
  • 空间与时间转换

    千次阅读 2018-07-27 16:29:29
    空间和时间之间的转换无非就两种方式即:时间换空间,空间换时间。 当年蒋介石就完成过空间换时间,以大量的土地换取自己喘息的时间。 在实际开发中时间 = 运行时间,空间 = 运行内存,所以空间和时间的转换其实也...
  • DDR3读写时序

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

    千次阅读 2017-02-24 00:00:29
    在电信网络尤其是无线通信领域里我们经常会遇到dBm dBi dB dBc等与功率有关的单位。许多维护工程师在对这些单位的理解上存在着混淆和误解造成计算失误下面集中分析这几个与功率有关的单位。 1.dBm ...
  • 若文件从创建后不曾修改过则可认为创建时间=修改时间,若文件创建后状态也不曾改变过则可认为创建时间=改变时间,若文件创建后不曾被读取过则可认为创建时间=访问时间。但是,但是,上述情况基本上是不可能的,也...
  • 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
  • Linux服务器时间同步

    万次阅读 2014-03-04 10:14:07
    Linux服务器运行久时,系统时间就会存在一定的误差,一般情况下可以使用date命令进行时间设置,但在做数据库集群分片等操作时对多台机器的时间差是有要求的,此时就需要使用ntpdate进行时间同步。 date命令: date...
  • 在Microsoft Project中有三种时间:基准计划、当前计划、实际状态。  基准计划:基线开始时间、基线完成时间、基线工期,  当前计划:开始时间、完成时间、工期  实际状态:实际开始时间、实际完成时间、实际...
  • ls实现列文件按时间排序

    万次阅读 2009-08-06 23:48:00
    1) ls -lt 时间最近的在前面2) ls -ltr 时间从前到后3) 利用sort ls -l | sort +7 (日期为第8列) 时间从前到后 ls -l | sort -r +7 时间最近的在前面
  • CentOS设置系统时间与网络时间同步

    万次阅读 2017-04-25 08:57:17
    Linux的时间分为System Clock(系统时间)和Real Time Clock (硬件时间,简称RTC)。 系统时间:指当前Linux Kernel中的时间。 硬件时间:主板上有电池供电的时间。 查看系统时间的命令: #date 设置系统时间的...
  • 几种Python执行时间的计算方法

    万次阅读 多人点赞 2017-01-09 10:22:42
    首先说一下我遇到的坑,生产上遇到的问题,我调度Python脚本执行并监控这个进程,python脚本运行时间远远大于python脚本中自己统计的程序执行时间。 监控python脚本执行的时间是36个小时,而python脚本中统计自己...
  • python——时间与时间戳之间的转换

    万次阅读 多人点赞 2016-05-09 19:03:40
    对于时间数据,如2016-05-05 20:28:54,有时需要与时间戳进行相互的运算,此时就需要对两种形式进行转换,在Python中,转换时需要用到time模块,具体的操作有如下的几种: 将时间转换为时间戳 重新格式化时间 时间戳...
1 2 3 4 5 ... 20
收藏数 7,996,765
精华内容 3,198,706
关键字:

时间