图片问题晚些时候修复 如果发现错误可以的话帮我纠正下,谢谢!
Ⅰ.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=2000 2.直接填入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,它会往后顺延,不会报错
- 范围是0~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 |
获取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](http://cdn.honestliu.com/image/image-202312121453041435KQk7eyfnY20231212145349b2535adbb75171.jpg)
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
的方法才能传入参数![]()
2.由最后承接其的对象类型可知,此时其已经不是Instead对象了,而成为了ZoneDateTime类型
ZonedDateTime 对象 = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(time);
3.isXxx 判断
其包含多个判断方法,这里主要理解他比较前后的方法就好。
![image-20231212150515234](http://cdn.honestliu.com/image/image-20231212150515234SyUdvnKKxN2023121215053d2a4d8a5b4f757b.jpg)
(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)
**注意:**根据单位的不同,分为不同的方法
(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](http://cdn.honestliu.com/image/image-20231212154537896sgkzBQ9C5N202312121545e22073d80836b0cf.jpg)
例子:
将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()
去指定
LocalDate 对象 = LocalDate.of(int year,int month,int dayofMonth);
2.LocalTime(时、分、秒)
(1)格式
Ⅰ.创建系统时间对象
LocalDate 对象 = LocalDate.now();
Ⅱ.创建指定时间对象
使用LocalDate.of()
去指定
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()
去指定
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