JDK7以前的时间类

18时间类2

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。

  第一个构造函数使用当前日期和时间来初始化对象。

Date( )

  第二个构造函数接收一个参数，该参数是从 1970 年 1 月 1 日起的毫秒数。

Date(long millisec)

Date 对象创建以后，可以调用下面的方法。

获取当前日期时间

   public static void main(String[] args) {
       // 初始化 Date 对象
       Date date = new Date();
       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());
   }

使用 SimpleDateFormat 格式化日期

  一、SimpleDateFormat的作用

    1.格式化：将时间转成指定格式

      如yyyy-MM-dd HH:mm:ss

    2.解析：把字符串表示的时间变成Date对象

   public static void main(String[] args) {
   //作用1
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss  EEE");
        System.out.println(sdf1.format(date));
   //作用2
        String time = "2023-11-11  11:11:11";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf2.parse(time));
   }

二、日期和时间的格式化编码

时间模式字符串用来指定时间格式。在此模式中，所有的 ASCII 字母被保留为模式字母，定义如下：

三、使用printf格式化日期

printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

在printf中输出日期

              /*** 输出日期类型***/
              // %t表示格式化日期时间类型，%T是时间日期的大写形式，在%t之后用特定的字母表示不同的输出格式
              Date date = new Date();
              long dataL = date.getTime();
              // 格式化年月日
              // %t之后用y表示输出日期的年份（2位数的年，如99）
              // %t之后用m表示输出日期的月份，%t之后用d表示输出日期的日号
              System.out.printf("%1$ty-%1$tm-%1$td; %2$ty-%2$tm-%2$td%n", date, dataL);
              // %t之后用Y表示输出日期的年份（4位数的年），
              // %t之后用B表示输出日期的月份的完整名， %t之后用b表示输出日期的月份的简称
              System.out.printf("%1$tY-%1$tB-%1$td; %2$tY-%2$tb-%2$td%n", date, dataL);
             
              // 以下是常见的日期组合
              // %t之后用D表示以 "%tm/%td/%ty"格式化日期
              System.out.printf("%1$tD%n", date);
              //%t之后用F表示以"%tY-%tm-%td"格式化日期
              System.out.printf("%1$tF%n", date);
             
              /*** 输出时间类型***/
              // 输出时分秒
              // %t之后用H表示输出时间的时（24进制），%t之后用I表示输出时间的时（12进制），
              // %t之后用M表示输出时间的分，%t之后用S表示输出时间的秒
              System.out.printf("%1$tH:%1$tM:%1$tS; %2$tI:%2$tM:%2$tS%n", date, dataL);
              // %t之后用L表示输出时间的秒中的毫秒
              System.out.printf("%1$tH:%1$tM:%1$tS %1$tL%n", date);
              // %t之后p表示输出时间的上午或下午信息
              System.out.printf("%1$tH:%1$tM:%1$tS %1$tL %1$tp%n", date);
             
              // 以下是常见的时间组合
              // %t之后用R表示以"%tH:%tM"格式化时间
              System.out.printf("%1$tR%n", date);
              // %t之后用T表示以"%tH:%tM:%tS"格式化时间
              System.out.printf("%1$tT%n", date);
              // %t之后用r表示以"%tI:%tM:%tS %Tp"格式化时间
              System.out.printf("%1$tr%n", date);
             
              /*** 输出星期***/
              // %t之后用A表示得到星期几的全称
              System.out.printf("%1$tF %1$tA%n", date);
              // %t之后用a表示得到星期几的简称
              System.out.printf("%1$tF %1$ta%n", date);
             
              // 输出时间日期的完整信息
              System.out.printf("%1$tc%n", date);

            /**
             * 格式为"%t"表示输出时间日期类型."%t"之后用y表示输出日期的二位数的年份(如99)、用m
             * 表示输出日期的月份,用d表示输出日期的日号;"%t"之后用Y表示输出日期的四位数的年份
             * (如1999)、用B表示输出日期的月份的完整名,用b表示输出日期的月份的简称."%t"之后用D
             * 表示以"%tm/%td/%ty"的格式输出日期、用F表示以"%tY-%tm-%td"的格式输出日期.
             */
            /**
             * "%t"之后用H表示输出时间的时(24进制),用I表示输出时间的时(12进制),用M表示输出时间
             * 分,用S表示输出时间的秒,用L表示输出时间的秒中的毫秒数、用 p 表示输出时间的是上午还是
             * 下午."%t"之后用R表示以"%tH:%tM"的格式输出时间、用T表示以"%tH:%tM:%tS"的格式输出
             * 时间、用r表示以"%tI:%tM:%tS %Tp"的格式输出时间.
             */
            /**
             * "%t"之后用A表示输出日期的全称,用a表示输出日期的星期简称.
             */

Calendar类

一、为什么需要日历类

  我们已经可以使用Date类来进行时分秒的计算，但如果涉及到年月日的计算又稍显麻烦，所以引入了Calendar类，其功能比Date类强大很多，而且在实现方式上也比Date类要复杂一些。

二、注意点

  Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程需要使用其内部的方法，只需要使用getInstance方法创建即可。

  Calendar 类使用时要注意它的容错性和延迟性。

三、构造函数

创建一个代表系统当前日期的Calendar对象

Calendar c = Calendar.getInstance();//默认是当前日期

创建一个指定日期的Calendar对象

使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);

四、类中的常量

Calendar类中用以下这些常量表示不同的意义

五、成员方法

  1.Set设置

public final void set(int year,int month,int date)
c1.set(2009, 6, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12

public void set(int field,int value)
c1.set(Calendar.DATE,12);//把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算
c1.set(Calendar.YEAR,2013);//把c1对象代表的年份设置为2008年，其他的所有数值会被重新计算

  2.Add增加

c1.add(Calendar.DATE, 10);
//把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算

c1.add(Calendar.DATE, -10);
//把c1对象的日期减去10，也就是c1也就表示为10天前的日期，其它所有的数值会被重新计算

  3.Get获取

get(int field);
c1.get(Calendar.DATE);
//获取当前的日期

六、Calendar的容错性

  调用Calendar对象的set()方法改变指定时间字段的值时，有可能传入一个不合法的参数，例如：为MONTH字段设置13，这将会导致什么结果呢？

	//Calendar：容错性测试
	@Test
	public void testCalender() {
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Calendar calendar = Calendar.getInstance();

		// Calendar容错性：true-打开；false-关闭
		calendar.setLenient(false);

		calendar.set(Calendar.MONTH, 13);
		System.out.println("A="+simpleDateFormat.format(calendar.getTime()));	// A标记

	}
12345678910111213

当打开calendar.setLenient(true)时（默认）：

  A处代码可以正常运行，因为将MONTH字段设置为13，将会使YEAR字段计算加1；

  输出结果：A=2020-02-12 13:59:33。

当关闭calendar.setLenient(false)时：

  A处将会导致运行异常，因为设置的MONTH字段超出了所允许的范围。

关键在于程序中注释有“容错性”的代码行：

  Calendar提供一个setLenient用于设置它的容错性，Calendar默认支持比较好的容错性，通过setLenient(false)关闭Calendar的容错性，让它进行严格的参数检查。

  Calendar有两种解释日历字段的模式：lenient模式，non-lenient模式

    当处于lenient模式时，每个字段都可接受超出范围的值；

    当处于non-lenient模式时，每个字段都进行严格的参数检查，不接收超出字段的值。

七、set()的延迟性

  set(int field, int value)方法日历的某个字段修改为value值，此外它还设置了一个内部成员变量，以指示日历字段field已经被更改。尽管日历字段field是立即更改的，但该Calendar所代表的事件却不会立即修改，直到下次调用get()、getTime()、getTimeInMillis()、add()或roll()时才会重新计算日历的时间。

    这被称为set()方法的延迟修改，采用延迟修改的优势是多次调用set()不会触发多次不必要的运算，下面来看一个例子：

	// set():延迟修改性
	@Test
	public void testCalender1() {
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Calendar calendar = Calendar.getInstance();

        calendar.set(2019, 2, 31);

        calendar.set(Calendar.MONTH, 8);

 		//包含getTime()方法，注释掉此行代码，运行结果截然不同
        System.out.println("A="+simpleDateFormat.format(calendar.getTime())); // A标记

        calendar.set(Calendar.DATE, 5);

        System.out.println("B="+simpleDateFormat.format(calendar.getTime())); // B标记
	}
123456789101112131415161718

打印结果：

• 注释掉 A行 之前：（set一次，get一次，一步一运算）
  A=2019-10-01 13:27:55
  B=2019-10-05 13:27:55
• 注释掉 A行 之后：（set两次，get一次，最后再运算）
  B=2019-09-05 13:33:21

GregorianCalendar类

一、Calendar类实现了公历日历，GregorianCalendar是Calendar类的一个具体实现。

Calendar 的getInstance（）方法返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。GregorianCalendar定义了两个字段：AD和BC。这是代表公历定义的两个时代。

二、GregorianCalendar对象的几个构造方法：

三、GregorianCalendar 类提供的一些方法列表：

四、实例

import java.util.*;
  
public class GregorianCalendarDemo {
 
   public static void main(String[] args) {
      String months[] = {
      "Jan", "Feb", "Mar", "Apr",
      "May", "Jun", "Jul", "Aug",
      "Sep", "Oct", "Nov", "Dec"};
      
      int year;
      // 初始化 Gregorian 日历
      // 使用当前时间和日期
      // 默认为本地时间和时区
      GregorianCalendar gcalendar = new GregorianCalendar();
      // 显示当前时间和日期的信息
      System.out.print("Date: ");
      System.out.print(months[gcalendar.get(Calendar.MONTH)]);
      System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
      System.out.println(year = gcalendar.get(Calendar.YEAR));
      System.out.print("Time: ");
      System.out.print(gcalendar.get(Calendar.HOUR) + ":");
      System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
      System.out.println(gcalendar.get(Calendar.SECOND));
      
      // 测试当前年份是否为闰年
      if(gcalendar.isLeapYear(year)) {
         System.out.println("当前年份是闰年");
      }
      else {
         System.out.println("当前年份不是闰年");
      }
   }
}

以上实例编译运行结果如下：

Date: Apr 22 2009
Time: 11:25:27
当前年份不是闰年

关于 Calendar 类的完整列表，可以参考标准的 Java文档。

JDK8之后新增的时间类

案例一：

  判断一个时间是否在指定时间区间内

  如果在JDK7及以前，需要将时间转换为毫秒值，再进行数值判断

  但是到了JDK8之后，可以直接定义开始时间和结束时间对象，然后调用方法进行比较

        LocalDateTime start = LocalDateTime.of(2022, 7, 8, 7, 20, 0);
        LocalDateTime end = LocalDateTime.of(2023, 11, 11, 0, 10, 0);

        LocalDateTime order = LocalDateTime.of(2023, 11, 11, 0, 0, 3);
        if (start.isBefore(order) && end.isAfter(order)) {
            System.out.println("成功参加");
        } else {
            System.out.println("参加失败");
        }

在JDK8之后，代码更加简洁，安全性更高（将Date对象设置为不可修改，避免了多线程下数据修改问题）

ZoneId类

方法：

        //在JDK8之后，代码更加简洁，安全性更高（将Date对象设置为不可修改，避免了多线程下数据修改问题）
        //ZoneId类：
        Set<String> zoneId1 = ZoneId.getAvailableZoneIds();
        System.out.println(zoneId1);

        ZoneId zoneId2 = ZoneId.systemDefault();
        System.out.println(zoneId2);

        ZoneId zoneId3 = ZoneId.of("Asia/Pontianak");
        System.out.println(zoneId3);

Instant类

一、什么是Instant类

  表示一个固定时间对象

二、方法摘要

        Instant instant = Instant.now();
        System.out.println(instant);
        System.out.println(instant.hashCode());

ZonedDateTime类

ZonedDateTime是具有时区的日期时间的不可变表示。 此类存储所有日期和时间字段，精度为纳秒和时区，区域偏移用于处理模糊的本地日期时间。 例如，值“2007年10月2日13：45.30.123456789 + 02：00在欧洲/巴黎时区”可以存储在ZonedDateTime 。

此类处理从本地时间线LocalDateTime到即时时间线Instant 。 两个时间线之间的差异是UTC /格林威治的偏移量，由ZoneOffset表示。

在两个时间线之间转换涉及使用从ZoneId访问的ZoneId计算偏移量。 瞬间获得偏移量很简单，因为每个瞬间只有一个有效偏移量。 相反，获得本地日期时间的偏移量并不简单。 有三种情况：

• 正常，有一个有效的偏移量。 对于一年中的绝大多数情况，正常情况适用，其中本地日期时间有一个有效的偏移量。
• 差距，零有效偏移。 这是因为春天夏令时从“冬天”变为“夏天”，时钟向前跳跃。 在间隙中，存在没有有效偏移的本地日期时间值。
• 重叠，有两个有效的偏移量。 这是因为秋季夏令时从“夏季”变为“冬季”，因此时钟被缩回。 在重叠中，存在具有两个有效偏移的本地日期时间值。

方法摘要

        ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println(dtf.format(time));

其他更多内容