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

Ⅰ.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<string> getAvailableZoneIds()获取Java中支持的所有时区
static ZoneId systemDefault()获取系统默认时区
static Zoneld of(string zoneld)获取一个指定时区

1.获取支持时区的名称

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

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

Set<String> 集合对象 = 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 日
如果觉得我的文章对你有用,请随意赞赏