JDK8 新增的日期时间类

在本人之前的博文《处理时间的类 —— System类、Date类、SimpleDateFormat类与 Calendar类》中，讲到过表示时间的类，有三类：Date、SimpleDateFormat、Calendar类（System.currentTimeMillis()勉强也能算作是一个）

那么，在JDK8的时代，Java提供了几个新的、线程安全的、用于处理时间的类。

现在，本人就来讲讲这几个类：

JDK8 新增的日期时间类

首先是 LocalDate、LocalTime、LocalDateTime类：

LocalDate、LocalTime、LocalDateTime类：

概述：

这三个类分别表示使用 ISO-8601日历系统的日期、时间、日期和时间

它们提供了简单的日期或时间，并不包含当前的时间信息。

也不包含与时区相关的信息。

注： ISO-8601日历系统 是 国际标准化组织制定的现代公民的日期和时间的表示法

这些新增的日期时间API都在 java.time包下

获取对象的方法：

获取对象的方法：

通过静态方法 ：now()（获取的时间是系统当前的时间）

通过静态方法：of()（方法参数可以指定时间）

那么，现在，本人来通过代码来展示下如何去获取对象：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

public class Test {

    public static void main(String[] args) {

        /* 通过静态方法 now() 返回该类的实例 */

        //获取当前的日期时分秒

        LocalDateTime now = LocalDateTime.now();

        System.out.println(now);

        //获取当前的日期

        LocalDate now1 = LocalDate.now();

        System.out.println(now1);

        //获取当前的时分秒

        LocalTime now2 = LocalTime.now();

        System.out.println(now2);

        System.out.println("=========================================");

        /* 静态方法 of() 返回该类的实例 */

        //指定日期时分秒

        LocalDateTime localDateTime = LocalDateTime.of(2048, 11, 25, 12, 00, 30);

        System.out.println(localDateTime);

        //指定日期

        LocalDate date = LocalDate.of(2020, 12, 12);

        System.out.println(date);

        //指定时分秒

        LocalTime time = LocalTime.of(14, 20, 30);

        System.out.println(time);

    }

}

那么，现在，本人来展示下运行结果：

常用方法：

与获取相关的方法(get系类的方法)：

getYear()：

获取年

ldt.getHour()：

获取小时

getMinute():

获取分钟

getSecond():

获取秒值

getDayOfMonth()：

获得月份天数(1-31)

getDayOfYear()：

获得年份天数(1-366)

getDayOfWeek()：

获得星期几(返回一个 DayOfWeek枚举值)

getMonth()：

获得月份(返回一个 Month 枚举值)

getMonthValue()：

获得月份(1-12)

getYear()：

获得年份

那么，现在，本人来通过代码来展示下与获取相关的方法的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDateTime;

import java.time.Month;

public class Test {

    public static void main(String[] args) {

        //获取日期时分秒

        LocalDateTime now = LocalDateTime.now();

        //获取年份

        int year = now.getYear();

        System.out.println(year);

        //获取月份枚举

        //Month 枚举类，定义了十二个月份

        Month month = now.getMonth();

        System.out.println(month);

        //获取月份的数值

        int monthValue = now.getMonthValue();

        System.out.println(monthValue);

        //获取当天在本月的第几天

        int dayOfMonth = now.getDayOfMonth();

        System.out.println(dayOfMonth);

        //获取小时

        int hour = now.getHour();

        System.out.println(hour);

        //获取分钟

        int minute = now.getMinute();

        System.out.println(minute);

        //获取秒值

        int second = now.getSecond();

        System.out.println(second);

    }

}

那么，现在，本人来展示下运行结果：

格式化日期日期字符串的方法：

format()：

格式化字符串

那么，现在，本人来通过代码来展示下如何去格式化日期日期字符串：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

public class Test {

    public static void main(String[] args) {

        //获取当前日期时分秒

        LocalDateTime now = LocalDateTime.now();

        //默认格式  年-月-日T时:分:秒

        System.out.println(now);

        //指定格式

        DateTimeFormatter ofPattern = DateTimeFormatter.ofPattern("yyyy年MM月DD日 HH时mm分ss秒");

        //传入格式

        String dateStr = now.format(ofPattern);

        System.out.println(dateStr);

    }

}

那么，现在，本人来展示下运行结果：

转换的方法：

toLocalDate()：

将目标LocalDateTime转换为相应的LocalDate对象

toLocalTime()：

将目标LocalDateTime转换为相应的LocalTime对象

那么，现在，本人来通过代码来展示下如何去转换：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

public class Test {

    public static void main(String[] args) {

        //获取当前年月日，时分秒

        LocalDateTime now = LocalDateTime.now();

        System.out.println(now);

        //将目标LocalDateTime转换为相应的LocalDate对象

        LocalDate localDate = now.toLocalDate();

        System.out.println(localDate);

        ///将目标LocalDateTime转换为相应的LocalTime对象

        LocalTime localTime = now.toLocalTime();

        System.out.println(localTime);

    }

}

那么，现在，本人来展示下运行结果：

判断的方法：

isAfter()：

判断一个日期是否在指定日期之后

isBefore()：

判断一个日期是否在指定日期之前

isEqual()：

判断两个日期是否相同

isLeapYear()：

判断是否是闰年（注意是LocalDate类和 LocalDateTime类特有的方法）

那么，现在，本人来通过代码来展示下这些API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;

public class Test {

    public static void main(String[] args) {

        //获取当前的日期

        LocalDate now = LocalDate.now();

        //指定的日期

        LocalDate of = LocalDate.of(2015, 12, 12);

        //判断一个日期是否在另一个日期之前

        boolean before = of.isBefore(now);

        System.out.println(before);

        //判断一个日期是否在另一个日期之后

        boolean after = of.isAfter(now);

        System.out.println(after);

        //判断这两个日期是否相等

        boolean after1 = now.equals(of);

        System.out.println(after1);

        //判断闰年

        boolean leapYear = of.isLeapYear();

        System.out.println(leapYear);

    }

}

那么，现在，本人来展示下运行结果：

解析字符串的方法：

paser(String str)：

将一个日期字符串解析成日期对象,注意字符串日期的写法的格式要正确,否则解析失败

paser(String str, DateTimeFormatter formatter)：

将字符串按照参数传入的格式进行解析

那么，现在，本人来通过代码来展示下如何去解析字符串：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.format.DateTimeFormatter;

public class Test {

    public static void main(String[] args) {

        //给出一个符合默认格式要求的日期字符串

        String dateStr="2020-01-01";

        //把日期字符串解析成日期对象 如果日期字符串时年月日 解析时用  LocalDate

        LocalDate parse = LocalDate.parse(dateStr);

        System.out.println(parse);

        System.out.println("===========================================");

        //给出一个符合默认格式要求的 时分秒 字符串

        String dateTimeStr="14:20:30";

        //把 时分秒 字符串解析成时分秒对象

        LocalTime parse1 = LocalTime.parse(dateTimeStr);

        System.out.println(parse1);

        System.out.println("=========================================");

        //给出一个符合默认格式要求的 日期时分秒 字符串

        String str="2018-12-12T14:20:30";

        //把 日期时分秒 字符串解析成时分秒对象

        LocalDateTime parse2 = LocalDateTime.parse(str);

        System.out.println(parse2);

        System.out.println("========================================");

        //给出一个自定义日期时分秒格式字符串

        String dateStr2="2020年12月12日 12:13:14";

        //给出一个自定义解析格式

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        //按照指定的格式去解析

        LocalDateTime parse3 = LocalDateTime.parse(dateStr2,formatter);

        System.out.println(parse3);

    }

}

那么，现在，本人来展示下运行结果：

增减年月日时分秒的方法（plus/minus系列的方法）：

plusYears(int offset)：

增加指定年份

plusMonths(int offset)：

增加指定月份

plusWeeks(int offset)：

增加指定周

plusDates(int offset)：

增加指定日

plusHours(int offset)：

增加指定时

plusMinuets(int offset)：

增加指定分

plusSeconds(int offset)：

增加指定秒

plusNanos(int offset)：

增加指定纳秒

minusYears(int offset)：

减少指定年

minusMonths(int offset)：

减少指定月

minusWeeks(int offset)：

减少指定周

minusDates(int offset)：

减少指定日

minusHours(int offset)：

减少指定时

minusMinuets(int offset)：

减少指定分

minusSeconds(int offset)：

减少指定秒

minusNanos(int offset)：

减少指定纳秒

那么，现在，本人来通过代码来展示下部分API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.LocalDate;

import java.time.LocalDateTime;

public class Test {

    public static void main(String[] args) {

        //增加时间量的方法 plusXXX系类的方法 返回的是一个新的日期对象

        LocalDateTime now = LocalDateTime.now();

        //可以给当前的日期增加时间量

        LocalDateTime newDate= now.plusYears(1);

        int year = newDate.getYear();

        System.out.println(year);

        System.out.println("================================");

        //减去时间量的方法minusXXX 系列的方法 返回的是一个新的日期对象

        LocalDate now1 = LocalDate.now();

        LocalDate newDate2 = now1.minusDays(10);

        int dayOfMonth = newDate2.getDayOfMonth();

        System.out.println(dayOfMonth);

    }

}

那么，现在，本人来展示下运行结果：

指定年月日时分秒的方法：

with(TemporalAdjuster adjuster):

指定特殊时间

withYear(int year):

指定年

withDayOfYear(int dayOfYear):

指定日

withMonth(int month):

指定月

withDayOfMonth(int dayOfMonth):

指定日

那么，现在，本人来通过代码来展示下部分API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.DayOfWeek;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.temporal.TemporalAdjusters;

public class Test {

    public static void main(String[] args) {

        //指定某个日期的方法 with()方法

        LocalDate now2 = LocalDate.now();

        LocalDate localDate = now2.withYear(2014);

        System.out.println(localDate);

        // TemporalAdjusters工具类，提供了一些获取特殊日期的方法

        LocalDate with = now2.with(TemporalAdjusters.firstDayOfMonth());

        System.out.println(with);

        LocalDate with1 = now2.with(TemporalAdjusters.firstDayOfNextMonth());

        System.out.println(with1);

        //获取这个月的第几个星期几是几号,比如 TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY)

        // 代表的意思是这个月的第二个星期五是几号

        LocalDate with2 = now2.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY));

        System.out.println(with2);

    }

}

那么，现在，本人来展示下运行结果：

在上文中，本人运用到了TemporalAdjuster接口，

那么，现在，本人就来讲解下这个接口：

TemporalAdjuster接口 —— 时间校正器：

概述：

一般我们用该接口的一个对应的工具类 TemporalAdjusters中的一些常量,

来指定日期

对于这个接口，我们主要运用它的几个常量 和 next()方法来指定日期

或者采用自定义的方式来指定日期

现在，本人来通过一段代码来展示下这个接口的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.DayOfWeek;

import java.time.LocalDate;

import java.time.temporal.Temporal;

import java.time.temporal.TemporalAdjuster;

import java.time.temporal.TemporalAdjusters;

public class Test {

    public static void main(String[] args) {

        LocalDate now = LocalDate.now();

        //指定日期

        //对于一些特殊的日期，可以通过一个工具类TemporalAdjusters 来指定

        TemporalAdjuster temporalAdjuster = TemporalAdjusters.firstDayOfMonth();    //见名知意，本月第一天

        LocalDate with = now.with(temporalAdjuster);

        System.out.println(with);

        TemporalAdjuster next = TemporalAdjusters.next(DayOfWeek.SUNDAY);   //下周周末

        LocalDate with1 = now.with(next);

        System.out.println(with1);

        System.out.println("===================================");

        LocalDate now1 = LocalDate.now();

        //自定义日期 —— 下一个工作日

        LocalDate with2 = now1.with(new TemporalAdjuster() {

            @Override

            //参数 nowDate 当前的日期对象

            public Temporal adjustInto(Temporal nowDate) {

                //向下转型

                LocalDate date= (LocalDate) nowDate;

                if(date.getDayOfWeek().equals(DayOfWeek.FRIDAY)){

                    LocalDate localDate = date.plusDays(3);

                    return localDate;

                }else if(date.getDayOfWeek().equals(DayOfWeek.SATURDAY)){

                    LocalDate localDate = date.plusDays(2);

                    return localDate;

                }else{

                    LocalDate localDate = date.plusDays(1);

                    return localDate;

                }

            }

        });

        System.out.println("下一个工作日是：" + with2);

    }

}

那么，现在，本人来展示下运行结果：

Instant 时间戳类：

获取对象的方法：

now():

注意默认获取出来的是当前的美国时间，

和我们相差八个小时（因为我们在东八时区）

设置偏移量的方法:

atOffset():

获取系统默认时区时间的方法:

atZone():

方法的参数是要一个时区的编号(可以通过时区编号类获取ZonedDateTime类的对象)

get系列的方法:

getEpochSecond():

获取从1970-01-01 00:00:00到当前时间的秒值

toEpochMilli():

获取从1970-01-01 00:00:00到当前时间的毫秒值

getNano():

把获取到的当前时间的秒数 换算成纳秒

ofEpoch系列方法：

ofEpochSecond():

给计算机元年增加秒数

ofEpochMilli():

给计算机元年增加毫秒数

现在，本人来展示下这些API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.Instant;

import java.time.OffsetDateTime;

import java.time.ZoneOffset;

import java.util.Date;

public class Test {

    public static void main(String[] args) {

        //  Instant 时间戳类从1970 -01 - 01 00:00:00 截止到当前时间的毫秒值

        Instant now = Instant.now();

        System.out.println(now); //获取的是默认时区，获取的不是中国 的时区

        //获取当前时区的，我们可以添加偏移量,返回偏移过后的日期

        OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));

        System.out.println(offsetDateTime);

        System.out.println("===========================");

        //从1970 - 01 - 01 00:00:00 截止到当前时间的毫秒值

        long l = System.currentTimeMillis();

        System.out.println(l);

        long time = new Date().getTime();

        //JDK1.8 Instant 时间戳类从1970 -01 - 01 00:00:00 截止到当前时间的毫秒值

        Instant now1 = Instant.now();

        //toEpochMilli():从1970 -01 - 01 00:00:00 截止到当前时间间隔的毫秒值

        long l1 = now1.toEpochMilli();

        System.out.println(l1);

        //获取从1970 -01 - 01 00:00:00 截止到当前时间间隔的秒值

        long epochSecond = now1.getEpochSecond();

        System.out.println(epochSecond);

        System.out.println("==========================");

        //给计算机元年增加相应的时间量

        Date date = new Date(1000 * 60 * 60*24);

        System.out.println(date);

        //现在 给计算机元年增加相应的时间量

        //5. ofEpochSecond() 方法 给计算机元年增加秒数

        //ofEpochMilli() 给计算机元年增加毫秒数

        Instant instant = Instant.ofEpochMilli(1000 * 60 * 60 * 24);

        System.out.println(instant);

        //ofEpochSecond() 方法 给计算机元年增加秒数

        Instant instant1 = Instant.ofEpochSecond(60 * 60 * 24);

        System.out.println(instant1);

    }

}

那么，现在本人来展示下运行结果：

Duration类 —— 用于计算两个“时间”间隔的类：

常用API：

静态方法 between()：

计算两个时间的间隔，默认是秒

toDays():

将时间转换为以天为单位的

toHours():

将时间转换为以时为单位的

toMinutes():

将时间转换为以分钟为单位的

toMillis()：

将时间转换为以毫秒为单位的

toNanos():

将时间转换为以纳秒为单位的

那么，现在本人来通过一段代码展示下这些API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.Duration;

import java.time.Instant;

import java.time.OffsetDateTime;

import java.time.ZoneOffset;

import java.util.Date;

public class Test {

    public static void main(String[] args) {

        //计算时间的间隔

        Instant start = Instant.now();

        for (int i = 0; i < 15; i++) {

            System.out.println(i);

        }

        Instant end = Instant.now();

        Duration duration = Duration.between(start, end);

        long l = duration.toNanos();

        //间隔的时间

        System.out.println("循环耗时："+l+"纳秒");

    }

}

现在，本人来展示下运行结果：

Period类 —— 用于计算两个“日期”间隔的类：

静态方法 between()：

计算两个日期之间的间隔

getYears()：

获取年份

getMonths()：

获取月份

getDays()：

获取天数

那么，现在本人来通过一段代码展示下这些API的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.*;

public class Test {

    public static void main(String[] args) {

        //计算两个日期的间隔

        LocalDate birthday = LocalDate.of(2012, 12, 12);

        LocalDate now = LocalDate.now();

        //我从出生到现在，有多少岁，零几个月，几天

        //计算两个日期的间隔

        Period between = Period.between(birthday, now);

        int years = between.getYears();

        int months = between.getMonths();

        int days = between.getDays();

        System.out.println("玛雅人的地球都消灭了"+years+"年"+months+"月"+days+"天了...");

    }

}

那么，现在，本人来展示下运行结果:

DateTimeFormatter类 —— 解析和格式化日期或时间的类

本人现在来展示下这个类的常用API ：

静态方法ofPattern("yyyy-MM-dd")：

通过给定格式获取对象

format()：

把一个日期对象的默认格式 格式化成指定的格式的字符串

那么，现在，本人来展示下这个类的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.DayOfWeek;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.time.temporal.Temporal;

import java.time.temporal.TemporalAdjuster;

import java.time.temporal.TemporalAdjusters;

public class Test {

    public static void main(String[] args) {

        // 之前格式化日期的类  new SimpleDateFormat()

        //JDK1.8 DateTimeFormatter

        //指定格式 静态方法 ofPattern()

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // DateTimeFormatter 自带的格式方法

        LocalDateTime now = LocalDateTime.now();

        //把日期对象，格式化成字符串

        String format = formatter.format(now);

        //刚才的方式是使用的日期自带的格式化方法

        String format1 = now.format(formatter);

        System.out.println(format);

        System.out.println(format1);

    }

}

那么，现在本人来展示下运行结果：

ZonedDate、ZonedTime、ZonedDateTime —— 带时区的时间或日期

概述：

这个三个类方法及用法和 LocalDate、 LocalTime、 LocalDateTime 基本一样

只不过ZonedDate,ZonedTime、ZonedDateTime 这三个带有当前系统的默认时区的时间表示类

那么使用这三个类，就不得不介绍下 ZoneID类：

ZoneID —— 世界时区类：

常用API：

getAvailableZoneIds()：

.获取世界各个地方的时区的集合

systemDefault()：

获取系统默认时区的ID

of(String zoneName):

根据各个地区的时区ID名创建对象

那么，现在，本人就来展示下这几个类的使用：

package edu.youzg.about_new_features.core.about_jdk8.core;

import java.time.*;

import java.util.Set;

public class Test {

    public static void main(String[] args) {

        //ZoneID 世界时区类

        //获取世界各地的时区编号。

        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();

        for (String availableZoneId : availableZoneIds) {

            System.out.println(availableZoneId);

        }

        System.out.println("=====================");

        //获取系统的默认时区编号

        ZoneId zoneId = ZoneId.systemDefault();

        System.out.println(zoneId);

        //获取其他国家的日期

        LocalDateTime now = LocalDateTime.now();

        //获取指定时区的日期时间

        ZoneId zoneId1 = ZoneId.of("Europe/Monaco");

        ZonedDateTime zonedDateTime = now.atZone(zoneId1);  //获得指定时区的当前时间

        System.out.println(zonedDateTime);

        System.out.println("=====================");

        //根据时区，获取该地区的日期

        LocalDateTime now1 = LocalDateTime.now(ZoneId.of("America/Phoenix"));  //获得指定时区的当前时间（不带时区信息）

        System.out.println(now1);

    }

}

由于世界各地的时区编号太多，所以，本人仅展示最后的几个输出结果：

详解 JDK8 新增的日期时间类的更多相关文章

JDK8 新增的日期时间API
背景 JDK8中增加了一套全新的日期时间API,这里进行总结下,方便查询使用. 新的时间及日期API位于 java.time 包中,下面是一些关键类. Instant:代表的是时间戳. LocalDa ...
jdk8环境下sprngboot/springmvc中JSR310新日期/时间类LocalDateTime显示效果带T
如图所示: 日期时间类中带了一个T,以上这种格式LocalDateTime格式化的时候默认日期时间格式:ISO.DATE_TIME(按笔者目前的知识理解是ISO8601规范中的日期时间格式化) 想要把 ...
Java日期时间API系列3-----Jdk7及以前的日期时间类的不方便使用问题
使用Java日期时间类,每个人都很熟悉每个项目中必不可少的工具类就是dateutil,包含各种日期计算,格式化等处理,而且常常会遇到找不到可用的处理方法,需要自己新增方法,处理过程很复杂. 1.Dat ...
日期类时间类，日期时间类，单例模式，装箱与拆箱，数字类随机数，BigDecimal总结
1.日期类,时间类,日期时间类初步日期使用方法及格式转换方法(旧方法): 格式://Mon Jul 30 11:26:05 CST 2018 年月日时分秒 CST代表北 ...
日期时间类：Date，Calendar，计算类：Math
日期时间类计算机如何表示时间? 时间戳(timestamp):距离特定时间的时间间隔. 计算机时间戳是指距离历元(1970-01-01 00:00:00:000)的时间间隔(ms). 计算机中时间2 ...
Java日期时间类
日期时间类有三种: 一.java.util.Date:一般用于声明日期时间类型的变量. 二.java.sql.Date:一般用于数据库日期时间的映射. 三.java.util.Calendar:一般用 ...
Java 之 JDK1.8之前日期时间类
一.JDK1.8之前日期时间类二. java.lang.System类 System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1 ...
Object类、日期时间类、system类及StringBuilder字符串容器
一.Object类常用API 1.1 概述 java.lang.Object类是Java语言中的根类,即所有类的父类.Object类中描述的所有方法子类都可以使用.在对象实例化的时候,最终找的父类就是 ...
详解Java中格式化日期的DateFormat与SimpleDateFormat类
DateFormat其本身是一个抽象类,SimpleDateFormat 类是DateFormat类的子类,一般情况下来讲DateFormat类很少会直接使用,而都使用SimpleDateFormat ...

随机推荐

Xmind8 Pro破解版
思维导图又叫心智导图,是表达发散性思维的有效图形思维工具 ,它简单却又很有效,是一种实用性的思维工具.思维导图运用图文并重的技巧,把各级主题的关系用相互隶属与相关的层级图表现出来,把主题关键词与图像. ...
2，MapReduce原理及源码解读
MapReduce原理及源码解读目录 MapReduce原理及源码解读一.分片灵魂拷问:为什么要分片? 1.1 对谁分片 1.2 长度是否为0 1.3 是否可以分片 1.4 分片的大小 1.5 ...
谷歌开发者:看可口可乐公司是怎么玩转 TensorFlow 的？
在这篇客座文章中,可口可乐公司的 Patrick Brandt 将向我们介绍他们如何使用 AI 和 TensorFlow 实现无缝式购买凭证. 可口可乐的核心忠诚度计划于 2006 年以 MyCoke ...
树莓派 Raspberry PI基础
树莓派 Raspberry PI基础官网网址:https://www.raspberrypi.org 下载地址:https://www.raspberrypi.org/downloads/ 官方系统 ...
CentOS7通过wget下载文件到指定目录
查看自己的CentOS7系统有没有安装wget: [duanyongchun@192 3DUnetCNN]$ rpm -qa|grep wget 已安装提示: #已安装提示:wget-1.14-18. ...
A song for a new begining 8月26日到10月11日第一阶段
玩转redis-简单消息队列
使用go语言基于redis写了一个简单的消息队列源码地址使用demo redis的 list 非常的灵活,可以从左边或者右边添加元素,当然也以从任意一头读取数据添加数据和获取数据的操作也是非常简 ...
centos替换源
!/bin/sh 本文原内容来自:https://github.com/judasn/Linux-Tutorial/blob/master/CentOS-Extra-Packages.md 可能额外需 ...
mysql正则匹配中文时存在的问题
可以看到,目前正则匹配字母没问题,c出现1次,2次,3次匹配的结果都是正常的接下来我们看看匹配中文的效果可以看到,当匹配连续出现歪时,结果就开始不正常了然后我去看了下mysql的中文文档中关于正 ...
Shell:Day07.笔记
函数:1.函数介绍function 为了避免代码重复使用,我们一般通过函数编写代码块,而这一个代码块用来实现某种功能. 且,这个功能在后面的代码中,会重复调用: def 2.函数的语法格式函数的写 ...

详解 JDK8 新增的日期时间类

JDK8 新增的日期时间类

LocalDate、LocalTime、LocalDateTime类：

获取对象的方法：

常用方法：

与获取相关的方法(get系类的方法)：

格式化日期日期字符串的方法：

转换的方法：

判断的方法：

解析字符串的方法：

增减年月日时分秒的方法（plus/minus系列的方法）：

指定年月日时分秒的方法：

TemporalAdjuster接口 —— 时间校正器：

Instant 时间戳类：

Duration类 —— 用于计算两个“时间”间隔的类：

Period类 —— 用于计算两个“日期”间隔的类：

DateTimeFormatter类 —— 解析和格式化日期或时间的类

ZonedDate、ZonedTime、ZonedDateTime —— 带时区的时间或日期

ZoneID —— 世界时区类：

详解 JDK8 新增的日期时间类的更多相关文章

随机推荐

热门专题