Java-日期时间API（详解）

悠悠 2023-09-28 22:39 143阅读 0赞

### 日期时间API ###

*  前言
 *  一、JDK8之前日期时间API
 *   *  1、java.lang.System类
     *   *  1.1 概述
         *  1.2 注意
     *  2、java.util.Date类
     *   *  2.1 概述
         *  2.2 两个构造器的使用
         *  2.3 常用方法
         *  2.4 代码演示
     *  3、java.sql.Date类
     *   *  3.1 概述
         *  3.2 代码演示
     *  4. java.text.SimpleDateFormat类
     *   *  4.1 概述
         *  4.2 格式化与解析
         *  4.3 练习
     *  5、Calendar日历类(抽象类）
     *   *  5.1 概述
         *  5.2 实例化
         *  5.3 方法
 *  二、 JDK8中新日期时间API
 *   *  1、新日期时间API出现的背景
     *  2、新时间日期API
     *  3、LocalDate、LocalTime、LocalDateTime 类
     *   *  3.1 概述
         *  3.2 方法
         *  3.3 代码演示
     *  4、Instant类
     *   *  4.1 特性
         *  4.2 方法
         *  4.3 代码演示
     *  5、java.time.format.DateTimeFormatter 类
     *   *  5.1 概述
         *  5.2 方法
         *  5.3 代码演示
     *  6、其它API
     *   *  6.1 概述
         *  6.2 代码演示

--------------------

# 前言 #

本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！  
也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！让我们在成长的道路上互相学习，欢迎关注！

分享ChatGPT的相关资料文档、最新资讯、玩法和创意，获取第一手信息，一起走在AI时代的最前线！前100名加入可赠送ChatGPT账号！

加入链接：[https://t.zsxq.com/0cStvoskD][https_t.zsxq.com_0cStvoskD]

# 一、JDK8之前日期时间API #

## 1、java.lang.System类 ##

### 1.1 概述 ###

> `System`类提供的`public static long currentTimeMillis()`用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

**代码演示：**

@Test
        public void test1(){
          
            long time = System.currentTimeMillis();
            //返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
            //称为时间戳
            System.out.println(time);//1645835914706
        }
    }

### 1.2 注意 ###

> ⭕ 此方法适于计算时间差。

> ⭕ 计算世界时间的主要标准有：
> 
> 1.  `UTC(Coordinated Universal Time)`
> 2.  `GMT(Greenwich Mean Time)`
> 3.  `CST(Central Standard Time)`

## 2、java.util.Date类 ##

### 2.1 概述 ###

> 表示特定的瞬间，精确到毫秒

### 2.2 两个构造器的使用 ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>构造器</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>Date()</code></td> 
   <td>创建一个对应当前时间的<code>Date</code>对象</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>Date(long date)</code></td> 
   <td>创建指定毫秒数的<code>Date</code>对象</td> 
  </tr> 
 </tbody> 
</table>

### 2.3 常用方法 ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>toString()</code></td> 
   <td>把此 Date 对象转换为以下形式的 <code>String： dow mon dd hh:mm:ss zzz yyyy</code>，显示当前的年、月、日、时、分、秒 。 其中： <code>dow</code> 是一周中的某一天 (<code>Sun</code>, <code>Mon</code>, <code>Tue</code>, <code>Wed</code>, <code>Thu</code>, <code>Fri</code>, <code>Sat</code>)，<code>zzz</code>是时间标准</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>getTime()</code></td> 
   <td>返回自 <font>1970 年 1 月 1 日 00:00:00 GMT</font> 以来此 <code>Date</code> 对象表示的毫秒数（时间戳）。</td> 
  </tr> 
 </tbody> 
</table>

> 注意：其它很多方法都过时了

### 2.4 代码演示 ###

@Test
        public void test1() {
          
            //构造器一：Date()：创建一个对应当前时间的Date对象
            Date date1 = new Date();
            System.out.println(date1.toString());//Sat Feb 26 08:45:48 CST 2022
    
            System.out.println(date1.getTime());//1645836348270
    
            //构造器二：创建指定毫秒数的Date对象
            Date date2 = new Date(155030620410L);
            System.out.println(date2.toString());//Sat Nov 30 16:03:40 CST 1974
            System.out.println(date2.getTime());//155030620410
        }
    }

## 3、java.sql.Date类 ##

### 3.1 概述 ###

> `java.sql.Date`类为`java.util.Date`类的子类，为数据库的日期类型。

### 3.2 代码演示 ###

@Test
           public void test1(){
          
            //创建java.sql.Date对象
            java.sql.Date date3 = new java.sql.Date(35235325345L);
            System.out.println(date3);//1971-02-13
    
            //如何将java.util.Date对象转换为java.sql.Date对象
            //情况一：
            Date date4 = new java.sql.Date(2343243242323L);
            java.sql.Date date5 = (java.sql.Date) date4;
            //情况二：
            Date date6 = new Date();
            java.sql.Date date7 = new java.sql.Date(date6.getTime());
        }

## 4. java.text.SimpleDateFormat类 ##

### 4.1 概述 ###

> ⭕ `Date`类的`API`不易于国际化，大部分被废弃了。

> ⭕ `java.text.SimpleDateFormat`类是一个不与语言环境有关的方式来格式化和解析日期的具体类。

> ⭕ 它允许进行格式化：日期–>文本、解析：文本–>日期

### 4.2 格式化与解析 ###

> ⭕ 格式化：日期 —>字符串

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>构造器</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>SimpleDateFormat()</td> 
   <td>默认的模式和语言环境创建对象</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>public SimpleDateFormat(String pattern)</td> 
   <td>该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用public String format(Date date)方法格式化时间对象date</td> 
  </tr> 
 </tbody> 
</table>

> ⭕ 解析：格式化的逆过程，字符串 —> 日期

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>构造器</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public Date parse(String source)</code></td> 
   <td>从给定字符串的开始解析文本，以生成一个日期</td> 
  </tr> 
 </tbody> 
</table>

**代码演示：**

@Test
        public void testSimpleDateFormat() throws ParseException {
          
            //实例化SimpleDateFormat:使用默认的构造器
            SimpleDateFormat sdf = new SimpleDateFormat();
    
            //格式化：日期 --->字符串
            Date date = new Date();
            System.out.println(date);
    
            String format = sdf.format(date);
            System.out.println(format);
    
            //解析：格式化的逆过程，字符串 ---> 日期
            String str = "19-12-18 上午11:43";
            Date date1 = sdf.parse(str);
            System.out.println(date1);
    
            //*************按照指定的方式格式化和解析：调用带参的构造器*****************
    //        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            //格式化
            String format1 = sdf1.format(date);
            System.out.println(format1);//2019-02-18 11:48:27
            //解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),
            //否则，抛异常
            Date date2 = sdf1.parse("2020-02-18 11:48:27");
            System.out.println(date2);
       }

### 4.3 练习 ###

/**
    *练习二："三天打渔两天晒网"   1990-01-01  xxxx-xx-xx 打渔？晒网？
    *举例：2020-09-08 ？ 总天数
    
    
        总天数 % 5 == 1,2,3 : 打渔
        总天数 % 5 == 4,0 : 晒网
    
        总天数的计算？
        方式一：( date2.getTime() - date1.getTime()) / (1000 * 60 * 60 * 24) + 1
        方式二：1990-01-01  --> 2019-12-31  +  2020-01-01 -->2020-09-08
    */
        @Test
        public void testExer() throws ParseException {
          
            String birth = "2020-09-08";
    
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf1.parse(birth);
    //        System.out.println(date);
    
            java.sql.Date birthDate = new java.sql.Date(date.getTime());
            System.out.println(birthDate);
        }

## 5、Calendar日历类(抽象类） ##

### 5.1 概述 ###

> `Calendar`是一个抽象基类，主用用于完成日期字段之间相互操作的功能。

### 5.2 实例化 ###

> ⭕ 使用`Calendar.getInstance()`方法。

> ⭕ 调用它的子类`GregorianCalendar`的构造器。

### 5.3 方法 ###

> 一个`Calendar`的实例是系统时间的抽象表示，通过`get(int field)`方法来取得想要的时间信息。比如`YEAR`、`MONTH`、`DAY_OF_WEEK`、`HOUR_OF_DAY` 、`MINUTE`、`SECOND`。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public void set(int field,int value)</code></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public void add(int field,int amount)</code></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public final Date getTime()</code></td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>public final void setTime(Date date)</code></td> 
  </tr> 
 </tbody> 
</table>

注意:

> ⭕ 获取月份时：一月是0，二月是1，以此类推，12月是11   
> ⭕ 获取星期时：周日是1，周二是2 ， …周六是7

**代码演示：**

@Test
        public void testCalendar(){
          
            //1.实例化
            //方式一：创建其子类（GregorianCalendar）的对象
            //方式二：调用其静态方法getInstance()
            Calendar calendar = Calendar.getInstance();
    //        System.out.println(calendar.getClass());
    
            //2.常用方法
            //get()
            int days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
            System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
    
            //set()
            //calendar可变性
            calendar.set(Calendar.DAY_OF_MONTH,22);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
    
            //add()
            calendar.add(Calendar.DAY_OF_MONTH,-3);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
    
            //getTime():日历类---> Date
            Date date = calendar.getTime();
            System.out.println(date);
    
            //setTime():Date ---> 日历类
            Date date1 = new Date();
            calendar.setTime(date1);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
        }
    }

# 二、 JDK8中新日期时间API #

## 1、新日期时间API出现的背景 ##

> `JDK 1.0`中包含了一个`java.util.Date`类，但是它的大多数方法已经在`JDK1.1`引入`Calendar`类之后被弃用了。而`Calendar`并不比`Date`好多少。它们面临的问题是：  
> ⭕ 可变性：像日期和时间这样的类应该是不可变的。  
> ⭕ 偏移性：`Date`中的年份是从1900开始的，而月份都从0开始。  
> ⭕ 格式化：格式化只对`Date`有用，`Calendar`则不行。  
> ⭕ 它们也不是线程安全的；不能处理闰秒等。  
> 总结：对日期和时间的操作一直是Java程序员最痛苦的地方之一。

**代码演示：**

Date date1 = new Date(2020 - 1900,9 - 1,8);
     System.out.println(date1);//Tue Sep 08 00:00:00 GMT+08:00 2020

## 2、新时间日期API ##

> `Java 8` 吸收了Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。  
> 新的 `java.time`中包含了所有关于本地日期（`LocalDate`）、本地时（`LocalTime`）、本地日期时间（`LocalDateTime`）、时区（`ZonedDateTime`）和持续时间（`Duration`）的类。  
> 历史悠久的 `Date` 类新增了 `toInstant()` 方法， 用于把 `Date`转换成新的表示形式。这些新增的本地化时间日期 `API` 大大简 化了日期时间和本地化的管理。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>包名</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>java.time</code></td> 
   <td>包含值对象的基础包</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>java.time.chrono</code></td> 
   <td>提供对不同的日历系统的访问</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>java.time.format</code></td> 
   <td>格式化和解析时间和日期</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>java.time.temporal</code></td> 
   <td>包括底层框架和扩展特性</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>java.time.zone</code></td> 
   <td>包含时区支持的类</td> 
  </tr> 
 </tbody> 
</table>

> 说明：大多数开发者只会用到基础包和`format`包，也可能会用到`temporal`包。因此，尽管有68个新的公开类型，大多数开发者，大概将只会用到其中的三分之一。

## 3、LocalDate、LocalTime、LocalDateTime 类 ##

### 3.1 概述 ###

> ⭕ `LocalDate`、`LocalTime`、`LocalDateTime` 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

> ⭕ `LocalDate`代表`IOS`格式（`yyyy-MM-dd`）的日期,可以存储 生日、纪念日等日期。

> ⭕ `LocalTime`表示一个时间，而不是日期。

> ⭕ `LocalDateTime`是用来表示日期和时间的，这是一个最常用的类之一。

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

### 3.2 方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>now() / now(ZoneId zone)</code></td> 
   <td>静态方法，根据当前时间创建对象/指定时区的对象</td> 
  </tr> 
  <tr> 
   <td><code>of()</code></td> 
   <td>静态方法，根据指定日期/时间创建对象</td> 
  </tr> 
  <tr> 
   <td><code>getDayOfMonth()/getDayOfYear()</code></td> 
   <td>获得月份天数(1-31) /获得年份天数(1-366)</td> 
  </tr> 
  <tr> 
   <td><code>getDayOfWeek()</code></td> 
   <td>获得星期几(返回一个 DayOfWeek 枚举值)</td> 
  </tr> 
  <tr> 
   <td><code>getMonth()</code></td> 
   <td>获得月份, 返回一个 Month 枚举值</td> 
  </tr> 
  <tr> 
   <td><code>getMonthValue() / getYear()</code></td> 
   <td>获得月份(1-12) /获得年份</td> 
  </tr> 
  <tr> 
   <td><code>getHour()/getMinute()/getSecond()</code></td> 
   <td>获得当前对象对应的小时、分钟、秒</td> 
  </tr> 
  <tr> 
   <td><code>withDayOfMonth( )</code></td> 
   <td>将月份天数修改为指定的值并返回新的对象</td> 
  </tr> 
  <tr> 
   <td><code>withDayOfYear()</code></td> 
   <td>将年份天数修改为指定的值并返回新的对象</td> 
  </tr> 
  <tr> 
   <td><code>withMonth()</code></td> 
   <td>将月份修改为指定的值并返回新的对象</td> 
  </tr> 
  <tr> 
   <td><code>withYear()</code></td> 
   <td>将年份修改为指定的值并返回新的对象</td> 
  </tr> 
  <tr> 
   <td><code>plusDays()</code></td> 
   <td>向当前对象添加几天</td> 
  </tr> 
  <tr> 
   <td><code>plusWeeks()</code></td> 
   <td>向当前对象添加几周</td> 
  </tr> 
  <tr> 
   <td><code>plusMonths()</code></td> 
   <td>向当前对象添加几个月</td> 
  </tr> 
  <tr> 
   <td><code>plusYears()</code></td> 
   <td>向当前对象添加几年</td> 
  </tr> 
  <tr> 
   <td><code>plusHours()</code></td> 
   <td>向当前对象添加几小时</td> 
  </tr> 
  <tr> 
   <td><code>minusMonths()</code></td> 
   <td>从当前对象减去几月</td> 
  </tr> 
  <tr> 
   <td><code>minusWeeks()</code></td> 
   <td>从当前对象减去几周</td> 
  </tr> 
  <tr> 
   <td><code>minusDays()</code></td> 
   <td>从当前对象减去几天</td> 
  </tr> 
  <tr> 
   <td><code>minusYears()</code></td> 
   <td>从当前对象减去几年</td> 
  </tr> 
  <tr> 
   <td><code>minusHours()</code></td> 
   <td>从当前对象减去几小时</td> 
  </tr> 
 </tbody> 
</table>

### 3.3 代码演示 ###

@Test
        public void test1(){
          
            //now():获取当前的日期、时间、日期+时间
            LocalDate localDate = LocalDate.now();
            LocalTime localTime = LocalTime.now();
            LocalDateTime localDateTime = LocalDateTime.now();
    
            System.out.println(localDate);
            System.out.println(localTime);
            System.out.println(localDateTime);
    
            //of():设置指定的年、月、日、时、分、秒。没有偏移量
            LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
            System.out.println(localDateTime1);
    
    
            //getXxx()：获取相关的属性
            System.out.println(localDateTime.getDayOfMonth());
            System.out.println(localDateTime.getDayOfWeek());
            System.out.println(localDateTime.getMonth());
            System.out.println(localDateTime.getMonthValue());
            System.out.println(localDateTime.getMinute());
    
            //体现不可变性
            //withXxx():设置相关的属性
            LocalDate localDate1 = localDate.withDayOfMonth(22);
            System.out.println(localDate);
            System.out.println(localDate1);
    
    
            LocalDateTime localDateTime2 = localDateTime.withHour(4);
            System.out.println(localDateTime);
            System.out.println(localDateTime2);
    
            //不可变性
            LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
            System.out.println(localDateTime);
            System.out.println(localDateTime3);
    
            LocalDateTime localDateTime4 = localDateTime.minusDays(6);
            System.out.println(localDateTime);
            System.out.println(localDateTime4);
        }

## 4、Instant类 ##

### 4.1 特性 ###

> ⭕ `Instant`：时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳。

> ⭕ 在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位。

> ⭕ `java.time`包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。因为`java.time`包是基于纳秒计算的，所以`Instant`的精度可以达到纳秒级。

> ⭕ (1 ns = 10-9 s) 1秒 = 1000毫秒 =106微秒=109纳秒

### 4.2 方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>now()</code></td> 
   <td>静态方法，返回默认<code>UTC</code>时区的<code>Instant</code>类的对象</td> 
  </tr> 
  <tr> 
   <td><code>ofEpochMilli(long epochMilli)</code></td> 
   <td>静态方法，返回在<font>1970-01-01 00:00:00</font>基础上加上指定毫秒数之后的<code>Instant</code>类的对象</td> 
  </tr> 
  <tr> 
   <td><code>atOffset(ZoneOffset offset)</code></td> 
   <td>结合即时的偏移来创建一个 <code>OffsetDateTime</code></td> 
  </tr> 
  <tr> 
   <td><code>toEpochMilli()</code></td> 
   <td>返回1970-01-01 00:00:00到当前时间的毫秒数，即为时间戳</td> 
  </tr> 
 </tbody> 
</table>

> 时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。

### 4.3 代码演示 ###

@Test
        public void test2(){
          
            //now():获取本初子午线对应的标准时间
            Instant instant = Instant.now();
            System.out.println(instant);//2019-02-18T07:29:41.719Z
    
            //添加时间的偏移量
            OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
            System.out.println(offsetDateTime);//2019-02-18T15:32:50.611+08:00
    
            //toEpochMilli():获取自1970年1月1日0时0分0秒（UTC）开始的毫秒数  ---> Date类的getTime()
            long milli = instant.toEpochMilli();
            System.out.println(milli);
    
            //ofEpochMilli():通过给定的毫秒数，获取Instant实例  -->Date(long millis)
            Instant instant1 = Instant.ofEpochMilli(1550475314878L);
            System.out.println(instant1);
        }

## 5、java.time.format.DateTimeFormatter 类 ##

### 5.1 概述 ###

> 该类提供了三种格式化方法：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>格式化类别</th> 
   <th>例子</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>预定义的标准格式</td> 
   <td><code>ISO_LOCAL_DATE_TIME</code>;<code>ISO_LOCAL_DATE</code>;<code>ISO_LOCAL_TIME</code></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>本地化相关的格式</td> 
   <td><code>ofLocalizedDateTime(FormatStyle.LONG)</code></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>自定义的格式</td> 
   <td><code>ofPattern(“yyyy-MM-dd hh:mm:ss”)</code></td> 
  </tr> 
 </tbody> 
</table>

### 5.2 方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方 法</th> 
   <th>描 述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>ofPattern(String pattern)</code></td> 
   <td>静态方法 ， 返 回 一 个 指 定 字 符 串 格 式 的</td> 
  </tr> 
  <tr> 
   <td><code>format(TemporalAccessor t)</code></td> 
   <td>格式化一个日期、时间，返回字符串</td> 
  </tr> 
  <tr> 
   <td><code>parse(CharSequence text)</code></td> 
   <td>将指定格式的字符序列解析为一个日期、时间</td> 
  </tr> 
 </tbody> 
</table>

### 5.3 代码演示 ###

@Test
        public void test1(){
          
    //        方式一：预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
            DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
            //格式化:日期-->字符串
            LocalDateTime localDateTime = LocalDateTime.now();
            String str1 = formatter.format(localDateTime);
            System.out.println(localDateTime);
            System.out.println(str1);//2019-02-18T15:42:18.797
    
            //解析：字符串 -->日期
            TemporalAccessor parse = formatter.parse("2019-02-18T15:42:18.797");
            System.out.println(parse);
    
    //        方式二：
    //        本地化相关的格式。如：ofLocalizedDateTime()
    //        FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
            DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
            //格式化
            String str2 = formatter1.format(localDateTime);
            System.out.println(str2);//2019年2月18日 下午03时47分16秒
    
    
    //      本地化相关的格式。如：ofLocalizedDate()
    //      FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
            DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
            //格式化
            String str3 = formatter2.format(LocalDate.now());
            System.out.println(str3);//2019-2-18
    
    
    //       重点： 方式三：自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
            DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
            //格式化
            String str4 = formatter3.format(LocalDateTime.now());
            System.out.println(str4);//2019-02-18 03:52:09
    
            //解析
            TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
            System.out.println(accessor);
    
        }
    
    }

## 6、其它API ##

### 6.1 概述 ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>API</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>ZoneId</code></td> 
   <td>该类中包含了所有的时区信息，一个时区的ID，如 <code>Europe/Paris</code></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>ZonedDateTime</code></td> 
   <td>一个在<code>ISO-8601</code>日历系统时区的日期时间，如 2007-12-03T10:15:30+01:00 Europe/Paris。其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如： Asia/Shanghai等</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>Clock</code></td> 
   <td>使用时区提供对当前即时、日期和时间的访问的时钟。 ① 持续时间：<code>Duration</code>，用于计算两个“时间”间隔 ②日期间隔：<code>Period</code>，用于计算两个“日期”间隔</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>TemporalAdjuster</code></td> 
   <td>时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>TemporalAdjusters</code></td> 
   <td>该类通过静态方法 (<code>firstDayOfXxx()/lastDayOfXxx()/nextXxx()</code>)提供了大量的常用 <code>TemporalAdjuster</code>的实现。</td> 
  </tr> 
 </tbody> 
</table>

### 6.2 代码演示 ###

//ZoneId:类中包含了所有的时区信息
    // ZoneId的getAvailableZoneIds():获取所有的ZoneId
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    for (String s : zoneIds) {
          
    System.out.println(s);
    }
    // ZoneId的of():获取指定时区的时间
    LocalDateTime localDateTime = LocalDateTime.now(ZoneId.of("Asia/Tokyo"));
    System.out.println(localDateTime);
    //ZonedDateTime:带时区的日期时间
    // ZonedDateTime的now():获取本时区的ZonedDateTime对象
    ZonedDateTime zonedDateTime = ZonedDateTime.now();
    System.out.println(zonedDateTime);
    // ZonedDateTime的now(ZoneId id):获取指定时区的ZonedDateTime对象
    ZonedDateTime zonedDateTime1 = ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
    System.out.println(zonedDateTime1);
    
    //Duration:用于计算两个“时间”间隔，以秒和纳秒为基准
    LocalTime localTime = LocalTime.now();
    LocalTime localTime1 = LocalTime.of(15, 23, 32);
    //between():静态方法，返回Duration对象，表示两个时间的间隔
    Duration duration = Duration.between(localTime1, localTime);
    System.out.println(duration);
    System.out.println(duration.getSeconds());
    System.out.println(duration.getNano());
    LocalDateTime localDateTime = LocalDateTime.of(2016, 6, 12, 15, 23, 32);
    LocalDateTime localDateTime1 = LocalDateTime.of(2017, 6, 12, 15, 23, 32);
    Duration duration1 = Duration.between(localDateTime1, localDateTime);
    System.out.println(duration1.toDays());
    
    //Period:用于计算两个“日期”间隔，以年、月、日衡量
    LocalDate localDate = LocalDate.now();
    LocalDate localDate1 = LocalDate.of(2028, 3, 18);
    Period period = Period.between(localDate, localDate1);
    System.out.println(period);
    System.out.println(period.getYears());
    System.out.println(period.getMonths());
    System.out.println(period.getDays());
    Period period1 = period.withYears(2);
    System.out.println(period1);
    9.3 JDK8中新日期时间API
    // TemporalAdjuster:时间校正器
    // 获取当前日期的下一个周日是哪天？
    TemporalAdjuster temporalAdjuster = TemporalAdjusters.next(DayOfWeek.SUNDAY);
    LocalDateTime localDateTime = LocalDateTime.now().with(temporalAdjuster);
    System.out.println(localDateTime);
    // 获取下一个工作日是哪天？
    LocalDate localDate = LocalDate.now().with(new TemporalAdjuster() {
          
    @Override
    public Temporal adjustInto(Temporal temporal) {
          
    LocalDate date = (LocalDate) temporal;
    if (date.getDayOfWeek().equals(DayOfWeek.FRIDAY)) {
          
    return date.plusDays(3);
    } else if (date.getDayOfWeek().equals(DayOfWeek.SATURDAY)) {
          
    return date.plusDays(2);
    } else {
          
    return date.plusDays(1);
    } }
    });
    System.out.println("下一个工作日是：" + localDate);
    
    java.time.format.DateTimeFormatter与
    java.text.DateFormat formatter.toFormat() 无

[https_t.zsxq.com_0cStvoskD]: https://t.zsxq.com/0cStvoskD