JAVA中适合时间的对象_Java8的最新时间类库

最新推荐文章于 2024-07-05 08:14:42 发布

weixin_39997400

最新推荐文章于 2024-07-05 08:14:42 发布

阅读量181

点赞数

文章标签： JAVA中适合时间的对象

本文链接：https://blog.csdn.net/weixin_39997400/article/details/114673800

版权

十三、plus方法在LocalDate中的使用

想要修改某个日期/时间对象的现有实例时，我们可以使用 plus和 minus方法来完成操作。

Java8中日期时间相关的API中的所有实例都是不可改变的，一旦创建LocalDate，LocalTime，LocalDateTime就无法修改他们(类似于String)，这对于线程安全时非常有利的。

plus方法在LocalDate与LocalTime中的使用

LocalDate中定义了多种对日期进行增减操作的方法。

LocalDate plusDay(long days) 增加天数

LocalDate plusWeeks(long weeks) 增加周数

LocallDate plusMonths(long months) 增加月数

LocalDate plusYears(long years) 增加年数

importjava.time.LocalDate;importjava.time.Month;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 13:15*/

public classJava8TimeMethodPlusDemo1 {public static voidmain(String[] args) {//封装 LocalDate 对象参数为2016年2月13日

LocalDate localDate = LocalDate.of(2016, Month.FEBRUARY, 13);//当前时间是：2016-02-13

System.out.println("当前时间是：" +localDate);//计算当前时间的4天后的时间并打印注意：返回的是一个新的对象

LocalDate localDate1 = localDate.plusDays(4);//当前四天后的时间是：2016-02-17

System.out.println("当前四天后的时间是：" +localDate1);//计算当前时间的3周后的时间并打印

LocalDate localDate2 = localDate.plusWeeks(3);//当前三周后的时间是：2016-03-05

System.out.println("当前三周后的时间是：" +localDate2);//计算当前时间的5个月后的实际教案并打印

LocalDate localDate3 = localDate.plusMonths(5);//当前五个月后的时间是：2016-07-13

System.out.println("当前五个月后的时间是：" +localDate3);//计算当前时间的2年后的时间并打印

LocalDate localDate4 = localDate.plusYears(2);//当前两年后的时间是：2018-02-13

System.out.println("当前两年后的时间是：" +localDate4);

}

结果

minus方法与以上类似。

十四、plus方法在LocalTime中的使用

LocalTime中定义了多种对事件进行增减操作的方法

LocalTime plusNanos(long nanos) 增加纳秒

LocalTime plusSeconds(long seconds) 增加秒

LocalTime plusMinutes(long minutes) 增加分钟

LocalTime plusHours(long hours) 增加小时

importjava.time.LocalTime;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 13:29*/

public classJava8TimeMethodPlusDemo2 {public static voidmain(String[] args) {//封装 LocalTime对象参数为8点14分39秒218纳秒

LocalTime localTime = LocalTime.of(8, 14, 39, 218);//当前时间是：08:14:39.000000218

System.out.println("当前时间是：" +localTime);//计算当前事件500纳秒后的时间并打印

LocalTime localTime1 = localTime.plusNanos(500);//当前时间500纳秒后是：08:14:39.000000718

System.out.println("当前时间500纳秒后是：" +localTime1);//计算当前时间45秒后的时间并打印

LocalTime localTime2 = localTime.plusSeconds(45);//当前时间45秒后是：08:15:24.000000218

System.out.println("当前时间45秒后是：" +localTime2);//计算当前时间19分钟后的时间并打印

LocalTime localTime3 = localTime.plusMinutes(19);//当前时间19分钟后是：08:33:39.000000218

System.out.println("当前时间19分钟后是：" +localTime3);//计算当前时间3小时后的时间并打印

LocalTime localTime4 = localTime.plusHours(3);//当前时间3小时后是：11:14:39.000000218

System.out.println("当前时间3小时后是：" +localTime4);

}

结果

十五、plus的单独使用方式1

本文中都是使用plusXXX的方法进行演示，

实际上也有对应的减少方法，以minus开头的方法对应的即为减少，实际上也有对应的减少方法，以minus开头的方法对应的即为减少，实际上minus方法调用的也是plus方法，只不过传入的参数是负数。

plus 和 minus 方法的应用

刚才学习到的plusXXX相关的方法都是添加了数值到具体的某一项上，根据观察还有两个单独的plus方法，接下来我们来学习这两个单独的plus方法。

plus(long amountToadd, TemporalUnit unit) LocalTime

plus(TemporalAmount amoutToadd) LocalTime

TemporalAmount 是一个接口，当接口作为方法的参数的时候，实际上传入的是接口的实现类对象，根据查看这个接口的体系，可以看到这个接口有一个实现类，名字叫做Period，在学习第一节的时候，说明了这个类表示一段时间。

format,png

如何使用Period来表示一段时间呢？这个类本身提供了of(int year, int month, int day)来表示，例如：Period.of(1,2,3)返回的对象即为1年2个月3天这么一个时间段。

importjava.time.LocalDateTime;importjava.time.Period;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 13:48

* 今天程序员小张查看自己的车辆保险记录的时候看到还有2年3月8天就到期了，计算到期的时间是什么时候*/

public classJava8TimeMethodPlusDemo3 {public static voidmain(String[] args) {//1、封装当前时间 -> now方法

LocalDateTime now =LocalDateTime.now();//2、在当前时间的基础上进行+2年，+3月，+8天的操作//然后获得一个截止日期对象，这个对象表示的时间就是保险到期的时间。

LocalDateTime endTime = now.plusYears(2).plusMonths(3).plusDays(8);//当前的时间是：2020-05-03T13:52:34.316278400保险到期的时间是：2022-08-11T13:52:34.316278400

System.out.println("当前的时间是：" + now + "保险到期的时间是：" +endTime);//plus(TemporalAmount amountToAdd)//1、首先封装 priod.of()方法传进去参数

Period period = Period.of(2, 3, 8);//2、通过 now()方法的 plus()方法传进去

LocalDateTime endTime1 =now.plus(period);//当前的时间是：2020-05-03T14:06:16.239460900保险到期的时间是：2022-08-11T14:06:16.239460900

System.out.println("当前的时间是：" + now + "保险到期的时间是：" +endTime1);

}

结果

十六、plus的单独使用方式2

plus(long amountToadd, TemporalUnit unit)

在实际开发过程中，可能还会更精准的去操作日期或者说增加一些特殊的时间，比如说1个世纪、1个半天，1千年，10年等，Java8提供了这些日期的表示方式而不需要去单独进行计算了。

TemporalUnit是一个接口，通过查看体系接口发现,可以使用子类ChronoUnit来表示，ChronoUnit封装了很多时间段供我们使用。

importjava.time.LocalDateTime;importjava.time.Month;importjava.time.temporal.ChronoUnit;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 14:41

* 结婚10年称为锡婚，2020年2月2日11点11分11秒成为对称日，如果在那天结婚了，那么锡婚会发生在什么时候？*/

public classJava8TimeMethodPlusDemo4 {public static voidmain(String[] args) {//封装一个日期，表示结婚的时间电

LocalDateTime marriedTime = LocalDateTime.of(2020, Month.FEBRUARY, 2, 11, 11, 11);//使用 plus方法进行计算

LocalDateTime time = marriedTime.plus(1, ChronoUnit.DECADES);//如果在2020-02-02T11:11:11，那么锡婚在：2030-02-02T11:11:11

System.out.println("如果在" + marriedTime + "，那么锡婚在：" +time);//如果锡婚后的半天需要请所有的亲戚朋友吃饭，那么计算吃饭的时间节点\

LocalDateTime eating = time.plus(1, ChronoUnit.HALF_DAYS);//吃饭的时间是：2030-02-02T23:11:11

System.out.println("吃饭的时间是：" +eating);

}

结果

十七、with方法的使用方式1

with方法在LocalDateTime类的应用

如果不需要对日期进行加减而是要直接修改日期的话，那么可以使用with方法，with方法提供了很多种修改时间的方式

LocalDateTime withNano(int i) 修改纳秒

LocalDateTime withSecond(int i) 修改秒

LocalDateTime withMinute(int i) 修改分支

LocalDateTime withHour(int i) 修改小时

LocalDateTime withDayOfMonth(int i) 修改日

LocalDateTime withMonth(int i) 修改月

LocalDateTime withYear(int i) 修改年

importjava.time.LocalDateTime;importjava.time.Month;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 14:59*/

public classJava8TimeMethodWithDemo1 {public staticLocalDateTime getTime(){return LocalDateTime.of(1999, Month.DECEMBER,12,12,12,0);

}public static voidmain(String[] args) {

LocalDateTime time=getTime();//经过使用之后发现time中的时间有错误，应该日期是1号//在不知道原有时间的基础山，无法进行增减操作，所以可以直接使用with方法进行修改

LocalDateTime resultTime = time.withDayOfMonth(1);//修改前错误的时间是：1999-12-12T12:12，正确的时间是：1999-12-01T12:12

System.out.println("修改前错误的时间是：" + time + "，正确的时间是：" +resultTime);

}

结果

十八、with方法的使用方式2

with(TemporalField field, long newValue)

temporalField是一个接口，通过查看体系结构，可以使用它的子类

ChronoField,ChronoField中封装了一些日期时间中的组成成分，可以直接选择之后传入第二个参数进行修改。

例如：with(ChronoField.DAY_OFMONTH,1);将日期中的月份中的天数改为1

例如：with(ChronoField.YEAR,2021);将日期中的年份改为2021。

importjava.time.LocalDateTime;importjava.time.Month;importjava.time.temporal.ChronoField;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 15:16*/

public classJava8TimeMethoodWithDemo2 {public staticLocalDateTime getTime() {return LocalDateTime.of(1999, Month.DECEMBER,12,12,12,0);

}public static voidmain(String[] args) {

LocalDateTime time=getTime();//经过使用之后发现time中的事件有错误，应该是1号 ->在不知道原有时间的基础上，无法进行增减操作，所以可以直接使用with方式进行修改

LocalDateTime resultTime = time.with(ChronoField.DAY_OF_MONTH, 1);//修改前：1999-12-12T12:12

System.out.println("修改前：" +time);//修改后：1999-12-01T12:12

System.out.println("修改后：" +resultTime);

}

结果

十九、章节练习(2)

importjava.time.LocalDateTime;importjava.time.Month;importjava.time.Period;importjava.time.temporal.TemporalAdjuster;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 15:23

* 使用三种方式计算2019年7月19日14时38分34秒后的3年7个月18天后是什么时候？*/

public classJava8TimeMethodTest {public static voidmain(String[] args) {//封装一个当前时间 -> of方法

LocalDateTime time = LocalDateTime.of(2019, Month.JULY, 19, 14, 38, 34);//通过 Period 封装一个时间段表示3年7个月18天

Period period = Period.of(3, 7, 18);

LocalDateTime endTime=time.plus(period);//当前时间时：2019-07-19T14:38:34,3年7个月18天的日期是：2023-03-09T14:38:34

System.out.println("当前时间时：" + time + ",3年7个月18天的日期是：" +endTime);

}

结果

二十、TemporalAdjuster调节器的使用

调节器TemporalAdjuster与查询TemporalQuery

with(TemporalAdjuster adjuster)

在上一节学习的with方法中学习了可以通过with方法修改日期时间对象中封装的数据，但是有一些时候可能会做一些复杂的操作，

比如说将时间调整到下个周的周日，下一个工作日，或者本月中的某一天，这个时候可以使用调节器TemporalAdjuster来更方便的处理日期。

with方法有一个重载形式，需要传入一个TemporalAdjuster对象，通过查看发现TemporalAdjuster是一个接口，那么实际上传入的是这个接口的实现类对象。

在以上的描述中，发现了一个叫做TemporalAdjusters的类可以给我们提供一些常用的方法，方法如下：

TemporalAdjusters类中常用静态方法的使用

static TemporalAdjuster firstDayofNextMonth() 下个月的第一天

static TemporalAdjuster firstDayOfNextYear() 下一年的第一天

static TemporalAdjuster firstDayOfYear() 当年的第一天

importjava.time.LocalDate;importjava.time.temporal.TemporalAdjusters;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 15:46*/

public classJava8TimeTemporalAdjusterDemo1 {public static voidmain(String[] args) {//封装日期时间对象为当前时间

LocalDate now =LocalDate.now();//通过 with方法传入 TemporalAdjuster类的实现对象，就可以进行更改//实现类对象是由 TemporalAdjusters类的静态方法来提供。修改时间为当月的第一天

LocalDate firstDayOfMonth =now.with(TemporalAdjusters.firstDayOfMonth());//将时间修改为当月的第一天，具体时间为：2020-05-01

System.out.println("将时间修改为当月的第一天，具体时间为：" +firstDayOfMonth);//修改时间为下个月的第一天

LocalDate firstDayOfNextmonth =now.with(TemporalAdjusters.firstDayOfNextMonth());//下个月的第一天：2020-06-01

System.out.println("下个月的第一天：" +firstDayOfNextmonth);//修改时间为下一年的第一天

LocalDate firstDayOfNextyear =now.with(TemporalAdjusters.firstDayOfNextYear());//下一年的第一天：2021-01-01

System.out.println("下一年的第一天：" +firstDayOfNextyear);//修改时间为本年的第一天

LocalDate firstDayOfYear =now.with(TemporalAdjusters.firstDayOfYear());//本年的第一天：2020-01-01

System.out.println("本年的第一天：" +firstDayOfYear);//修改时间为本月的最后一天

LocalDate lastDayOfMonth =now.with(TemporalAdjusters.lastDayOfMonth());//本月的最后一天：2020-05-31

System.out.println("本月的最后一天：" +lastDayOfMonth);//修改时间为本年的最后一天

LocalDate lastDayOfYear =now.with(TemporalAdjusters.lastDayOfYear());//本年的最后一天：2020-12-31

System.out.println("本年的最后一天：" +lastDayOfYear);

}

结果

注意：TemporalAdjusters 是一个接口，with方法实际上传入的是这个饥饿口的实现类对象，TemporalAdjusters并不是TemporalAdjuster的实现类，

只不过TemporalAdjusters的静态方法实现了TemporalAdjuster，并且将实现类对象返回了。

二十一、DayOfWeek枚举类使用

DayOfWeek是一周中星期几的枚举类，其中封装了从周一到周日

importjava.time.DayOfWeek;importjava.time.LocalDate;importjava.time.temporal.TemporalAdjusters;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 16:07*/

public classJava8TimeTemporalAdjusterDemo2 {public static voidmain(String[] args) {//封装日期对象为当前时间

LocalDate now =LocalDate.now();//将当前时间修改为下一个周日

LocalDate s =now.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));//下一个周日是：2020-05-10

System.out.println("下一个周日是：" +s);//将当前时间修改为上一个周三

LocalDate w =now.with(TemporalAdjusters.previous(DayOfWeek.WEDNESDAY));//上一个周三是：2020-04-29

System.out.println("上一个周三是：" +w);

}

结果

二十二、自定义TemporalAdjuster调节器

通过Java8本身提供的TemporalAdjusters中的方法可以完成一些常用的操作，如果要自定义日期时间的更改逻辑，可以通过实现TemporalAdjuster类接口的方式来完成。

1、创建类实现TemporalAdjuster接口

2、实现TemporalAdjuster中的 adjusterInto()方法，传入一个日期时间对象，完成逻辑之后返回日期事件对象。

3、通过with方法传入自定义调节器对象完成更改。

例如：假如员工一个月中领取工资，发薪日是每个月的15日，如果发薪日是周末，则调整为周五。

/***@authorLiuHuaXiong

* @create 2020-05-03 下午 16:17

* 假如员工一个月中领取工资，发薪日是每个月的15日，如果发薪日是周末，则调整为周五。

* 之后会传入一个日期时间对象，判断是不是15号，如果不是就修改为15号，如果是周六或者是周日，则改为周五(上一个)*/

public class PayDayAdjuster implementsTemporalAdjuster {

@OverridepublicTemporal adjustInto(Temporal temporal) {//Temporal 是time包下所有日期事件类对象的顶级父接口，实际上可以理解为传入的是 LocalDate或者 LocalTime对象//1、需要将 temporal 转换为 LocalDate 对象

LocalDate payDay =LocalDate.from(temporal);//2、判断当前封装的时间中的日期是不是当月15号，如果不是就修改为15

intday;if(payDay.getDayOfMonth() != 15) {

day= 15;

}else{

day=payDay.getDayOfMonth();

}//将 payDay中的值改为15

LocalDate realPayDay =payDay.withDayOfMonth(day);//3、判断 readPayDay 对象中封装的星期数是不是周六或者是周日，如果是就改为上一周周五

if (realPayDay.getDayOfWeek() == DayOfWeek.SUNDAY ||realPayDay.getDayOfWeek()==DayOfWeek.SATURDAY) {//如果发薪日是周末则修改为上一个周五

realPayDay =realPayDay.with(TemporalAdjusters.previous(DayOfWeek.FRIDAY));

}returnrealPayDay;

}

importjava.time.LocalDate;importjava.time.Month;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 16:33*/

public classJava8TimeTemporalAdjusterDemo3 {public static voidmain(String[] args) {//封装 LocalDate 对象为2018年12月1日

LocalDate payDay = LocalDate.of(2018, Month.DECEMBER, 15);//计算 payDay 的真实发薪日是什么时候

LocalDate realPayDay = LocalDate.from(newPayDayAdjuster().adjustInto(payDay));//预计的发薪日是：2018-12-15

System.out.println("预计的发薪日是：" +payDay);//真实的发薪日是：2018-12-14

System.out.println("真实的发薪日是：" +realPayDay);

}

结果

二十三、TemporalQuery的应用

学习的时态类对象(LocalDate，LocalTime)都有一个方法叫做query，可以针对日期进行查询，R query(TemporalQuery query)这个方法是一个泛型方法，返回的数据就是传入的泛型类的类型，TemporalQuery是一个泛型接口，里面有一个抽象方法是R queryFrom(TemporalAccessor temporal)，TemporalAccessor是Temporal的父接口，实际上也就是LocalDate,LocalDateTime相关类的顶级父接口，这个queryFrom的方法的实现逻辑就是，传入一个日期/时间对象通过自定义逻辑返回数据。

如果要计划日期距离某一天特定天数差距多少天，可以自定义类实现TemporalQuery接口并且作为参数传到query方法中。

例如：计算当前时间距离下一个劳动节还有多少天？

importjava.time.LocalDate;importjava.time.Month;importjava.time.temporal.ChronoUnit;importjava.time.temporal.TemporalAccessor;importjava.time.temporal.TemporalQuery;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 12:06*/

//获取某一天距离下一个劳动节相隔天数的实现类

public class UtilDayQueryImpl implements TemporalQuery{

@OverridepublicLong queryFrom(TemporalAccessor temporal) {//1、TemporalAccessor是LocalDateTime的顶级父接口，相当于LocalDate就是这个接口，将Temporal转换为//LocalDate 进行使用

LocalDate now =LocalDate.from(temporal);//2、封装当年劳动节时间

LocalDate laborDay = LocalDate.of(now.getYear(), Month.MAY, 1);//3、判断当前时间是否已经超过了当年的劳动节

if(now.isAfter(laborDay)) {

laborDay= laborDay.plusYears(1);

}//4、通过ChronoUnit的between来计算两个时间电的差额

long days =ChronoUnit.DAYS.between(now, laborDay);returndays;

}

importjava.time.LocalDate;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 12:35*/

public classJava8TimeTemporalQueryDemo1 {public static voidmain(String[] args) {//计算距离下一个劳动节还有多少天

LocalDate now =LocalDate.now();//调用now的query方法，然后将我们自己的实现类UtilDayQueryImpl作为参数传入

Long day = now.query(newUtilDayQueryImpl());//2020-05-03

System.out.println(now);//363

System.out.println(day);

}

结果

二十四、章节练习(3)

importjava.time.LocalDate;importjava.time.Month;importjava.time.temporal.ChronoUnit;importjava.time.temporal.TemporalAccessor;importjava.time.temporal.TemporalQuery;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 12:51*/

public class TestQueryImpl implements TemporalQuery{//计算任意时间与下一个圣诞节/儿童节/劳动节各相差多少天

/***

*@paramtemporal

*@return表示距离三个节日天数差额，0-圣诞节，1-儿童节，2-劳动节*/@OverridepublicLong[] queryFrom(TemporalAccessor temporal) {//1、将传入的参数转换为LocalDate对象

LocalDate date =LocalDate.from(temporal);//2、封装当年的圣诞节/儿童节/劳动节的日期时间对象

LocalDate d1 = LocalDate.of(date.getYear(), Month.DECEMBER, 25);

LocalDate d2= LocalDate.of(date.getYear(), Month.JUNE, 1);

LocalDate d3= LocalDate.of(date.getYear(), Month.MAY, 1);//3、判断date是否已经超过了d1/d2/d3

if(date.isAfter(d1)) {

d1= d1.plusYears(1);

}if(date.isAfter(d2)) {

d2= d2.plusYears(1);

}if(date.isAfter(d3)) {

d3= d3.plusYears(1);

}

Long[] lon={ChronoUnit.DAYS.between(date,d1),ChronoUnit.DAYS.between(date,d2),

ChronoUnit.DAYS.between(date,d3)};returnlon;

}

importjava.time.LocalDate;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 13:04*/

public classJava8TimeTemporalQueryTest2 {public static voidmain(String[] args) {//1、封装任意日期

LocalDate date = LocalDate.of(2020, 5, 30);//2、调用date 对象的query方法查询距离三个节日的差额

Long[] query = date.query(newTestQueryImpl());//3、打印结果//209

System.out.println(query[0]);//2

System.out.println(query[1]);//336

System.out.println(query[2]);

}

结果

二十五、java.util.Date转换为java.time.LocalDate(1)

对于老项目的改造，需要将Date或者Calendar转换为java.util包中相应的类的，可以根据本小节中提供的方法进行改造。

Java8中的java.time中并没有提供太多的内置方式来转换java.util包中用预处理标准日期和时间的类，我们可以使用Instant类作为中介，也可以使用java.sql.Date和java.sql.TimeStamp类提供的方法进行转换。

使用Instant类将java.util.Date转换为java.time.LocalDate

java.time包中并没有提供很多的方式来进行直接转换，但是给之前的Date类，Calendar类在java1.8都提供了一个新的方法，叫做toInstant()，

可以将当前对象转换为Instant对象，通过给Instan添加时区信息之后就可以转换为LocalDate对象。

importjava.time.Instant;importjava.time.LocalDate;importjava.time.ZoneId;importjava.time.ZonedDateTime;importjava.util.Date;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 13:14*/

public classJava8DateToLocalDateDemo1 {public static voidmain(String[] args) {//初始化Date()对象

Date d = newDate();//1、将Date()对象转换成Instant对象

Instant i =d.toInstant();//2、Date类包含日期和时间信息，但是不提高时区信息，和Instant一样，通过Instant的anZone()来进行添加时区信息

ZonedDateTime zonedDateTime =i.atZone(ZoneId.systemDefault());//3、通过LocalDate方法转换

LocalDate date =zonedDateTime.toLocalDate();//转换之前Sun May 03 17:21:18 CST 2020

System.out.println("转换之前" +d);//转换之后2020-05-03

System.out.println("转换之后" +date);

}

结果

二十六、java.sql.Date与java.sql.Timestamp的转换方式

java.sql.Date类中提供直接转换为LocalDate的方法,toLocalDate()

java.sql.Timestamp类是时间戳对象，通过传入一个毫秒值对象进行初始化

importjava.sql.Date;importjava.sql.Timestamp;importjava.time.LocalDate;importjava.time.LocalDateTime;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 13:21*/

public classJava8DateToLocalDemo2 {public static voidmain(String[] args) {//初始化 java.sql.Date 对象

Date d = newDate(System.currentTimeMillis());//java.sql.Date 自带了转换成LocalDate 的方法， toLocalDate.

LocalDate date =d.toLocalDate();//转换前的java.sql.Date对象是：2020-05-03

System.out.println("转换前的java.sql.Date对象是：" +d);//转换后的java.time.LocalDate对象是：2020-05-03

System.out.println("转换后的java.time.LocalDate对象是：" +date);//初始化java.sql.Timestamp对象，世界戳对象

Timestamp timestamp = newTimestamp(System.currentTimeMillis());//java.sql.Timestamp 中也自带了转换成LocalDate 的方法 toLocalDate

LocalDateTime localDateTime =timestamp.toLocalDateTime();//转换之前的java.sql.Timestamp对象是：2020-05-03 17:25:29.057

System.out.println("转换之前的java.sql.Timestamp对象是：" +timestamp);//转换之后的java.time.LocalDateTime对象是：2020-05-03T17:25:29.057

System.out.println("转换之后的java.time.LocalDateTime对象是：" +localDateTime);

}

结果

二十七、java.util.Date转换为java.time.LocalDate方式(2)

将java.util.Date类转换为java.time.LocalDate类的第二种方法

java.sql.Date类提供了转换为LocalDate的方法，那么可以将java.util.Date先转换为java.sql.Date。

通过java.sql.Date的构造方法直接传入一个毫秒值可以构造一个java.sql.Date对象，毫秒值可以通过java.util.Date对象的getTime()方法获取到。

importjava.time.LocalDate;importjava.util.Date;/***@authorLiuHuaXiong

* @create 2020-05-03 下午 17:34*/

public classJava8DateToLocalDateDemo4 {public static voidmain(String[] args) {//初始化 Date对象

Date d = newDate();/** java.sql.Date类提供了转换为LocalDate的方法，那么可以将java.util.Date先转换为java.sql.Date

* 通过java.sql.Date提供的方式转换为LocalDate.

* java.sql.Date类构造的时候需要毫秒值， -> java.Util.Date类中提供了一个获取毫秒值的方法, getTime()

**/java.sql.Date date= newjava.sql.Date(d.getTime());

LocalDate localDate=date.toLocalDate();//转换前的java.util.Date对象是：Sun May 03 17:39:46 CST 2020

System.out.println("转换前的java.util.Date对象是：" +d);//转换前的java.sql.Date对象是：2020-05-03

System.out.println("转换前的java.sql.Date对象是：" +date);//转换前的java.time.LocalDate对象是：2020-05-03

System.out.println("转换前的java.time.LocalDate对象是：" +localDate);

}

看结果

二十八、Calendar转换为ZonedDateTime

Calendar对象字Java1.1开始提供了一个方法获取时区对象的方法，getTimeZone()，要将Calendar对象转换为ZonedDateTime需要先获取到时区对象。

从Java1.8开始TimeZone类提供了一个方法可以获取到ZonedId。

获取到ZonedId之后就可以初始化ZOnedDateTime对象了，ZonedDateTime类有一个ofInstant()方法，可以将一个Instant对象和ZonedId对象作为参数传入构造一个ZonedDateTime对象。

importjava.time.ZoneId;importjava.time.ZonedDateTime;importjava.util.Calendar;importjava.util.TimeZone;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 13:47*/

public classJava8TimeCalendarToZoneedDateTimeDemo1 {public static voidmain(String[] args) {//1、初始化一个Calendar对象

Calendar calendar =Calendar.getInstance();//2、Calendar对象自java1.1以后开始提供了一个方法用于获取时区对象getTimeZone()方法，要将Calendar转换为//ZoneedDateTime对象需要先获取到时区对象

TimeZone timeZone =calendar.getTimeZone();//3、从java1.8开始TimeZone类提供了一个方法可以获取到ZoneId -> 拿拿ZoneId对象来构建ZonedDateTime

ZoneId zoneId =timeZone.toZoneId();//4、zonedDateTime类有一个ofInstant方法。可以将Instant对象和ZoneId对象封装为一个ZonedDateTime

ZonedDateTime zonedDateTime =ZonedDateTime.ofInstant(calendar.toInstant(), zoneId);//转换之前的Calendar对象是：java.util.GregorianCalendar[time=1588499141905,areFieldsSet=true,areAll//FieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",.......

System.out.println("转换之前的Calendar对象是：" +calendar);//转换之后的ZonedDateTime对象是：2020-05-03T17:45:41.905+08:00[Asia/Shanghai]

System.out.println("转换之后的ZonedDateTime对象是：" +zonedDateTime);

}

结果

二十九、Calendar转换为LocalDateTime

java.util.Calendar类转换为java.time.LocalDateTime类

Calendar对象可以获取到年月日时分秒的信息，这些信息可以作为LocalDateTime构造方法的参数

importjava.time.LocalDateTime;importjava.util.Calendar;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 14:07*/

public classJava8TimeCalendarToLocalDateTimeDemo1 {public static voidmain(String[] args) {//1、初始化Calendar对象

Calendar calendar =Calendar.getInstance();//2、通过get获取Calendar对象中封装的数据

int year =calendar.get(Calendar.YEAR);int month =calendar.get(Calendar.MONTH);int day =calendar.get(Calendar.DAY_OF_MONTH);int hour =calendar.get(Calendar.HOUR);int minute =calendar.get(Calendar.MINUTE);int second =calendar.get(Calendar.SECOND);//3、将以上获取的六个参数作为LocalDateTime的of方法的参数传递，封装的月份是从0开始的，所以month要加1

LocalDateTime localDateTime = LocalDateTime.of(year, month + 1, day, hour, minute, second);//2020-05-03T05:49:23

System.out.println(localDateTime);

}

结果

三十、新日期实践类的parse和format方法

SimpleDateFormat类在刚开始的时候讲过了是线程不安全的，所以Java8提供了新的格式化类 DateTimeFormatter

dateTimeFormatter类提供了大量预定义格式化器，包括常量(如ISO_LOCAL_DATE)，模式字母(如yyyy-MM-dd)以及本地化样式。

与SimpleDateFormat不同的是，新版本的日期/时间API的格式化与解析不需要再创建转换器对象了，通过时间日期对象的parse/format方法可以直接进行转换.

LocalDate类定义的parse和format方法

importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 14:16*/

public classjava8TimeFormatAndParseDemo1 {public static voidmain(String[] args) {//对LoacalDateTime进行格式化和解析，初始化LocalDateTime对象

LocalDateTime localDateTime =LocalDateTime.now();//localDateTime对象可以直接调用format方法进行格式化

String s1 =localDateTime.format(DateTimeFormatter.ISO_DATE);

String s2=localDateTime.format(DateTimeFormatter.ISO_DATE_TIME);//LocalDateTime:2020-05-03T17:55:04.194526800

System.out.println("LocalDateTime:" +localDateTime);//ISO_DATE:2020-05-03

System.out.println("ISO_DATE:" +s1);//ISO_DATE_TIME:2020-05-03T17:55:04.1945268

System.out.println("ISO_DATE_TIME:" +s2);//解析字符串的方式通过LocalDateTime类的静态方法parse传入需要解析的字符串即可

LocalDateTime parse =LocalDateTime.parse(s2);//2020-05-03T17:55:04.194526800

System.out.println(parse);

}

结果

三十一、ofLocalizedDate方法

对日期进行格式化

通过DateTimeFormatter的ofLocalizedDate的方法也可以调整格式化的方式。

public staticDateTimeFormatter ofLocalizedDate(FormatStyle dateStyle) {

Objects.requireNonNull(dataStyle, message:"dateStyle");return new DateTimeFormatterBuilder().appendLocalized(dateStyle,timeStyle:"null")

.toFormatter(ResolverStyle.Smart, IsoChronology.Instance);

}

此方法需要传入一个FormatStyle类对象，擦好看后发现FormaStyle对象是一个枚举类，其中有几种方式如下：

Full：全显示(年月日+星期) Long：全显示(年月日) Medium：缩略显示(没有年月日汉字) SHORT：精简显示(精简年+月日)

importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;importjava.time.format.FormatStyle;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 14:25*/

public classJava8TimeFormatAndParseDemo2 {public static voidmain(String[] args) {

LocalDateTime localDateTime=LocalDateTime.now();//通过DateTimeFormatter 的 ofLocalizedDate指定解析格式

String r1 =localDateTime.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL));

String r2=localDateTime.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG));

String r3=localDateTime.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM));

String r4=localDateTime.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT));//FULL:2020年5月3日星期日

System.out.println("FULL:" +r1);//LONG:2020年5月3日

System.out.println("LONG:" +r2);//MEDIUM:2020年5月3日

System.out.println("MEDIUM:" +r3);//SHORT:2020/5/3

System.out.println("SHORT:" +r4);

}

结果

三十二、自定义格式化器

除了系统自带的方式之外，也可以通过DateTimeFormatter类提供的ofPattern方式创建自定时格式化器，格式化的写法与之前使用SimpleDateFormat相同。

importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 14:31*/

public classJava8TimeFormatAndParseDemo3 {public static voidmain(String[] args) {

LocalDateTime now=LocalDateTime.now();//通过DateTimeFormatter 提供的ofPattern方法自定义格式化方式

String s = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss:SSS"));//2020/05/03 18:07:44:859

System.out.println(s);

}

结果

三十三、章节练习(4)

importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;/***@authorLiuHuaXiong

* @create 2020-05-02 下午 14:35

* 将1998年3月18日17时19分28秒转换成以下格式： 1998-03月-18---17:19分28秒 -> yyyy-MM月-dd---HH:mm分ss秒*/

public classJava8TimeFormatAndParseTest1 {public static voidmain(String[] args) {//初始化一个LocalDateTime对象

LocalDateTime time = LocalDateTime.of(1998, 3, 18, 17, 19, 28);//通过time 对象的 format方法自定义格式化器完成格式化

String s = time.format(DateTimeFormatter.ofPattern("yyyy-MM月-dd---HH:mm分ss秒"));//1998-03月-18---17:19分28秒

System.out.println(s);

}

结果

作者：XT_fc0f

链接：https://www.jianshu.com/p/7a1b367ae95f

来源：简书

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

weixin_39997400

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA中适合时间的对象_Java8的最新时间类库

十三、plus方法在LocalDate中的使用想要修改某个日期/时间对象的现有实例时，我们可以使用 plus和 minus方法来完成操作。Java8中日期时间相关的API中的所有实例都是不可改变的，一旦创建LocalDate，LocalTime，LocalDateTime就无法修改他们(类似于String)，这对于线程安全时非常有利的。plus方法在LocalDate与LocalTime中的使用L...
复制链接

扫一扫