深入理解Java8新特性之新日期时间API的应用

目录
  • 1.新旧对比(线程安全问题)
  • 2.LocalDate
  • 3.LocalTime
  • 4.LocalDateTime
  • 5.Instant
  • 6.Duration、Period
  • 7.TestTemporalAdjuster、TestTemporalAdjusters
  • 8.DateTimeFormatter

1.新旧对比(线程安全问题)

我们先来看下面的代码:👇👇👇 (关于代码中某些类中的某些方法,我在这里就不说了,大家可以去查找api文档)

package com.szh.java8.datetime;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;

/**
 *
 */
public class TestSimpleDateFormat {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

        Callable<Date> task1 = new Callable<Date>() {
            @Override
            public Date call() throws Exception {
                return sdf.parse("20211109");
            }
        };

        ExecutorService pool1 = Executors.newFixedThreadPool(10);
        List<Future<Date>> futureList1 = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            futureList1.add(pool1.submit(task1));
        }

        for (Future<Date> future : futureList1) {
            System.out.println(future.get());
        }

        pool1.shutdown();

        //=================================================================

//        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");
//
//        Callable<LocalDate> task2 = new Callable<LocalDate>() {
//            @Override
//            public LocalDate call() throws Exception {
//                return LocalDate.parse("20211109",dtf);
//            }
//        };
//
//        ExecutorService pool2 = Executors.newFixedThreadPool(10);
//        List<Future<LocalDate>> futureList2 = new ArrayList<>();
//        for (int i = 0; i < 10; i++) {
//            futureList2.add(pool2.submit(task2));
//        }
//
//        for (Future<LocalDate> future : futureList2) {
//            System.out.println(future.get());
//        }
//
//        pool2.shutdown();
    }
}

运行之后,就出现了线程安全问题。

将代码中的上半部分注释掉,然后打开下半部分的代码,再次运行,线程安全问题就不存在了。

也就是Java8中提供了新一套日期时间API已经解决了线程安全问题。

2.LocalDate

package com.szh.java8.datetime;

import java.time.LocalDate;

/**
 *
 */
public class TestLocalDate {

    public static void main(String[] args) {
        LocalDate ld1 = LocalDate.now();
        System.out.println(ld1);

        LocalDate ld2 = LocalDate.of(2021,5,1);
        System.out.println(ld2);

        LocalDate ld3 = ld1.plusYears(20);
        System.out.println(ld3);

        LocalDate ld4 = ld1.minusMonths(3);
        System.out.println(ld4);

        System.out.println(ld1.isBefore(ld2));
        System.out.println(ld2.isAfter(ld1));
        System.out.println(ld1.isLeapYear());

        System.out.println("年:" + ld1.getYear() + ", 月:" + ld1.getMonth() + ", 日:" + ld1.getDayOfMonth());
        System.out.println("年:" + ld1.getYear() + ", 月:" + ld1.getMonthValue() + ", 日:" + ld1.getDayOfMonth());
    }
}

3.LocalTime

package com.szh.java8.datetime;

import java.time.LocalTime;

/**
 *
 */
public class TestLocalTime {

    public static void main(String[] args) {
        LocalTime lt1 = LocalTime.now();
        System.out.println(lt1);

        LocalTime lt2 = LocalTime.of(13,14,15);
        System.out.println(lt2);

        LocalTime lt3 = lt2.plusHours(3);
        System.out.println(lt3);

        LocalTime lt4 = lt2.minusMinutes(14);
        System.out.println(lt4);

        System.out.println(lt1.isBefore(lt2));
        System.out.println(lt2.isAfter(lt1));
        System.out.println("小时:" + lt1.getHour() + ", 分钟:" + lt1.getMinute() + ", 秒:" + lt1.getSecond());
    }
}

4.LocalDateTime

package com.szh.java8.datetime;

import java.time.LocalDateTime;

/**
 *
 */
public class TestLocalDateTime {

    public static void main(String[] args) {
        LocalDateTime ldt1 = LocalDateTime.now();
        System.out.println(ldt1);

        LocalDateTime ldt2 = LocalDateTime.of(2020,5,1,13,14,15);
        System.out.println(ldt2);

        LocalDateTime ldt3 = ldt1.plusYears(15);
        System.out.println(ldt3);

        LocalDateTime ldt4 = ldt1.minusDays(20);
        System.out.println(ldt4);

        System.out.println(ldt1.isBefore(ldt2));
        System.out.println(ldt2.isAfter(ldt1));
        System.out.println("年:" + ldt2.getYear() + ", 月:" + ldt2.getMonthValue() + ", 日:" + ldt2.getDayOfMonth()
                + ", 小时:" + ldt2.getHour() + ", 分钟:" + ldt2.getMinute() + ", 秒:" + ldt2.getSecond());
    }
}

5.Instant

package com.szh.java8.datetime;

import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;

/**
 * Instant : 时间戳(使用 Unix 元年  1970年1月1日 00:00:00 所经历的毫秒值)
 *           默认使用 UTC 时区
 */
public class TestInstant {

    public static void main(String[] args) {
        Instant instant1 = Instant.now();
        System.out.println(instant1);

        OffsetDateTime odt = instant1.atOffset(ZoneOffset.ofHoursMinutesSeconds(8,16,32));
        System.out.println(odt);

        System.out.println(instant1.getEpochSecond());
        System.out.println(instant1.toEpochMilli());

        Instant instant2 = Instant.ofEpochSecond(1000);
        System.out.println(instant2);

        Instant instant3 = instant1.plusSeconds(30);
        System.out.println(instant3);

        Instant instant4 = instant1.minusSeconds(50);
        System.out.println(instant4);
    }
}

6.Duration、Period

package com.szh.java8.datetime;

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Period;

/**
 * Period : 用于计算两个“日期”间隔
 * Duration : 用于计算两个“时间”间隔
 */
public class TestPeriodDuration {

    public static void main(String[] args) {
        LocalDate ld1 = LocalDate.now();
        LocalDate ld2 = LocalDate.of(2020,5,1);
        Period period = Period.between(ld2,ld1);
        System.out.println("两个日期相差:" + period.getYears() + "年," + period.getMonths() + "个月,"
                            + period.getDays() + "天....");
        System.out.println(period.isNegative()); //检查此期间的三个单位是否为负
        System.out.println(period.isZero()); //检查此期间的所有三个单位是否为零

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

        LocalTime lt1 = LocalTime.now();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LocalTime lt2 = LocalTime.now();
        Duration duration = Duration.between(lt1,lt2);
        System.out.println("两个时间相差:" + duration.toHours() + "个小时," + duration.toMinutes() + "分钟,"
                            + duration.getSeconds() + "秒....");
        System.out.println(duration.isNegative()); //检查此期间的三个单位是否为负
        System.out.println(duration.isZero()); //检查此期间的所有三个单位是否为零
    }
}

7.TestTemporalAdjuster、TestTemporalAdjusters

package com.szh.java8.datetime;

import java.time.DayOfWeek;
import java.time.LocalDateTime;
import java.time.temporal.TemporalAdjusters;

/**
 *  TemporalAdjuster : 时间校正器。有时我们可能需要获取例如:将日期调整到“下个周日”等操作。
 *  TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。
 */
public class TestTemporalAdjuster {

    public static void main(String[] args) {
        LocalDateTime ldt1 = LocalDateTime.now();
        System.out.println(ldt1);

        LocalDateTime ldt2 = ldt1.withMonth(5);
        System.out.println(ldt2);

        LocalDateTime ldt3 = ldt1.with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
        System.out.println(ldt3);

        //自定义:下一个工作日
        LocalDateTime ldt4 = ldt1.with((l) -> {
            LocalDateTime ldt5 = (LocalDateTime) l;
            DayOfWeek dow = ldt5.getDayOfWeek();

            if (dow.equals(DayOfWeek.FRIDAY)) {
                return ldt5.plusDays(3);
            } else if (dow.equals(DayOfWeek.SATURDAY)) {
                return ldt5.plusDays(2);
            } else {
                return ldt5.plusDays(1);
            }
        });
        System.out.println(ldt4);
    }
}

8.DateTimeFormatter

package com.szh.java8.datetime;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * 解析与格式化
 */
public class TestDateTimeFormatter {

    public static void main(String[] args) {
        DateTimeFormatter dtf1 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        LocalDateTime ldt1 = LocalDateTime.now();

        String strDate1 = ldt1.format(dtf1);
        System.out.println(strDate1);

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

        DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        String strDate2 = ldt1.format(dtf2);
        System.out.println(strDate2);

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

        LocalDateTime newDate = ldt1.parse(strDate2, dtf2);
        System.out.println(newDate);
    }
}

以上就是深入理解Java8新特性之新日期时间API的应用的详细内容,更多关于Java 日期时间API的资料请关注我们其它相关文章!

(0)

相关推荐

  • Java8新特性时间日期库DateTime API及示例详解

    Java8新特性的功能已经更新了不少篇幅了,今天重点讲解时间日期库中DateTime相关处理.同样的,如果你现在依旧在项目中使用传统Date.Calendar和SimpleDateFormat等API来处理日期相关操作,这篇文章你一定不要错过.来刷新你的知识库吧! 背景 Java对日期.日历及时间的处理一直以来都饱受诟病,比如java.util.Date和java.util.Calendar类易用性差,不支持时区,非线程安全:还有用于格式化日期的类DateFormat也是非线程安全的等问题. J

  • java8新特性之日期时间API

    jdk8之前 一.java.lang.System long times = System.currentTimeMillis(); //返回的是当前时间与1970年1月1月1日0分0秒之间以毫秒为单位的时间差 //称为时间戳 System.out.println(times); 二.java.util.Date And java.sql.Date 将java.util.Date 对象转换为java.sql.Date对象: //将java.util.Date 对象转换为java.sql.Date

  • Java编程时间日期API实例解析

    本文实例主要是关于Java8中的新特性,时间日期api的相关实例,具体如下: package com.effective.common.base.date; import java.time.Instant; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.time.Period; import java.time.ZoneId; import

  • Java 日期与时间API相关用法总结

    一.时间和日期 在系统开发中,日期与时间作为重要的业务因素,起到十分关键的作用,例如同一个时间节点下的数据生成,基于时间范围的各种数据统计和分析,集群节点统一时间避免超时等. 在时间和日期中有几个关键概念: 日期:通常年月日的组合表示当前日期. 时间:通常时分秒的组合表示当前时间. 时区:世界各国家与地区经度不同,划分24个标准时区,相邻时区的时间相差一个小时. 时间戳:从UTC时间的1970-1-1 00:00:00起到现在的总秒数. 日期和时间的用法在系统中通常是获取时间和一些常见的计算与格

  • Java8新日期时间API的20个使用示例

    除了lambda表达式,stream以及几个小的改进之外,Java 8还引入了一套全新的时间日期API,在本篇教程中我们将通过几个简单的任务示例来学习如何使用Java 8的这套API.Java对日期,日历及时间的处理一直以来都饱受诟病,尤其是它决定将java.util.Date定义为可修改的以及将SimpleDateFormat实现成非线程安全的.看来Java已经意识到需要为时间及日期功能提供更好的支持了,这对已经习惯使用Joda时间日期库的社区而言也是件好事.关于这个新的时间日期库的最大的优点

  • Java中的时间日期API知识点总结

    自从 14 年发布 Java 8 以后,我们古老 java.util.Date 终于不再是我们 Java 里操作日期时间的唯一的选择. 其实 Java 里的日期时间的相关 API 一直为世猿诟病,不仅在于它设计分上工不明确,往往一个类既能处理日期又能处理时间,很混乱,还在于某些年月日期的数值映射存储反人类,例如:0 对应月份一月,11 对应月份十二月,118 对应年份 2018(1900 + 118)等. 往往我们得到某个年月值还需要再做相应的运算才能得到准确的年月日信息,直到我们的 Java

  • 深入理解Java8新特性之新日期时间API的应用

    目录 1.新旧对比(线程安全问题) 2.LocalDate 3.LocalTime 4.LocalDateTime 5.Instant 6.Duration.Period 7.TestTemporalAdjuster.TestTemporalAdjusters 8.DateTimeFormatter 1.新旧对比(线程安全问题) 我们先来看下面的代码:

  • Java8新特性之新日期时间库的使用教程

    一.为什么引入新的日期时间库 Java对日期,日历及时间的处理一直以来都饱受诟病,尤其是它决定将java.util.Date定义为可修改的以及将SimpleDateFormat实现成非线程安全的. 关于这个新的时间日期库的最大的优点就在于它定义清楚了时间日期相关的一些概念,比方说,瞬时时间(Instant),持续时间(duration),日期(date),时间(time),时区(time-zone)以及时间段(Period).同时它也借鉴了Joda库的一些优点,比如将人和机器对时间日期的理解区分

  • 揭秘PowerShell 5.0新特性和新功能

    Windows PowerShell 5.0中包含了大量的新特性和新功能,提升了整体的用户体验.虽然其中一些功能只能供硬核PowerShell开发人员使用,但其他新功能和特性具有广泛的适用性. 例如其中一个新功能是远程文件编辑.管理员暂时可以通过PowerShell建立与另一个Windows服务器的远程会话.新的远程文件编辑功能在此基础之上进行构建,从而能够建立一个远程会话,然后在远程计算机上编辑文件. 建立远程会话的方法通常相同.你可以使用Enter-PSSession命令,附上–Comput

  • JavaScript ES6的新特性使用新方法定义Class

    ES6(ECMAScript 6)是即将到来的新版本JavaScript语言的标准,代号harmony(和谐之意,显然没有跟上我国的步伐,我们已经进入中国梦版本了).上一次标准的制订还是2009年出台的ES5.目前ES6的标准化工作正在进行中,预计会在14年12月份放出正式敲定的版本.但大部分标准已经就绪,且各浏览器对ES6的支持也正在实现中. ES6中定义类的方式, 就是ES3和ES5中定义类的语法糖,虽然也有些区别,但是整体定义类的方式更加简洁,类的继承更加方便, 如果想对ES6中的继承更加

  • Java8新特性Optional类及新时间日期API示例详解

    目录 Optional类 以前对null的处理 Optional类介绍 Optional的基本使用 Optional的常用方法 新时间日期API 旧版日期时间的问题 新日期时间API介绍 日期时间的常见操作 日期时间的修改和比较 格式化和解析操作 Instant类 计算日期时间差 时间校正器 日期时间的时区 JDK新的日期和时间API的优势 Optional类 面试官:Optional类了解过吗? 这个Optional类主要是解决空指针的问题. 以前对null的处理 @Test public v

  • 浅析JDK12的五大重要新特性(推荐)

    JDK12的五大重要新特性 Java12在March 19, 2019发布了. 在2017年发布Java 9之后,Java平台发布节奏已从每3年以上的主要版本转变为每6个月发布一次功能.现在,每年的3月和9月都会发布新的版本功能. 从而提供了更细化,更快和可管理的版本更新. 这是一个好消息,不好的就是大家会觉得JDK的版本更新太快了. 什么?JDK12已经出来了? 什么?9月份要出JDK13了? 什么?我还在用JDK8? 废话少说,我们来看下JDK12的五个比较重要的新特性: 引入JVM常量AP

  • JDK19新特性使用实例详解

    目录 前提 新特性列表 新特性使用详解 Record模式 Linux/RISC-V移植 外部函数和内存API 虚拟线程 向量API switch匹配模式 结构化并发 前提 JDK19于2022-09-20发布GA版本,本文将会详细介绍JDK19新特性的使用. 新特性列表 新特性列表如下: JPE-405:Record模式(预览功能) JPE-422:JDK移植到Linux/RISC-V JPE-424:外部函数和内存API(预览功能) JPE-425:虚拟线程,也就是协程(预览功能) JPE-4

  • iOS开发之路--微博新特性页面

    BeyondAppDelegate.m // // BeyondAppDelegate.m // 20_帅哥no微博 // // Created by beyond on 14-8-3. // Copyright (c) 2014年 com.beyond. All rights reserved. // #import "BeyondAppDelegate.h" #import "BeyondViewController.h" #import "NewFe

随机推荐