图片问题晚些时候修复 如果发现错误可以的话帮我纠正下，谢谢！

Ⅰ.JDK8以前时间相关类

一.Date的常用方法

1.创建日期对象的格式

JDK8以后，可以用LocalDateTime去创建，不用这么复杂了。

(1)无参构造：

分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

Data 对象 = new Date();

(2)含参构造：

分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

Data 对象 = new Date(指定毫秒值);

(3)创建当前时间的日期对象

long 对象 = System.currentTimeMillis();

2.修改时间对象中的毫秒值SetTime

下面的time(单位:毫秒）设置的是距离1970 年 1 月 1 日 00:00:00 GMT多少毫秒

对应方法：Date对象.setTime(time);

**作用：**设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。

public class DateDemo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();
        
        //public void setTime(long time):设置时间，给的是毫秒值
        //long time = 1000*60*60;
        //System.currentTimeMillis()是一个System类中的方法，用于返回当前时间的毫秒数。
        long time = System.currentTimeMillis();
        //将返回的毫秒值设置给日期对象——d
        d.setTime(time);

        System.out.println(d);//Tue Dec 12 16:39:55 SGT 2023(每次结果随运行时间而定)
    }
}

3.获取时间对象中的毫秒值getTime

这个方法在时间计算时经常用到，把date对象转换为距离计算机时间原点的毫秒值，从而用于时间的计算、判断。

对应方法：Date对象.getTime();

**作用：**返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

(1)例程：

public class DateDemo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();
        
        //public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
        System.out.println(d.getTime());////1702370617089(同样和运行的时间有关)
        
    }
}

4.小结

Date表示特定的时间瞬间，我们可以使用Date对象对时间进行操作。

二.SimpleDateFormat类

这是一个时间格式化类，可以格式化Date输出的时间，也可以将时间类转成文本类，方便输出

1.主要功能

  • 格式化：按照指定的格式，把Date对象转换为String对象。
    • 把Date对象转成2023年12月11日
  • 解析：按照指定的格式，把String对象转换为Date对象。再通风Date对象获取毫秒值以计算
    • 把2023年12月11日转成Date对象以计算

2.构造方法

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

构造方法 说明
public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认格式
public SimpleDateFormat(String pattern) 构造一个SimpleDateFormat，使用指定格式

(1)默认格式的创建

SimpleDateFormat 对象 = new SimpleDateFormat();

(2)指定格式的创建

构造时传入格式化规则

 SimpleDateFormat 对象 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

3.格式规则(String pattern)

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

常用的格式规则为：

标识字母（区分大小写） 含义
y 年
M 月
d 日
H 时
m 分
s 秒

规则编写范例：yyyy-MM-dd HH:mm:ss

4.常用的方法

常用的方法 说明
public String format(Date date) 格式化(日期对象 ——> 字符串)
public Date parse(String source) 解析(字符串 ——> 日期对象)

(1)日期对象格式化为字符串Format(格式化)

例子：

使用空参/含参simpleDateFormat对象对日期对象进行格式化

    private static void method1() {
        //1.利用空参构造创建simpleDateFormat对象，默认格式
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        Date d1 = new Date(0L);
        //对Date对象进行格式化
        String str1 = sdf1.format(d1);
        System.out.println(str1);//1970/1/1 上午8:00

        //2.利用带参构造创建simpleDateFormat对象，指定格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        String str2 = sdf2.format(d1);
        System.out.println(str2);//1970年01月01日 08:00:00

    }

(2)字符串转为日期对象Parse(解析)

注意：使用parse解析字符串，其SimpleDateFormat中的规则，必须与待解析字符串格式一致

**例如：**下面的字符串是"2023-11-11 11:11:11",则对应的规则是"yyyy-MM-dd HH:mm:ss"

public class Test2 {
    public static void main(String[] args) {
        //1.定义一个字符串表示时间
        String str = "2023-11-11 11:11:11";
        //2.利用空参构造创建simpleDateFormat对象
        // 细节:
        //创建对象的格式要跟字符串的格式完全一致
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //将字符串解析成Date数据
        Date d1 = sdf.parse(str);
        //3.打印结果，获取Date数据的毫秒值
        System.out.println(d1.getTime());//1699672271000
    }
}

三.Calendar类(日历类)

java.util.Calendar类表示一个“日历类”，可以进行日期运算。它是一个抽象类，不能创建对象，我们可以使用它的子类：java.util.GregorianCalendar类。

1.获取Calendar类的对象

Calendar是一个抽象类,不能直接new,而是通过一个静态方法获取到子类对象,有两种方式可以获取GregorianCalendar对象：

2.底层原理

根据系统的不同时区来获取不同的日历对象(中国是公历)；默认表示当前时间。

会把时间中的"纪元、年、月、日、时、分、秒、星期等"都放到一个数组中

3.创建对象

获取对象的时候，其默认获取的是当前系统的时间

  • 直接创建GregorianCalendar对象；

  • 通过Calendar的静态方法getInstance()方法获取GregorianCalendar对象

    Calendar 对象 = Calendar.getInstance();

4.常用方法

方法名 说明
public static Calendar getInstance() 获取一个它的子类GregorianCalendar对象。
public int get(int field) 获取某个字段(日历变量)的值。field参数表示获取哪个字段的值
public void set(int field,int value) 1.设置某个字段的值;设置年为2000，field=Calendar.YEAR，valu=20002.直接填入Date对象会修改全部信息为Date的信息
public void add(int field,int amount) 为某个字段增加(正数)/减少(负数)指定的值

(1).对象中的参数(field)

i.用索引表示(弃用)
  • 0：纪元
  • 1：年
  • 2：月
  • 3：一年中的第几周
  • 4：一个月中的第几周
  • 5：一个月的第几天(日期)
  • ....
ii.用Calender中定义的常量来表示(主用)
  • Calendar.YEAR : 年
  • Calendar.MONTH ：月
    • 范围是0~11; 获取出来是0,实际对应月份是1，可以通过+1进行矫正。
    • 如果传入数值超过11，它会往后顺延，不会报错
  • Calendar.DAY_OF_MONTH：月中的日期
  • Calendar.HOUR：小时
  • Calendar.MINUTE：分钟
  • Calendar.SECOND：秒
  • Calendar.DAY_OF_WEEK：星期(周日表示一周第一天)
    • 星期的定义遵循了国外的习惯：星期日是一周的第一天
      • 从这个类中获取的是1则其代表的是周日。
      • 可以通过查表法，使其符合国人习惯

(2).get方法示例：

获取日历对象某个字段内容

public class Demo {
    public static void main(String[] args) {
        //1.获取一个GregorianCalendar对象
        Calendar instance = Calendar.getInstance();//获取子类对象

        //2.打印子类对象
        System.out.println(instance);//打印出来一个集合，内容就是系统的时间信息

        //3.获取属性
        int year = instance.get(Calendar.YEAR);
        int month = instance.get(Calendar.MONTH) + 1;//Calendar的月份值是0-11
        int day = instance.get(Calendar.DAY_OF_MONTH);

        int hour = instance.get(Calendar.HOUR);
        int minute = instance.get(Calendar.MINUTE);
        int second = instance.get(Calendar.SECOND);

        int week = instance.get(Calendar.DAY_OF_WEEK);//返回值范围：1--7，分别表示："星期日","星期一","星期二",...,"星期六"

        System.out.println(year + "年" + month + "月" + day + "日" + 
                           	hour + ":" + minute + ":" + second);
        System.out.println(getWeek(week));

    }

    //查表法，查询星期几
    public static String getWeek(int w) {//w = 1 --- 7
        //做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        //查表
        return weekArray[w - 1];
    }
}

(3).set方法示例：

设置日历对象某个字段的信息

public class Demo {
    public static void main(String[] args) {
        //设置属性——set(int field,int value):
		Calendar c1 = Calendar.getInstance();//获取当前日期

		//计算班长出生那天是星期几(假如班长出生日期为：1998年3月18日)
		c1.set(Calendar.YEAR, 1998);
		c1.set(Calendar.MONTH, 3 - 1);//转换为Calendar内部的月份值
		c1.set(Calendar.DAY_OF_MONTH, 18);

		int w = c1.get(Calendar.DAY_OF_WEEK);
		System.out.println("班长出生那天是：" + getWeek(w));

        
    }
    //查表法，查询星期几
    public static String getWeek(int w) {//w = 1 --- 7
        //做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        //查表
        return weekArray[w - 1];
    }
}

(4).add方法示例：

这个就是Calendar这个类的优点了，可以以更加直观的方式增加日期。

如加一个月：对象.add(Calendar.MONTH, 1);

public class Demo {
    public static void main(String[] args) {
        //计算200天以后是哪年哪月哪日，星期几？
		Calendar c2 = Calendar.getInstance();//获取当前日期
        c2.add(Calendar.DAY_OF_MONTH, 200);//日期加200

        int y = c2.get(Calendar.YEAR);
        int m = c2.get(Calendar.MONTH) + 1;//转换为实际的月份
        int d = c2.get(Calendar.DAY_OF_MONTH);

        int wk = c2.get(Calendar.DAY_OF_WEEK);
        System.out.println("200天后是：" + y + "年" + m + "月" + d + "日" + getWeek(wk));

    }
    //查表法，查询星期几
    public static String getWeek(int w) {//w = 1 --- 7
        //做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        //查表
        return weekArray[w - 1];
    }
}

Ⅱ.JDK8时间相关类

零.新增的类

JDK8时间类类名 作用
ZoneId 时区(洲名/城市名)(国家名/城市名)
Instant 时间戳
ZoneDateTime 带时区的时间
DateTimeFormatter 用于时间的格式化和解析
LocalDate 年、月、日
LocalTime 时、分、秒
LocalDateTime 年、月、日、时、分、秒
Duration 时间间隔（秒，纳，秒）
Period 时间间隔（年，月，日）
ChronoUnit 时间间隔（所有单位）

一.ZoneId 时区

方法 说明
static Set getAvailableZoneIds() 获取Java中支持的所有时区
static ZoneId systemDefault() 获取系统默认时区
static Zoneld of(string zoneld) 获取一个指定时区

1.获取支持时区的名称

不知道有什么时区的时候用用得了。其实更好得办法是直接去网上检索😂

注：Set虽然是集合但其并没有索引

Set 集合对象 = ZoneId.getAvailableZoneIds();

(1).通过直接打印集合对象，就可以知道支持那几个时区了

System.out.println(集合对象);//输出就略了，很多

(2).可以通过集合对象.size获知其集合长度是600，即支持600个国家

System.out.println(zoneIds.size());//600

2.获取当前系统的默认时区

使用systemDefault()方法获得的数据的类型是zoneId类型的

ZoneId 对象 = ZoneId.systemDefault();
System.out.println(对象);//Asia/Shanghai

3.获取指定的时区

ZoneId 对象 = ZoneId.of("时区信息");

例如：

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

二.Instead 时间戳

方法 说明
static Instant now() 获取当前时间的Instant对象(标准时间)
static Instant ofXxxx(long epochMilli) 根据(秒/毫秒/纳秒)获取Instant对象
ZonedDateTime atZone(ZoneIdzone) 指定时区
boolean isxxx(Instant otherInstant) 判断时间的方法
Instant minusXxx(long millisToSubtract) 减少时间系列的方法
Instant plusXxx(long millisToSubtract) 增加时间系列的方法

1.获取当前时间的Instant对象

Instead对象是不带时区的，它所表示的时间都是标准时间

(1)获取当前时间的Instant对象(标准时间)

其获取的"当前时间"是指世界标准时间，和中国的时区是不一样的

Instant 对象 = Instant.now();

(2)根据(秒/毫秒/纳秒)获取Instant对象

i.获取的数据类型是Instead类型的。

ii.方法调用括号中填入的"秒/毫秒/纳秒"，是指定其距离计算机时间原点的时间(根据不同单位，方法也不同)

image-20231212145304143 
Instant 对象 = Instant.ofEpochXxxx(秒/毫秒/纳秒);

例子：

//根据毫秒值获取时间对象
Instant instant1 = Instant.ofEpochMilli(0L);
System.out.println(instant1);//1970-01-01T00:00:00z
//根据秒/纳秒获取时间对象
Instant instant2 = Instant.ofEpochSecond(1L);
System.out.println(instant2);//1970-01-01T00:00:01Z
//根据秒获取时间对像
Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);
System.out.println(instant3);//1970-01-01T00:00:027

2.Instead指定时区创建ZoneDateTime对象

1.它的参数是ZoneID zone所以需要调用ZoneID的方法才能传入参数

image-20231212152815968

2.由最后承接其的对象类型可知，此时其已经不是Instead对象了，而成为了ZoneDateTime类型

ZonedDateTime 对象 = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(time);

3.isXxx 判断

其包含多个判断方法，这里主要理解他比较前后的方法就好。

image-20231212150515234

(1)判断一个调用对象时间是否在参数对象时间前面

对应方法：isBefore

例子：

比较instead4在不在instead5的前面

boolean result1=instant4.isBefore(instant5);//4在不在5的前面
System.out.println(result1);//true

(2)判断一个调用对象时间是否在参数对象时间后面

对应方法：isAfter

例子：

比较instead4是不是在instead5的后面

boolean result2 = instant4.isAfter(instant5);
System.out.println(result2);//false

4.Instead minusXxx() 减时间的方法

instead对象都是只读对象，所以加减操作都不会改变原始对象的值，而是会另外创建一个新的对象

格式：Instant minusXxx(long millisToSubtract)

**注意：**根据单位的不同，分为不同的方法

image-20231212151816383

(1)例子

在instead6的基础上减一秒，产生instead7

Instant instant6 =Instant.ofEpochMilli(3000L);
System.out.println(instant6);//1970-01-01T00:00:03Z

Instant instant7 =instant6.minusSeconds(1);
System.out.println(instant7);//1970-01-01T00:00:02Z

5.Instant plusXxx(） 加时间的方法

类似于减去时间，这里不赘述

三.ZoneDateTime 带时区的时间

方法 说明
static ZonedDateTime now() 获取当前时间的ZonedDateTime对象
static ZonedDateTime ofXxxx() 获取指定时间的ZonedDateTime对象
ZonedDateTime withXxx(时间) 修改时间系列的方法
ZonedDateTime minusXxx(时间) 减少时间系列的方法
ZonedDateTime plusXxx(时间) 增加时间系列的方法

1.获取当前时间对象(带时区)

格式：ZonedDateTime 对象 = ZonedDateTime.now();

2.获取指定时间的时间对象(带时区)

用年、月、日、时、分、秒、纳秒的方式指定

格式：

ZonedDateTime time1 = ZonedDateTime.of(年, 月, 日,
                                       时, 分, 秒, 纳秒, ZoneId.of("时区"));

例子：

ZonedDateTime time1 = ZonedDateTime.of(2023, 10, 1,
                                       11, 12, 12, 0, ZoneId.of("Asia/Shanghai"));

3.通过Instead + 时区的方式指定获取时间对象

Instant instant = Instant.ofEpochMilli(0L);
ZoneId zoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(time2);

4.withXxx 修改时间系列的方法

instead对象都是只读对象，所以修改时间操作并不会改变原始对象的值，而是需要另外创建一个新的对象来承接

格式：ZonedDateTime 承接对象 = 待修改对象.withXxx(修改信息);

同样存在多个方法，需要时去帮助文档找就好了

image-20231212154537896

例子：

将time2这个时间对象里的年修改为2000，并赋值给time3

ZonedDateTime time3 = time2.withYear(2000);
System.out.println(time3);

5.减少&增加时间

例子：

//4. 减少时间
ZonedDateTime time4 = time3.minusYears(1);
System.out.println(time4);

//5.增加时间
ZonedDateTime time5 = time4.plusYears(1);
System.out.println(time5);

四.DateTimeFormatter时间的格式化和解析

1.格式

(1)创建解析/格式化器

static DateTimeFormatter ofPattern(格式) 获取格式对象

例子：

DateTimeFormatter dtf1=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm;ss EE a");

(2)调用解析器格式化

String format(时间对象) 按照指定方式格式化

例子

System.out.println(dtf1.format(time));

五.LocalDateTime(新的时间类)

可以理解为这是JDK8新增的时间对象，其无需用毫秒值指定，可以直接传输具体信息从而建立对应的时间对象

1.LocalDate(年、月、日)

这里的月份是正常值，不用从0开始算，这里是：0~12

(1)格式：

Ⅰ.创建系统时间对象
LocalDate 对象 = LocalDate.now();
Ⅱ.创建指定时间对象

使用LocalDate.of()去指定

image-20231213122444009

LocalDate 对象 = LocalDate.of(int year,int month,int dayofMonth);

2.LocalTime(时、分、秒)

(1)格式

Ⅰ.创建系统时间对象
LocalDate 对象 = LocalDate.now();
Ⅱ.创建指定时间对象

使用LocalDate.of()去指定

image-20231213122544924

LocalDate 对象 = LocalDate.of(int hour,int minute,int second);

3.LocalDateTime(年、月、日、时、分、秒)

(1)格式

Ⅰ.创建系统时间对象
LocalDateTime i = LocalDateTime.now();
//i:2023-12-13T12:29:20.238250500
Ⅱ.创建指定时间对象

使用LocalDate.of()去指定

image-20231213123049440

LocalDate 对象 = LocalDate.of(参数);

六.工具类，计算时间间隔

1.Duration 时间间隔（秒，纳，秒）

(1)创建对象

时间间隔就是第二个参数减第一个参数

Duration 对象 = Duration.between(参数1, 参数2);

(2)结果的获取

直接用Duration类获取的对象就是Duration类型的，不能算作可用数据，要对他进行转换

  • toDays():转成时间差的天数
  • toHours():转成时间差的小时数
  • toMinutes():转成时间差的分钟数
  • toMillis():转成时间差的毫秒数
  • toNanos():转成时间差的纳秒数

(3)例程

利用between方法计算时间间隔

// 本地日期时间对象。
LocalDateTime today = LocalDateTime.now();
System.out.println(today);

// 出生的日期时间对象
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1, 0, 0, 0);
System.out.println(birthDate);

Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数
System.out.println("相差的时间间隔对象:" + duration);

System.out.println("============================================");
System.out.println(duration.toDays());//两个时间差的天数
System.out.println(duration.toHours());//两个时间差的小时数
System.out.println(duration.toMinutes());//两个时间差的分钟数
System.out.println(duration.toMillis());//两个时间差的毫秒数
System.out.println(duration.toNanos());//两个时间差的纳秒数

2.Period 时间间隔（年，月，日）

利用between方法计算时间间隔

(1)创建对象

时间间隔就是第二个参数减第一个参数

Period period = Period.between(参数1, 参数2);

(2)获取结果

同样的，获取的结果也要通过相应的方法转化才能是我们需要的数据

  • getYears:获取间隔年
  • getMonths:获取间隔月
  • getDays:获取间隔天

(3)例程

// 当前本地 年月日
LocalDate today = LocalDate.now();
System.out.println(today);

// 生日的 年月日
LocalDate birthDate = LocalDate.of(2000, 1, 1);
System.out.println(birthDate);

Period period = Period.between(birthDate, today);//第二个参数减第一个参数

System.out.println("相差的时间间隔对象:" + period);
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
//将间隔转换为间隔了多少个月
System.out.println(period.toTotalMonths());

3.ChronoUnit 时间间隔（所有单位）

利用between方法计算时间间隔

(1)创建对象

XXX:根据要计算时间的间隔会存在区别，计算日用DAYS,计算年用YEARS等等，具体看下面例程

ChronoUnit.XXX.between(birthDate, today)

(2)例程

// 当前时间
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 生日时间
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1,0, 0, 0);
System.out.println(birthDate);

System.out.println("相差的年数:" + ChronoUnit.YEARS.between(birthDate, today));
System.out.println("相差的月数:" + ChronoUnit.MONTHS.between(birthDate, today));
System.out.println("相差的周数:" + ChronoUnit.WEEKS.between(birthDate, today));
System.out.println("相差的天数:" + ChronoUnit.DAYS.between(birthDate, today));
System.out.println("相差的时数:" + ChronoUnit.HOURS.between(birthDate, today));
System.out.println("相差的分数:" + ChronoUnit.MINUTES.between(birthDate, today));
System.out.println("相差的秒数:" + ChronoUnit.SECONDS.between(birthDate, today));
System.out.println("相差的毫秒数:" + ChronoUnit.MILLIS.between(birthDate, today));
System.out.println("相差的微秒数:" + ChronoUnit.MICROS.between(birthDate, today));
System.out.println("相差的纳秒数:" + ChronoUnit.NANOS.between(birthDate, today));
System.out.println("相差的半天数:" + ChronoUnit.HALF_DAYS.between(birthDate, today));
System.out.println("相差的十年数:" + ChronoUnit.DECADES.between(birthDate, today));
System.out.println("相差的世纪(百年)数:" + ChronoUnit.CENTURIES.between(birthDate, today));
System.out.println("相差的千年数:" + ChronoUnit.MILLENNIA.between(birthDate, today));
System.out.println("相差的纪元数:" + ChronoUnit.ERAS.between(birthDate, today));

4.判断平闰年

(1)isLeapYear()

闰年返回：true

平年返回：flase

最后修改：2023 年 12 月 13 日
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏