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 ...

随机推荐

面试刷题17:线程两次start()会发生什么？
线程是并发编程的基础元素,是系统调度的最小单元,现代的jvm直接对应了内核线程.为了降低并发编程的门槛,go语言引入了协程. 你好,我是李福春,我在准备面试,今天的题目是? 一个线程两次调用start ...
曹工说Spring Boot源码（26）-- 学习字节码也太难了，实在不能忍受了，写了个小小的字节码执行引擎
曹工说Spring Boot源码(26)-- 学习字节码也太难了,实在不能忍受了,写了个小小的字节码执行引擎写在前面的话相关背景及资源: 曹工说Spring Boot源码(1)-- Bean De ...
构建一个简单的 Google Dialogflow 聊天机器人【上】
概述本教程将向您展示如何构建一个简单的Dialogflow聊天机器人,引导您完成Dialogflow的最重要功能.您将学习如何: 创建Dialogflow帐户和第一个Dialogflow聊天机器人, ...
CUDA编程入门
CUDA是一个并行计算框架.用于计算加速.是nvidia家的产品.广泛地应用于现在的深度学习加速. 一句话描述就是:cuda帮助我们把运算从cpu放到gpu上做,gpu多线程同时处理运算,达到加速效果 ...
Oracle 和SQL Server 中的SQL语句使用区别
最近开始接触Oracle,想要了解下同SQL Server使用时的区别.搜寻网上信息找到具体区别分类如下: 一.数据类型比较类型名称 Oracle SQLServer 比较字符数据类型 CHA ...
Codeforces Round #625 (1A - 1D)
A - Journey Planning 题意: 有一列共 n 个城市, 每个城市有美丽值 b[i], 要访问一个子序列的城市, 这个子序列相邻项的原项数之差等于美丽值之差, 求最大的美丽值总和. ...
使用nginx访问FastDFS
文中所有~~~均为同一个自定义文件夹名字,一般使用项目名称 2.1.为什么需要用Nginx访问? FastDFS通过Tracker服务器,将文件放在Storage服务器存储,但是同组存储服务器之间需要 ...
Java系列之数组
原文首发于微信公众号:jzman-blog,欢迎关注交流! 本来打算温习一下注解方面的内容作为今天的推送,但是来不及写了,那就一起来看一下数组,数组是用来存放一组具有相同类型数据的数据结构,通过下标来 ...
关于java动态代理模式
1. 动态代理动态代理就是通过代理类是代理类与相关接口不直接发生联系,而在运行期(Runtime)实现动态关联. 动态代理主要用到java.lang.reflect包中的两个类,Invocation ...
使用内部枚举类作为外部类的参数的Mybatis的参数该如何判断
新写了一个接口,期望根据不同的参数来给数据库中不同的字段进行传值.这里使用了内部静态枚举类的方式进行传值,在写mybatis动态sql时,如果是普通对象,一般使用,那么使用枚举类,如何判断枚举类的值呢 ...

详解 JDK8 新增的日期时间类

JDK8 新增的日期时间类

LocalDate、LocalTime、LocalDateTime类：

获取对象的方法：

常用方法：

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

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

转换的方法：

判断的方法：

解析字符串的方法：

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

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

TemporalAdjuster接口 —— 时间校正器：

Instant 时间戳类：

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

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

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

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

ZoneID —— 世界时区类：

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

随机推荐

热门专题