Java---时间日期

一、java8之前的日期相关类

• JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用
• 而Calendar并不比Date好多少。它们面临的问题是：
  • Date类中的年份是从1900开始的，而月份都从0开始
  • 格式化只对Date类有用，对Calendar类则不能使用
  • 非线程安全

1. System类

常用方法

方法声明	功能介绍
static long currentTimeMillis()	返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差，即获取当前时间戳

使用案例

public class SystemTest {
    public static void main(String[] args){
        // 获取当前时间戳,数据很大所以使用long,不够可使用bigInteger
        long timeStamp = System.currentTimeMillis();
        // 1613797497699
        // 通常用于测试某一段代码的执行效率
        long startTime = System.currentTimeMillis(); //获取开始时间
		doSomething(); //测试的代码段
		long endTime = System.currentTimeMillis(); //获取结束时间
		System.out.println("程序运行时间：" + (endTime - startTime) + "ms"); //输出程序运行时间
    }
}

2. Date类

基本概念

java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒，可以精确到毫秒

常用方法

方法声明	功能介绍
Date()	使用无参的方式构造对象，也就是当前系统时间
Date(long date)	根据参数指定毫秒数构造对象， 参数为距离1970年1月1日0时0分0秒的毫秒数
long getTime()	获取调用对象距离1970年1月1日0时0分0秒的毫秒数
void setTime(long time)	设置调用对象为距离基准时间time毫秒的时间

使用案例

import java.util.Date;
public class DateTest {

    public static void main(String[] args) {

        // 1.使用无参方式构造Date对象并打印
        Date d1 = new Date();
        System.out.println("d1 = " + d1); // 获取当前系统时间

        // 2.使用参数指定的毫秒数来构造Date对象并打印  1秒 = 1000毫秒  东八区
        Date d2 = new Date(1000);
        System.out.println("d2 = " + d2); // Thu Jan 01 08:00:01 CST 1970

        // 3.获取调用对象距离1970年1月1日0时0分0秒的毫秒数
        long timeStamp = d2.getTime();
        System.out.println("获取到的毫秒数是：" + timeStamp); // 1000

        // 4.设置调用对象所表示的时间点为参数指定的毫秒数
        d2.setTime(2000);
        System.out.println("修改后的时间是：" + d2); // Thu Jan 01 08:00:02 CST 1970
    }
}

Date 类的无参数构造方法获取的是系统当前的时间，显示的顺序为星期、月、日、小时、分、秒、年。

Date 类带 long 类型参数的构造方法获取的是距离 GMT 指定毫秒数的时间，1000毫秒是一秒钟，而 GMT（格林尼治标准时间）与 CST（中央标准时间）相差 8 小时，也就是说 1970 年 1 月 1 日 00:00:00 GMT 与 1970 年 1 月 1 日 08:00:00 CST 表示的是同一时间。 因此距离 1970 年 1 月 1 日 00:00:00 CST 一秒钟的时间为 1970 年 1 月 1 日 00:00:01 CST，即使用 Date 对象表示为 Thu Jan 01 08:00:01 CST 1970。

3. SimpleDateFormat类

基本概念

java.text.SimpleDateFormat类主要用于实现日期和文本之间的转换

常用方法

方法声明	功能介绍
SimpleDateFormat()	使用无参方式构造对象
SimpleDateFormat(String pattern)	根据参数指定的模式来构造对象，模式主要有: y-年 M-月 d-日 H(h)-时 m-分 s-秒
final String format(Date date)	用于将日期类型转换为文本类型
Date parse(String source)	用于将文本类型转换为日期类

使用案例

import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatTest {

    public static void main(String[] args) throws Exception {

        // 1.获取当前系统时间并打印
        Date nowTime = new Date();
        System.out.println(nowTime); // Sat Feb 20 13:33:40 CST 2021

        // 2.构造SimpleDateFormat类型的对象并指定格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        // 3.实现日期类型向文本类型的转换并打印
        String format = sdf.format(nowTime);
        System.out.println("转换后的日期为：" + format); // 转换后的日期为：2021-02-20 13:33:40

        // 4.实现文本类型到日期类型的转换并打印
        Date parse = sdf.parse(format);
        System.out.println("转回日期格式的结果为：" + parse); // 转回日期格式的结果为：Sat Feb 20 13:33:40 CST 2021
    }
}

4. Calendar类

基本概念

Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期） 提供了一些方法。

创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。

Calendar c = Calendar.getInstance();

使用案例

import java.util.Calendar;
import java.util.Date;

public class CalendarTest {

    public static void main(String[] args) {

        // 设置格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 通过 getInstance() 方法获得 Calendar类的对象
        Calendar c = Calendar.getInstance();
        c.set(2020, 8, 8, 12, 15, 45); //设置年月日，若不设置时分秒将默认采用当前值
        System.out.println("设置日期为 2020-8-8 后的时间：" + c.getTime()); 
        //设置日期为 2020-8-8 后的时间：Tue Sep 08 12:15:45 CST 2020
        
        //转换为Date类型并按照指定的格式打印
        Date d = c.getTime(); //获取当前时间
        String format = sdf.format(d); //转化为文本指定格式
        System.out.println("转化格式后时间是：" + format); 
        //转化格式后时间是：2020-09-08 12:15:45

        //向指定的字段设置以及增加指定的数值
        c.set(Calendar.YEAR, 2021);
        //转换为Date类型并按照指定的格式打印
        System.out.println("设置年份后的结果是：" + sdf.format(c.getTime())); 
        //设置年份后的结果是：2021-09-08 12:15:45

        c.add(Calendar.MONTH, 2);
        System.out.println("增加月份后的结果是：" + sdf.format(c.getTime())); 
        //增加月份后的结果是：2021-11-08 12:15:45
    }
}

Calendar 类中定义了许多常量，分别表示不同的意义。

• Calendar.YEAR：年份。
• Calendar.MONTH：月份。
• Calendar.DATE：日期。
• Calendar.DAY_OF_MONTH：日期，和上面的字段意义完全相同。
• Calendar.HOUR：12小时制的小时。
• Calendar.HOUR_OF_DAY：24 小时制的小时。
• Calendar.MINUTE：分钟。
• Calendar.SECOND：秒。
• Calendar.DAY_OF_WEEK：星期几。

public static void calendarTest(){
    Calendar calendar = Calendar.getInstance(); //如果不设置时间，则默认为当前时间
    calendar.setTime(new Date()); //将系统当前时间赋值给 Calendar 对象
    System.out.println("现在时刻：" + calendar.getTime()); //获取当前时间

    int year = calendar.get(Calendar.YEAR); //获取当前年份
    System.out.print("现在是" + year + "年");
    int month = calendar.get(Calendar.MONTH) + 1; //获取当前月份（月份从 0 开始，所以加 1）
    System.out.print(month + "月");
    int day = calendar.get(Calendar.DATE); //获取日
    System.out.print(day + "日");
    int week = calendar.get(Calendar.DAY_OF_WEEK) - 1; // 取今天星期几（以星期日为第一天）
    System.out.print("星期" + week);
    int hour = calendar.get(Calendar.HOUR_OF_DAY); //获取当前小时数（24 小时制）
    System.out.print(hour + "时");
    int minute = calendar.get(Calendar.MINUTE); //获取当前分钟
    System.out.print(minute + "分");
    int second = calendar.get(Calendar.SECOND); //获取当前秒数
    System.out.print(second + "秒");
    int millisecond = calendar.get(Calendar.MILLISECOND); //获取毫秒数
    System.out.println(millisecond + "毫秒");
    int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH); //获取今天是本月第几天
    System.out.println("今天是本月的第 " + dayOfMonth + " 天");
    int dayOfWeekInMonth = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH); //获取今天是本月第几周
    System.out.println("今天是本月第 " + dayOfWeekInMonth + " 周");
    int many = calendar.get(Calendar.DAY_OF_YEAR); //获取今天是今年第几天
    System.out.println("今天是今年第 " + many + " 天");
}

输出结果：

现在是2021年2月20日星期616时42分39秒60毫秒
今天是本月的第 20 天
今天是本月第 3 周
今天是今年第 51 天

二、java8中的日期相关类

• Java 8通过发布新的Date-Time API来进一步加强对日期与时间的处理

  • java.time包：该包日期/时间API的基础包
  • java.time.chrono包：该包提供对不同日历系统的访问
  • java.time.format包：该包能够格式化和解析日期时间对象
  • java.time.temporal包：该包包含底层框架和扩展特性
  • java.time.zone包：该包支持不同时区以及相关规则的类

1. LocalDate类

基本概念

java.time.LocalDate类主要用于描述年-月-日格式的日期信息，该类不表示时间和时区信息

使用案例

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.temporal.ChronoField;

public class LocalDateTest {
    public static void main(String[] args) {
        //LocalDate.now()
        LocalDate nowTime = LocalDate.now();
        System.out.println("当前时间为："+nowTime);
        //LocalDate.parse()
        LocalDate parseTime = LocalDate.parse("2020-10-12");
        System.out.println("解析时间为："+parseTime);
        //LocalDate.of(()
        LocalDate ofTime = LocalDate.of(2020,9,22);
        System.out.println("构造时间为："+ofTime);

        LocalDate localDate = LocalDate.now();
        //获取年、月、日、星期几
        int year = localDate.getYear();
        int year1 = localDate.get(ChronoField.YEAR);
        System.out.println("年："+year+" "+year1);
        Month month = localDate.getMonth();
        int month1 = localDate.get(ChronoField.MONTH_OF_YEAR);
        System.out.println("月："+month+" "+month1);
        int day = localDate.getDayOfMonth();
        int day1 = localDate.get(ChronoField.DAY_OF_MONTH);
        System.out.println("日："+day+" "+day1);
        DayOfWeek dayOfWeek = localDate.getDayOfWeek();
        int dayOfWeek1 = localDate.get(ChronoField.DAY_OF_WEEK);
        System.out.println("星期："+dayOfWeek+" "+dayOfWeek1);
    }
}

输出结果：

当前时间为：2021-02-20
解析时间为：2020-10-12
构造时间为：2020-09-22
年：2021 2021
月：FEBRUARY 2
日：20 20
星期：SATURDAY 6

2. LocalTime类

基本概念

java.time.LocalTime 类主要用于描述时间信息，可以描述时分秒以及纳秒

使用案例

import java.time.LocalTime;
import java.time.temporal.ChronoField;

public class LocalTimeTest {
    public static void main(String[] args) {
        LocalTime nowTime = LocalTime.now();
        System.out.println("当前时间为："+nowTime);
        LocalTime ofTime = LocalTime.of(13, 10, 20);
        System.out.println("构造时间为："+ofTime);
        //获取小时
        int hour = nowTime.getHour();
        int hour1 = nowTime.get(ChronoField.HOUR_OF_DAY);
        System.out.println("时："+hour+" "+hour1);
        //获取分
        int minute = nowTime.getMinute();
        int minute1 = nowTime.get(ChronoField.MINUTE_OF_HOUR);
        System.out.println("分："+minute+" "+minute1);
        //获取秒
        int second = nowTime.getSecond();
        int second1 = nowTime.get(ChronoField.SECOND_OF_MINUTE);
        System.out.println("秒："+second+" "+second1);

    }
}

输出结果：

当前时间为：19:16:08.040616500
构造时间为：13:10:20
时：19 19
分：16 16
秒：8 8

3. LocalDateTime类★

基本概念

java.time.LocalDateTime类主要用于描述ISO-8601日历系统中没有时区的日期时间，如2007-1203T10:15:3

常用方法

方法声明	功能介绍
static LocalDateTime now()	从默认时区的系统时间中获取当前日期时间
static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second)	根据参数指定的年月日时分秒信息来设置日期时间
int getYear()	获取年份字段的数值
int getMonthValue()	获取1到12之间的月份字段
int getDayOfMonth()	获取日期字段
int getHour()	获取小时数
int getMinute()	获取分钟数
int getSecond()	获取秒数
LocalDateTime withYear(int year)	设置为参数指定的年
LocalDateTime withMonth(int month)	设置为参数指定的月
LocalDateTime withDayOfMonth(int dayOfMonth)	设置为参数指定的日
LocalDateTime withHour(int hour)	设置为参数指定的时
LocalDateTime withMinute(int minute)	设置为参数指定的分
LocalDateTime withSecond(int second)	设置为参数指定的秒
LocalDateTime plusYears(long years)	加上参数指定的年
LocalDateTime plusMonths(long months)	加上参数指定的月
LocalDateTime plusDays(long days)	加上参数指定的日
LocalDateTime plusHours(long hours)	加上参数指定的时
LocalDateTime plusMinutes(long minutes)	加上参数指定的分
LocalDateTime plusSeconds(long seconds)	加上参数指定的秒
LocalDateTime minusYears(long years)	减去参数指定的年
LocalDateTime minusMonths(long months)	减去参数指定的月
LocalDateTime minusDays(long days)	减去参数指定的日
LocalDateTime minusHours(long hours)	减去参数指定的时
LocalDateTime minusMinutes(long minutes)	减去参数指定的分
LocalDateTime minusSeconds(long seconds)	减去参数指定的秒

使用案例

import java.time.LocalDateTime;

public class LocalDateTimeTest {
    public static void main(String[] args) {
        // 获取当前日期时间信息，使用最多
        LocalDateTime nowTime = LocalDateTime.now();
        System.out.println("当前日期时间：" + nowTime);

        System.out.println("------------------------------------------");
        // 使用参数指定的年月日时分秒信息来获取对象
        LocalDateTime localDateTime = LocalDateTime.of(2008, 8, 8, 20, 8, 8);
        System.out.println("指定的日期时间是：" + localDateTime); // 自动调用toString方法
        System.out.println("获取到的年是：" + localDateTime.getYear()); // 2008
        System.out.println("获取到的月是：" + localDateTime.getMonthValue()); // 8
        System.out.println("获取到的日是：" + localDateTime.getDayOfMonth()); // 8
        System.out.println("获取到的时是：" + localDateTime.getHour()); // 20
        System.out.println("获取到的分是：" + localDateTime.getMinute()); // 8
        System.out.println("获取到的秒是：" + localDateTime.getSecond()); // 8

        System.out.println("--------------------------------------------");
        // 与String类型相似，调用对象本身的数据内容不会改变，返回值相当于创建了一个新的对象，
        // 实现特征的设置
        System.out.println("localDateTime = " + localDateTime);
        LocalDateTime localDateTime1 = localDateTime.withYear(2012).withMonth(12);
        System.out.println("localDateTime1 = " + localDateTime1);

        System.out.println("---------------------------------------------");
        // 实现特征的增加
        LocalDateTime localDateTime2 = localDateTime.plusDays(2);
        System.out.println("localDateTime2 = " + localDateTime2);
        LocalDateTime localDateTime3 = localDateTime.plusHours(3);
        System.out.println("localDateTime3 = " + localDateTime3);

        System.out.println("----------------------------------------------");
        // 实现特征的减少
        LocalDateTime localDateTime4 = localDateTime.minusMinutes(1);
        System.out.println("localDateTime4 = " + localDateTime4);
        LocalDateTime localDateTime5 = localDateTime.minusSeconds(3);
        System.out.println("localDateTime5 = " + localDateTime5);
    }
}

输出结果：

当前日期时间：2021-02-20T21:05:49.505128500

---

指定的日期时间是：2008-08-08T20:08:08
获取到的年是：2008
获取到的月是：8
获取到的日是：8
获取到的时是：20
获取到的分是：8
获取到的秒是：8

---

localDateTime = 2008-08-08T20:08:08
localDateTime1 = 2012-12-08T20:08:08

---

localDateTime2 = 2008-08-10T20:08:08
localDateTime3 = 2008-08-08T23:08:08

---

localDateTime4 = 2008-08-08T20:07:08
localDateTime5 = 2008-08-08T20:08:05

4. Instant类

基本概念

java.time.Instant类主要用于描述瞬间的时间点信息

常用方法

方法声明	功能介绍
static Instant now()	从系统时钟(本初子午线)上获取当前时间，
OffsetDateTime atOffset(ZoneOffset offset)	将此瞬间与偏移量组合以创建偏移日期时间
static Instant ofEpochMilli(long epochMilli)	根据参数指定的毫秒数来构造对象，参数为距离1970年1月1 日0时0分0秒的毫秒数
long toEpochMilli()	获取距离1970年1月1日0时0分0秒的毫秒数

使用案例

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

public class InstantTest {
    public static void main(String[] args) {
        // 使用Instant类来获取当前系统时间  并不是当前系统的默认时区 本初子午线
        Instant nowTime = Instant.now();
        System.out.println("当前时间为：" + nowTime);

        // 加上时区所差的8个小时
        OffsetDateTime offsetDateTime = nowTime.atOffset(ZoneOffset.ofHours(8));
        System.out.println("偏移后的日期时间为：" + offsetDateTime);

        // 获取当前调用对象距离标准基准时间的毫秒数，即时间戳
        long currentMilli = nowTime.toEpochMilli();
        System.out.println("当前时间毫秒差为：" + currentMilli);
        // 获取当前调用对象距离标准基准时间的秒数
        long currentSecond = nowTime.getEpochSecond();
        System.out.println("当前时间毫秒差为：" + currentSecond);

        // 4.根据参数指定的毫秒数来构造对象
        Instant instant = Instant.ofEpochMilli(currentMilli);
        System.out.println("根据参数指定的毫秒数构造出来的对象为：" + instant);
    }
}

输出结果：

当前时间为：2021-02-20T13:24:38.659495Z
偏移后的日期时间为：2021-02-20T21:24:38.659495+08:00
当前时间毫秒差为：1613827478659
当前时间毫秒差为：1613827478
根据参数指定的毫秒数构造出来的对象为：2021-02-20T13:24:38.659Z

5. DateTimeFormatter类

基本概念

java.time.format.DateTimeFormatter类主要用于格式化和解析日期

常用方法

方法声明	功能介绍
static DateTimeFormatter ofPattern(String pattern)	根据参数指定的模式来获取对象
String format(TemporalAccessor temporal)	将参数指定日期时间转换为字符串
TemporalAccessor parse(CharSequence text)	将参数指定字符串转换为日期时

使用案例

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

public class DateTimeFormatterTest {
    public static void main(String[] args) {
        // 获取当前系统的日期时间
        LocalDateTime nowTime = LocalDateTime.now();
        System.out.println("当前时间为：" + nowTime);

        // 按照指定的格式准备一个DateTimeFormatter类型的对象
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 实现日期时间向字符串类型的转换
        String formatTime = dateTimeFormatter.format(nowTime);
        System.out.println("调整格式后的结果是：" + formatTime);
        // 实现字符串类型到日期时间类型的转换
        TemporalAccessor parse = dateTimeFormatter.parse(formatTime);
        System.out.println("转回去的结果是：" + parse);
    }
}

输出结果：

当前时间为：2021-02-20T21:29:07.448267600
调整格式后的结果是：2021-02-20 21:29:07
转回去的结果是：{},ISO resolved to 2021-02-20T21:29:07

6. Period和Duration类

主要是用来计算日期，差值之类的。

Period：final修饰，线程安全，ISO-8601日历系统中基于日期的时间量，例如2年3个月4天。

Duration：final修饰，线程安全，基于时间的时间量，如“34.5秒”。

使用案例

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

public class PeriodAndDuration {
    public static void main(String[] args) {
        LocalDate localDate1 = LocalDate.of(2019, 11, 15);
        LocalDate localDate2 = LocalDate.of(2020, 1, 1);
        Period p = Period.between(localDate1, localDate2);
        System.out.println("years:"+p.getYears()+" months:"+p.getMonths()+" days:"+p.getDays());

        LocalDateTime localDateTime1 = LocalDateTime.of(2019, 11, 15, 0, 0);
        LocalDateTime localDateTime2 = LocalDateTime.of(2020, 12, 25, 10, 30);
        Duration d = Duration.between(localDateTime1, localDateTime2);
        System.out.println("days:"+d.toDays());
        System.out.println("hours:"+d.toHours());
        System.out.println("minutes:"+d.toMinutes());
        System.out.println("millis:"+d.toMillis());
    }
}

输出结果：

years:0 months:1 days:17
days:406
hours:9754
minutes:585270
millis:35116200000

Period和Duration的区别

①包含属性不同

Period包含年数，月数，天数，而Duration只包含秒，纳秒。

Period只能返回年数，月数，天数；Duration可以返回天数，小时数，分钟数，毫秒数等。

②between方法可以使用的类型不同

Period只能使用LocalDate

Duration可以使用所有包含了time部分且实现了Temporal接口的类，比如LocalDateTime，LocalTime和Instant等。

③between获取天数差的区别

Period.getDays() 获取天数时，只会获取days属性值，而不会将年月部分都计算成天数，不会有2020.1.1和2019.1.1比较后获取天数为365天的情况。

public int getDays() {
    return days;
}

Duration.toDays() 获取天数时，会将秒属性转换成天数。

public long toDays() {
    return seconds / SECONDS_PER_DAY;
}

所以，想要获取2个时间的相差总天数，只能用Duration。

三、日期时间比较

1. 使用Date.compareTo()方法

public static void dateCompareTest() throws ParseException {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date date1 = sdf.parse("2010-10-20");
    Date date2 = sdf.parse("2020-02-20");

    System.out.println("date1 : " + sdf.format(date1));
    System.out.println("date2 : " + sdf.format(date2));

    if (date1.compareTo(date2) > 0) {
        System.out.println("Date1 时间在 Date2 之后");
    } else if (date1.compareTo(date2) < 0) {
        System.out.println("Date1 时间在 Date2 之前");
    } else if (date1.compareTo(date2) == 0) {
        System.out.println("Date1 时间与 Date2 相等");
    }
}

输出结果：

date1 : 2010-10-20
date2 : 2020-02-20
Date1 时间在 Date2 之前

2. 使用Date.before()，Date.after()和Date.equals()

public static void dateCompareTest2() throws ParseException {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date date1 = sdf.parse("2010-10-20");
    Date date2 = sdf.parse("2020-02-20");

    System.out.println("date1 : " + sdf.format(date1));
    System.out.println("date2 : " + sdf.format(date2));

    if (date1.after(date2)) {
        System.out.println("Date1 时间在 Date2 之后");
    }
    if (date1.before(date2)) {
        System.out.println("Date1 时间在 Date2 之前");
    }
    if (date1.equals(date2)) {
        System.out.println("Date1 时间与 Date2 相等");
    }
}

输出结果：

date1 : 2010-10-20
date2 : 2020-02-20
Date1 时间在 Date2 之前

3. Calender.before()，Calender.after()和Calender.equals()

public static void dateCompareTest3() throws ParseException {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date date1 = sdf.parse("2009-12-31");
    Date date2 = sdf.parse("2019-01-31");

    System.out.println("date1 : " + sdf.format(date1));
    System.out.println("date2 : " + sdf.format(date2));

    Calendar cal1 = Calendar.getInstance();
    Calendar cal2 = Calendar.getInstance();
    cal1.setTime(date1);
    cal2.setTime(date2);

    if (cal1.after(cal2)) {
        System.out.println("Date1 时间在 Date2 之后");
    }
    if (cal1.before(cal2)) {
        System.out.println("Date1 时间在 Date2 之前");
    }
    if (cal1.equals(cal2)) {
        System.out.println("Date1 时间与 Date2 相等");
    }
}

输出结果：

date1 : 2009-12-31
date2 : 2019-01-31
Date1 时间在 Date2 之前

4. Java 8日期比较方法

在Java 8中，可以使用新的isBefore()，isAfter()，isEqual()和compareTo()来比较LocalDate，LocalTime和LocalDateTime。

public static void dateCompareTest4() throws ParseException {
    DateTimeFormatter sdf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    LocalDate date1 = LocalDate.of(2009, 12, 31);
    LocalDate date2 = LocalDate.of(2019, 1, 31);

    System.out.println("date1 : " + sdf.format(date1));
    System.out.println("date2 : " + sdf.format(date2));

    if (date1.isAfter(date2)) {
        System.out.println("Date1 时间在 Date2 之后");
    }
    if (date1.isBefore(date2)) {
        System.out.println("Date1 时间在 Date2 之前");
    }
    if (date1.isEqual(date2)) {
        System.out.println("Date1 时间与 Date2 相等");
    }
}

输出结果：

date1 : 2009-12-31
date2 : 2019-01-31
Date1 时间在 Date2 之前