第44章 时间日期类

作者：张子默

一、Date类

1、概述

java.util.Date类表示特定的瞬间，精确到毫秒。

继续查阅Date类的描述，发现Date类拥有多个构造函数，只是部分已过时，但是其中有未过时的构造函数可以把毫秒值转换成时间对象。

• public Date()：分配Date对象并初始化该对象，以表示分配它的时间(精确到毫秒)。
• public Date(long date)：分配Date对象并初始化此对象，以表示自从标准基准时间(称为"历元(epoch)"，即1970年1月1日00:00:00 GMT)以来的指定毫秒数。

tips：由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。

简单来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以定义毫秒时刻。例如：

import java.util.Date;
public class Demo01Date {
    public static void main(String[] args) {
        // 创建日期对象，把当前的时间
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
        // 创建日期对象，把当前的毫秒值转成日期对象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}
1
2
3
4
5
6
7
8
9

tips：在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。

2、常用方法

Date类中的多数方法已经过时，常用的方法有：

• public long getTime()把日期对象转换成对应的时间毫秒值。

二、DateFormat类

java.text.DateFormat是日期/时间格式化子类的的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换，也就是可以在Date对象和String对象之间进行来回转换。

• 格式化：按照指定的格式，从Date对象转换为String对象。
• 解析：按照指定的格式，从String对象转换为Date对象。

1、构造方法

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为：

• public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

参数pattern是一个字符串，代表日期时间的自定义格式。

2、格式规则

常用的格式规则为：

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档。

创建SimpleDateFormat对象的代码如：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class Demo02SimpleDateFormat {
    public static void main(String[] args) {
        // 对应的日期格式如：2018-01-16 15:06:38
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }
}
1
2
3
4
5
6
7
8

3、常用方法

DateFormat类的常用方法有：

• public String format(Date date)：将Date对象格式化为字符串。
• public Date parse(String source)：将字符串解析为Date对象。

1）format方法

使用format方法的代码为：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
把Date对象转换成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2）parse方法

使用parse方法的代码为：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
把String转换成Date对象
*/
public class Demo04DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = "2018年12月11日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三、练习

请使用日期时间相关的API计算一个人已经出生了多少天。

思路：

• 获取当前时间对应的毫秒值
• 获取自己出生日期对应的毫秒值
• 两个日期相减(当前时间-出生日期)

代码实现：

public static void function() throws Exception {
    System.out.println("请输入出生日期 格式 YYYY-MM-dd");
    // 获取出生日期,键盘输入
    String birthdayString = new Scanner(System.in).next();
    // 将字符串日期,转成Date对象
    // 创建SimpleDateFormat对象,写日期模式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    // 调用方法parse,字符串转成日期对象
    Date birthdayDate = sdf.parse(birthdayString);
    // 获取今天的日期对象
    Date todayDate = new Date();
    // 将两个日期转成毫秒值,Date类的方法getTime
    long birthdaySecond = birthdayDate.getTime();
    long todaySecond = todayDate.getTime();
    long secone = todaySecond-birthdaySecond;
    if (secone < 0){
    	System.out.println("还没出生呢");
    } else {
    	System.out.println(secone/1000/60/60/24);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

四、Calendar类

1、概念

对于日历，我们是再熟悉不过了。

java.util.Calendar是日历类，在Date之后出现，替换掉了许多Date的方法。该类将所有可能用到的事件信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

2、获取方式

Calendar为抽象类，由于语言敏感性，Calendar类在创建时并非直接创建，而是通过静态方法创建，返回子类对象，如下：

Calendar静态方法：

• public static Calendar getInstance()：使用默认时区和语言环境获得一个日历

例如：

import java.util.Calendar;
public class Demo06CalendarInit {
    public static void main(String[] args) {
    	Calendar cal = Calendar.getInstance();
    }
}
1
2
3
4
5
6

3、常用方法

根据Calendar类的API文档，常用方法有：

• public int get(int field)：返回指定日历字段的值。
• public void set(int field, int value)：将给定的日历字段设置为给定值。
• public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
• public Date getTime()：返回一个表示此Calendar时间值(从历元到现在的毫秒值偏移量)的Date对象。

Calendar类中提供了很多成员变量，代表给定的日历字段：

1）get/set方法

get方法用来获取指定字段的值，set方法用来设置指定字段的值，代码演示：

import java.util.Calendar;
public class CalendarUtil {
    public static void main(String[] args) {
        // 创建Calendar对象
        Calendar cal = Calendar.getInstance();
        // 设置年
        int year = cal.get(Calendar.YEAR);
        // 设置月
        int month = cal.get(Calendar.MONTH) + 1;
        // 设置日
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
    }
}

import java.util.Calendar;
public class Demo07CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2020);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2020年1月17日
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2）add方法

add方法可以对指定日历字段的值进行加减操作，如果第二个参数为正数则加上偏移量，如果为负数则减去偏移量。代码如下：

import java.util.Calendar;
public class Demo08CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日
        // 使用add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 减3年
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日;
    }
}
1
2
3
4
5
6
7
8
9
10
11

3）getTime方法

Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。

import java.util.Calendar;
import java.util.Date;
public class Demo09CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();
        System.out.println(date); // Tue Jan 16 16:03:09 CST 2018
    }
}
1
2
3
4
5
6
7
8
9

小贴士：

西方星期的开始为周日，中国为周一。

在Calendar类中，月份的表示是以0-11代表1-12月。

日期是有大小关系的，时间靠后，时间越大。

五、实例

• Date

package com.zzm.day12.demo02;

/**
 * 用途：
 * 时间：2021/6/27 22:13
 * 创建人：张子默
 */
/*
java.util.Date：表示日期和时间的类
类 Date 表示特定的瞬间，精确到毫秒。
毫秒：千分之一秒 1000毫秒=1秒
特定的瞬间：一个时间点，一刹那时间
2088-08-08 09:55:33:333 瞬间
2088-08-08 09:55:33:334 瞬间
2088-08-08 09:55:33:335 瞬间
...
毫秒值的作用：可以对时间和日期进行计算
2099-01-03 到 2088-01-01 中间一共有多少天
可以将日期转换为毫秒进行计算，计算完毕，再把毫秒转换成日期

把日期转换为毫秒
    当前日期：2088-01-01
    时间原点(0毫秒)：1970年1月1日 00:00:00(英国格林威治)
    就是计算当前日期到时间原点之间一共经历了多少毫秒(1624840753386)
注意：中国属于东八区，会把时间增加8个小时，1970年1月1日 08:08:00

把毫秒转换为日期：
    1 天 = 24 x 60 x 60 = 86400 秒 x 1000 = 86400000 毫秒
 */
public class Demo01Date {

    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis()); // 获取当前系统时间到1970年1月1日 00:00:00一共经历了多少毫秒
    }

}

package com.zzm.day12.demo02;

import java.util.Date;

/**
 * 用途：
 * 时间：2021/6/28 8:44
 * 创建人：张子默
 */
public class Demo02Date {

    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
    }

    /*
    long getTime()：把日期转换为毫秒值(相当于System.currentTimeMillis()方法)，返回自1970年1月1日 00:00:00 GMT 以来此Date对象表示的毫秒数。
     */
    private static void demo03() {
        Date date = new Date();
        System.out.println(date.getTime()); // 1624841876082
    }

    /*
    Date类带参数的构造方法
    Date(long date)传递毫秒值，把毫秒值转换为Date日期
     */
    private static void demo02() {
        Date date = new Date(1624840753386L);
        System.out.println(date); // Thu Jan 01 08:00:00 CST 1970
    }

    /*
    Date类的空参数构造方法
    Date()获取当前系统的日期和时间
     */
    private static void demo01() {
        Date date = new Date();
        System.out.println(date); // Mon Jun 28 08:50:37 CST 2021
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

• DateFormat

package com.zzm.day12.demo03;

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

/**
 * 用途：
 * 时间：2021/6/28 13:24
 * 创建人：张子默
 */

/*
java.text.DateFormat：是日期/时间格式化子类的抽象类
    作用：格式化(也就是日期 -> 文本)，解析(文本 -> 日期)
    成员方法：
        String format(Date date)：按照指定的模式，把Date日期格式化为符合模式的字符串。
        Date parse(String source)：把符合模式的字符串解析为Date日期
    DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat类的子类

java.text.SimpleDateFormat extends DateFormat
    构造方法：
        SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
            参数：String pattern：传递指定的模式
            模式：区分大小写
                y   年
                M   月
                d   日
                H   时
                m   分
                s   秒
            写对应的模式，会把模式替换为对应的日期和时间
                "yyy-MM-dd HH:mm:ss"
            注意：模式中的字母不能更改，连接模式的符号可以改变
                "yyy年MM月dd日 HH时mm分ss秒"
 */
public class Demo01DateFormat {

    public static void main(String[] args) throws ParseException {
        demo01();
        demo02();
    }

    /*
    使用DateFormate类中的方法parse，把文本解析为日期
    使用步骤：
        1.创建SimpleDateFormat对象，构造方法中传递指定的模式
        2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串解析为Date日期
    注意：
        public Date parse(String source) throws ParseException
        parse方法声明了一个异常叫PaseException
        如果字符串和构造方法的模式不一样，那么程序就会抛出此异常
        调用一个抛出了异常的方法，就必须得处理这个异常，要么throws继续抛出这个异常，要么try-catch自己处理
     */
    private static void demo02() throws ParseException {
        // 1.创建SimpleDateFormat对象，构造方法中传递指定的模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        // 2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串解析为Date日期
        // Date parse(String source)：把符合模式的字符串解析为Date日期
        Date date = sdf.parse("2021年06月28日 18时27分10秒");
        System.out.println(date); // Mon Jun 28 18:27:10 CST 2021
    }

    /*
    使用DateFormat类中的方法format，把日期格式转化为文本
        1.创建SimpleDateFormat对象，构造方法中传递指定的模式
        2.调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式把Date日期格式化为符合模式的字符串(文本)
     */
    private static void demo01() {
        // 1.创建SimpleDateFormat对象，构造方法中传递指定的模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        // 2.调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式把Date日期格式化为符合模式的字符串(文本)
        // String format(Date date)：按照指定的模式，把Date日期格式化为符合模式的字符串。
        Date date = new Date();
        String format = sdf.format(date);
        System.out.println(date); // Mon Jun 28 18:27:10 CST 2021
        System.out.println(format); // 2021年06月28日 18时27分10秒
    }

}

package com.zzm.day12.demo03;

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

/**
 * 用途：
 * 时间：2021/6/28 18:40
 * 创建人：张子默
 */

/*
练习：请使用日期时间相关的API，计算出一个人已经出生了多少天。
分析：
    1.使用Scanner类中的方法next，获取出生日期
    2.使用SimpleDateFormat类中的方法parse，把字符串的出生日期，解析为Date格式的出生日期
    3.把Date格式的出生日期转换为毫秒值
    4.获取当前的日期，转换为毫秒值
    5.使用当前日期的毫秒值-出生日期的毫秒值
    6.把毫秒值转换为天(s/1000/60/60/24)
 */
public class Demo02Test {

    public static void main(String[] args) throws ParseException {
        // 1.使用Scanner类中的方法next，获取出生日期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的出生日期，格式：yyyy-MM-dd");
        String birthdayDateString = sc.next();
        // 2.使用SimpleDateFormat类中的方法parse，把字符串的出生日期，解析为Date格式的出生日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sdf.parse(birthdayDateString);
        // 3.把Date格式的出生日期转换为毫秒值
        long birthdayDateTime = birthdayDate.getTime();
        // 4.获取当前的日期，转换为毫秒值
        long todayTime = new Date().getTime();
        // 5.使用当前日期的毫秒值-出生日期的毫秒值
        long time = todayTime - birthdayDateTime;
        // 6.把毫秒转换为天(s/1000/60/60/24)
        System.out.println(time/1000/60/60/24);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

• Calendar类

package com.zzm.day12.demo04;

import java.util.Calendar;

/**
 * 用途：
 * 时间：2021/6/28 19:36
 * 创建人：张子默
 */

/*
java.util.Calendar类，日历类
Calendar类是一个抽象类，里面提供了很多操作日历字段的方法(YEAR、MONTH、DAY_OFMONTH、HOUR)。
Calendar类无法直接创建对象使用，里面有一个静态方法叫getInstence()，该方法返回了Calendar类的一个子类对象。
static Calendar getInstance()使用默认时区和语言环境获得一个日历。
 */
public class Demo01Calendar {

    public static void main(String[] args) {
        Calendar c = Calendar.getInstance(); // 多态
        System.out.println(c);
    }

}

package com.zzm.day12.demo04;

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

/**
 * 用途：
 * 时间：2021/6/28 19:44
 * 创建人：张子默
 */

/*
Calendar类的常用成员方法：
    public int get(int field)：返回给定日历字段的值。
    public void set(int field, int value)：将指定的日历字段设置为给定的值。
    public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
    public Date getTime()：返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
    成员方法的参数：
        int field：日历类的字段，可以使用Calendar类的静态成员变量获取。
            public static final int YEAR = 1; 年
            public static final int MONTH = 2; 月
            public static final int DATE = 5; 月中的某一天
            public static final int DAY_OF_MONTH = 5; 月中的某一天
            public static final int HOUR = 10; 时
            public static final int MINUTE = 12; 分
            public static final int SECOND = 13; 秒
 */
public class Demo02Calendar {

    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
        demo04();
    }

    /*
    public Date getTime()：返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
    把日历对象转换为日起对象
     */
    private static void demo04() {
        // 使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        Date date = c.getTime();
        System.out.println(date);
    }

    /*
    public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
    把指定的字段增加/减少指定的值
    参数：
        int field：传递指定的日历字段(YEAR,MONTH...)
        intamount：增加/减少指定的值
            正数：增加
            负数：减少
     */
    private static void demo03() {
        // 使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        // 把年增加2年
        c.add(Calendar.YEAR, 2);
        // 把月份减少3个月
        c.add(Calendar.MONTH, -3);

        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month); // 西方的月份：0-11 东方：1-12

        // int date = c.get(Calendar.DAY_OF_MONTH);
        int date = c.get(Calendar.DATE);
        System.out.println(date);
    }

    /*
    public void set(int field, int value)：将指定的日历字段设置为给定的值。
        参数：
            int field：传递指定的日历字段(YEAR,MONTH...)
            int value：给指定字段设置的值
     */
    private static void demo02() {
        // 使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();

        // 设置年为9999
        c.set(Calendar.YEAR, 9999);
        // 设置月为9月
        c.set(Calendar.MONTH, 9);
        // 设置日为9日
        c.set(Calendar.DATE, 9);

        // 同时设置年月日，可以使用set的重载方法
        c.set(8888, 8, 8);

        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month); // 西方的月份：0-11 东方：1-12

        // int date = c.get(Calendar.DAY_OF_MONTH);
        int date = c.get(Calendar.DATE);
        System.out.println(date);
    }

    /*
    public int get(int field)：返回给定日历字段的值。
        参数：传递指定的日历字段(YEAR,MONTH...)
        返回值：日历字段代表的具体的值
     */
    private static void demo01() {
        // 使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month); // 西方的月份：0-11 东方：1-12

        // int date = c.get(Calendar.DAY_OF_MONTH);
        int date = c.get(Calendar.DATE);
        System.out.println(date);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153