JDK 8之前的日期时间API

22.日期与时间 - 图1

一、java.lang.System类

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

此方法适于计算时间差。

计算世界时间的主要标准有：

  • UTC(Coordinated Universal Time)
  • GMT(Greenwich Mean Time)
  • CST(Central Standard Time)

二、java.util.Date类

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

构造器：

  • Date()：使用无参构造器创建的对象可以获取本地当前时间。
  • Date(long date)

常用方法：

  • getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
  • toString():把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue,Wed, Thu, Fri, Sat)，zzz是时间标准。
  • 其它很多方法都过时了。

1、currentTimeMillis()

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

2、java.util.Date类

  1. <!--java.util.Date类-->
  2. <!--      1、两个构造器的使用-->
  3. <!--          >构造器一：Date():创建了一个对应当前时间的Date对象-->
  4. <!--           >构造器二：创建指定毫秒数的Date对象-->
  6. <!--      2、两个方法的使用-->
  7. <!--           >toString()：显示当前的年、月、日、时、分、秒-->
  8. <!--           >getTime()：获取当前Date对象对应的毫秒数。（时间戳）-->
  10. <!--      3、java.sql.Date对应着数据库中日期类型的变量-->
  11. <!--           >如何实例化-->
  12. <!--           >如何将java.sql.Date 对象转换为 java.util.Date对象（多态）-->
  13. <!--           >如何将java.util.Date 对象转换为 java.sql.Date对象-->
  15.     @Test
  16.     public void test2(){
  17.         //构造器一：Date():创建了一个对应当前时间的Date对象
  18.         Date date1=new Date();
  19.         //System.out.println(date1.toString());//Wed Nov 11 20:58:35 CST 2020
  20.         //System.out.println(date1.getTime());//1605099542441
  22.         //构造器二：创建指定毫秒数的Date对象
  23.         Date date2 = new Date(1605099542441L);
  24.         //System.out.println(date2);
  26.         //java.sql.Date ---> java.util.Date
  27.         java.sql.Date date3 = new java.sql.Date(1605099542441L);
  28.         //System.out.println(date3);//2020-11-11
  30.         //java.util.Date ---> java.sql.Date
  31.         Date date4 = new Date();
  32.         //System.out.println(date4);//Wed Nov 11 21:23:52 CST 2020
  33.         java.sql.Date date5 = new java.sql.Date(date4.getTime());
  34.         //System.out.println(date5);//2020-11-11
  35.     }

三、 java.text.SimpleDateFormat类

Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。

  • 它允许进行格式化：日期 -> 字符串、解析：字符串 -> 日期

  • 格式化：

    • SimpleDateFormat(),默认的模式和语言环境创建对象 .
    • public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：
    • public String format(Date date)：方法格式化时间对象date

  • 解析

    • public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。
  1.  /**
  2.      * SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析
  3.      * 1、两个操作
  4.      * 1.1、格式化：日期 ---> 字符串
  5.      * 1.2 解析：格式化的逆过程，字符串 ---> 日期
  6.      * 2、SimpleDateFormat的实例化
  7.  */
  8.     @Test
  9.     public void testSimpleDateFormat() throws ParseException {
  10.         //实例化SimpleDateFormat:使用默认的构造器
  11.         SimpleDateFormat sdf=new SimpleDateFormat();
  12.         //格式化1：日期 ---> 字符串
  13.         Date date=new Date();
  14.         System.out.println(date);
  15.         String format = sdf.format(date);
  16.         System.out.println(format);
  18.         //解析：格式化的逆过程，字符串 ---> 日期
  19.         String str="20-10-1 下午10:46";
  20.         Date date1 = sdf.parse(str);
  21.         System.out.println(date1);
  23.         //***************按照指定的方式进行格式化和解析：调用带参数的SimpleDateFormat构造器*****************************
  24.         //格式化2：日期 ---> 字符串
  25.         SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
  26.         String format1 = sdf1.format(date);
  27.         System.out.println(format1);//2020-11-12 08:37:51
  28.         //解析2：字符串 ---> 日期,要求字符串必须符合SimpleDateFormat识别的格式（通过构造器参数体现），否则会抛出异常
  29.         Date date2 = sdf1.parse("2021-11-12 08:37:51");
  30.         System.out.println(date2);//Fri Nov 12 08:37:51 CST 2021
  32.     }

练习一：字符串”2020-10-01”转换为java.sql.Date

  1. @Test
  2. public void testExer() throws ParseException {
  3.     String str="2020-10-01";
  4.     SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
  5.     Date date = simpleDateFormat.parse(str);
  6.     java.sql.Date date1 = new java.sql.Date(date.getTime());
  7.     System.out.println(date1);
  8. }

四、 java.util.Calendar(日历)类

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

  • 获取Calendar实例的方法

    • 使用Calendar.getInstance()方法
    • 调用它的子类GregorianCalendar的构造器。

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

    • public void set(int field,int value)
    • public void add(int field,int amount)
    • public final Date getTime()
    • public final void setTime(Date date)

  • 注意:

    • 获取月份时：一月是0，二月是1，以此类推，12月是11
    • 获取星期时：周日是1，周二是2 ， 。。。。周六是7
  1.     @Test
  2.     public void testCalendar(){
  3.         //1、实例化
  4.         //1、方式一：创建其子类（GregorianCalendar）的对象
  5.         //2、方式二：调用其静态方法getInstance()
  6.         Calendar calendar=Calendar.getInstance();
  7.         //System.out.println(calendar.getClass());
  9.         //2、常用的方法
  10.         //get()
  11.         int days = calendar.get(Calendar.DAY_OF_MONTH);//今天是这个月的第几天
  12.         System.out.println(days);
  13.         int days1 = calendar.get(Calendar.DAY_OF_WEEK);//今天是这周的第几天
  14.         System.out.println(days1);
  15.         int days2 = calendar.get(Calendar.DAY_OF_YEAR);//今天是今年的第几天
  16.         System.out.println(days2);
  17.         //set()
  18.         //Calendar可变性
  19.         calendar.set(Calendar.DAY_OF_MONTH,15);//修改为今天是这个月的第15天
  20.         days=calendar.get(Calendar.DAY_OF_MONTH);
  21.         System.out.println(days);
  22.         //add()
  23.         calendar.add(Calendar.DAY_OF_MONTH,3);//在当前的天数上再加3天即：15+3=18天
  24.         days=calendar.get(Calendar.DAY_OF_MONTH);
  25.         System.out.println(days);
  26.         //getTime()：日历类--->Date
  27.         Date date = calendar.getTime();//从calendar对象当做获取一个java.util.Date对象
  28.         System.out.println(date);
  29.         //setTime()：Date--->日历类
  30.         Date date1=new Date();
  31.         calendar.setTime(date1);
  32.         days=calendar.get(Calendar.DAY_OF_MONTH);
  33.         System.out.println(days);//12
  35.     }

JDK 8中的日期时间API

背景

如果我们可以跟别人说：“我们在1502643933071见面，别晚了！”那么就再简单不
过了。但是我们希望时间与昼夜和四季有关，于是事情就变复杂了。JDK 1.0中包含了
一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用
了。而Calendar并不比Date好多少。它们面临的问题是：
可变性：像日期和时间这样的类应该是不可变的。
偏移性：Date中的年份是从1900开始的，而月份都从0开始。
格式化：格式化只对Date有用，Calendar则不行。
此外，它们也不是线程安全的；不能处理闰秒等。

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

新时间日期API

  • java.time – 包含值对象的基础包
  • java.time.chrono – 提供对不同的日历系统的访问
  • java.time.format – 格式化和解析时间和日期
  • java.time.temporal – 包括底层框架和扩展特性
  • va.time.zone – 包含时区支持的类

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

一、LocalDate、LocalTime、LocalDateTime

  • LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类，它们的实例
    是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。
    它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区
    相关的信息。
  • LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存储 生日、纪念日等日期。
  • LocalTime表示一个时间，而不是日期。
  • LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。

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

22.日期与时间 - 图2

  1. @Test
  2.     public void test1(){
  3.         //now():获取当前的日期、时间、日期+时间
  4.         LocalDate localDate=LocalDate.now();
  5.         LocalTime localTime = LocalTime.now();
  6.         LocalDateTime localDateTime=LocalDateTime.now();
  7.         System.out.println(localDate);//2020-11-12
  8.         System.out.println(localTime);//21:57:02.584
  9.         System.out.println(localDateTime);//2020-11-12T21:57:02.584
  10.         //of():设置指定的年月日时分秒。没有偏移量
  11.         LocalDateTime localDateTime1 = LocalDateTime.of(2020, 11, 12, 21, 58, 20);
  12.         System.out.println(localDateTime1);//2020-11-12T21:58:20
  14.         //getXxx()：获取相相关属性
  15.         System.out.println(localDateTime.getDayOfMonth());//12 当月第几天
  16.         System.out.println(localDateTime.getDayOfWeek());//THURSDAY 星期几
  17.         System.out.println(localDateTime.getMonth());//NOVEMBER 几月
  18.         System.out.println(localDateTime.getMonthValue());//11 几月
  19.         System.out.println(localDateTime.getDayOfYear());//317 一年中的第几天
  20.         System.out.println(localDateTime.getMinute());//4 几分钟
  22.         //withXxx():设置相关属性，体现不可变性
  23.         LocalDate localDate1 = localDate.withDayOfMonth(22);
  24.         System.out.println(localDate); //2020-11-12
  25.         System.out.println(localDate1);//2020-11-22
  27.         //plusXxx():加上指定的时间，天数、月数，不可变性
  28.         LocalDateTime localDateTime2 = localDateTime.plusMonths(3);
  29.         System.out.println(localDateTime);//2020-11-12T22:11:23.645
  30.         System.out.println(localDateTime2);//2021-02-12T22:11:23.645
  32.         //minusXxx():减去指定的时间、天数、月数，不可变性
  33.         LocalDateTime localDateTime3 = localDateTime.minusDays(5);
  34.         System.out.println(localDateTime);//2020-11-12T22:14:26.274
  35.         System.out.println(localDateTime3);//2020-11-07T22:14:26.274
  37.     }

二、瞬时：Instant

  • 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毫秒 =109纳秒

22.日期与时间 - 图3

  1.     /**
  2.      * Instant：瞬时点
  3.      * 类似于 java.util.Date类
  4.     */
  5.     @Test
  6.     public void test2(){
  7.         //now()；获取本初子午线对应的标准时间
  8.         Instant instant=Instant.now();
  9.         System.out.println(instant);//2020-11-12T14:21:44.883Z(本初子午线的时间，距离当前时间少8个小时)
  11.         //添加时区的偏移量，东八区+8
  12.         OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
  13.         System.out.println(offsetDateTime);//2020-11-12T22:21:44.883+08:00（在本初子午线的时间基础之上+8小时）
  16.         //toEpochMilli():表示自1970年1月1日0时0分0秒（UTC）开始的毫秒数 -->Date类的getTime()
  17.         long milli = instant.toEpochMilli();
  18.         System.out.println(milli);//1605191250719
  20.         //ofEpochMilli:通过给定的毫秒数，获取Instant实例 -->Date(long millis)
  21.         Instant instant1 = Instant.ofEpochMilli(1605191181376L);
  22.         System.out.println(instant1);//2020-11-12T14:26:21.376Z
  23.     }

三、格式化与解析日期或时间

java.time.format.DateTimeFormatter类：该类提供了三种格式化方法：

  • 预定义的标准格式。如：ISO_LOCAL_DATE_TIME、ISO_LOCAL_DATE、ISO_LOCAL_TIME
  • 本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
  • 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

22.日期与时间 - 图4

  1.     /**
  2.      * DateTimeFormatter：格式化或解析日期、时间
  3.      *      类似于SimpleDateFormat
  4.      */
  6.     @Test
  7.     public void test3(){
  8.         //方式一：预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
  9.         DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
  10.         //格式化:日期 ---> 字符串
  11.         LocalDateTime now = LocalDateTime.now();
  12.         String format = formatter.format(now);
  13.         System.out.println(format);
  15.         //解析：字符串 ---> 日期
  16.         TemporalAccessor parse = formatter.parse("2020-11-12T22:36:08.156");
  17.         System.out.println(parse);
  19.         //方式二：本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
  20.         //参数不同格式化后字符串的格式不同
  21.         //FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT:适用于LocalDateTime
  22.         DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
  23.         String format1 = formatter1.format(now);
  24.         System.out.println(format1);//20-11-12 下午10:58
  25.         formatter1=DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
  26.         String format2 = formatter1.format(now);
  27.         System.out.println(format2);//2020年11月12日 下午10时59分32秒
  29.         //本地化相关格式。如：ofLocalizedDate()
  30.         //FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT:适用于LocalDate
  31.         DateTimeFormatter formatter2=DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
  32.         //格式化
  33.         String format3 = formatter2.format(LocalDate.now());
  34.         System.out.println(format3);//2020-11-14
  35.         //解析
  37.         //方式三：自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
  38.         DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
  39.         //格式化
  40.         String format4 = formatter3.format(LocalDateTime.now());
  41.         System.out.println(format4);//2020-11-14 01:50:46
  43.         //解析
  44.         TemporalAccessor parse1 = formatter3.parse("2020-11-14 01:50:46");
  45.         System.out.println(parse1);
  46.     }