【JAVA入门】Day21 - 时间类
文章目录
Java 中的时间有一些相关类，它们都与时间的编程息息相关。
一、JDK7前的时间相关类
| 类名 | 作用 |
|---|---|
| Date | 时间类 |
| SimpleDateFormat | 格式化时间 |
| Calender | 日历类 |
世界上的时间，是有一个统一的计算标准的。
曾经的世界时间标准被称作 格林尼治时间 / 格林威治时间 (Greenwich Mean Time)，简称GMT。GMT 的计算核心是：地球自转一天是24小时，太阳直射时为正午12点。但是由于误差太大，现在 GMT 已经被舍弃。
现在的世界时间标准是利用原子钟规定的，利用铯原子的振动频率计算出来的时间，作为世界标准时间（UTC）。
中国地处东八区，要在世界标准时间的基础上 + 8小时。
1.1 Date
Date 类是 JDK 写好的一个 Javabean 类，用来描述时间，精确到毫秒。
利用空参构造创建的对象，默认表示为系统当前时间。
利用有参构造创建的对象，表示为指定的时间。
| 方法 | 作用 |
|---|---|
| public Date() | 创建Date对象，表示系统当前时间 |
| public Date(long date) | 创建Date对象，表示指定时间 |
| public void setTime(long time) | 设置/修改毫秒值 |
| public long getTime() | 获取时间对象的毫秒值 |
【练习】学习使用Date类。
package DateClass;
import java.util.Date;
import java.util.Random;
public class DateDemo2 {
public static void main(String[] args) {
//需求一：打印一年后的时间
extracted();
//需求二：比较两个Date对象哪个在前哪个在后
extracted1();
}
private static void extracted() {
//1.打印时间原点一年后的时间
Date d1 = new Date(0L);
//2.获取d1的毫秒值
long time = d1.getTime();
//3.加上一年后的毫秒值
time = time + 1000L * 60 * 60 * 24 * 365;
//4.把计算后的时间毫秒值，设置回d1中
d1.setTime(time);
//5.打印
System.out.println(d1);
}
private static void extracted1() {
Random r = new Random();
//创建两个时间对象
Date d1 = new Date(r.nextInt());
Date d2 = new Date(r.nextInt());
System.out.println(d1);
System.out.println(d2);
long time1 = d1.getTime();
long time2 = d2.getTime();
if(time1 > time2) {
System.out.println("d2在前，d1在后");
} else if(time2 > time1) {
System.out.println("d1在前，d2在后");
} else {
System.out.println("两时间一样");
}
}
}
}
1.2 SimpleDateFormat
Date 类只能以默认的格式展示，不符合人们的阅读习惯。
SimpleDateFormat 可以把日期格式化；也可以解析日期，即把字符串表示的时间编程 Date 对象。
| 构造方法 | 说明 |
|---|---|
| public SimpleDateFormat() | 构造一个SimpleDateFormat对象，使用默认格式 |
| public SimpleDateFormat(String pattern) | 构造一个SimpleDateFormat对象，使用指定的格式 |
| 常用方法 | 说明 |
|---|---|
| public final String format(Date date) | 格式化（日期对象 -> 字符串） |
| public Date parse(String source) | 解析（字符串 -> 日期对象） |
格式化的时间形式的常用模式对应关系如下：
【练习1】练习使用SimpleDateFormat。
package DateClass;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo3 {
public static void main(String[] args) throws ParseException {
//需求一：格式化时间
method1();
//需求二：解析字符串
method2();
}
private static void method2() throws ParseException {
//1.定义一个字符串用来表示时间
String str = "2023-11-11 11:11:11";
//2.利用空参构造创建SimpleDateFormat对象
//其创建的格式参数要和字符串的格式完全一致
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//解析字符串，变为时间对象
Date date = sdf.parse(str);
//打印毫秒值
System.out.println(date.getTime());
}
private static void method1() {
//1.利用空参构造创建SimpleDateFormat对象，默认格式
SimpleDateFormat sdf = new SimpleDateFormat();
Date d1 = new Date(0L);
String str = sdf.format(d1);
System.out.println(str); //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
//3.格式2
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 EE");
String str3 = sdf3.format(d1);
System.out.println(str3); //1970年01月01日 08时00分00秒 周四
}
}
【练习2】把一个日期转换为另一种格式。
package DateClass;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo4 {
public static void main(String[] args) throws ParseException {
/*2000-11-11*/
String str = "2000-11-11";
//1.解析字符串为日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(str);
//2.格式化日期为年月日
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日");
String result = sdf1.format(date);
//3.打印
System.out.println(result);
}
}
【练习3】判断两个同学是否秒杀成功。
package DateClass;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo5 {
public static void main(String[] args) throws ParseException {
/*需求：
秒杀活动：2023年11月11日 0:0:0
开始时间：2023年11月11日 0:10:0
小贾下单付款时间：2023年11月11日 0:01:00
小皮下单付款时间：2023年11月11日 0:11:00
计算两个人有没有参加成功
*/
//1.比较两个时间
String startStr = "2023年11月11日 0:0:0";
String endStr = "2023年11月11日 0:10:0";
String orderStr1 = "2023年11月11日 0:01:0";
String orderStr2 = "2023年11月11日 0:11:00";
//2.解析上面的时间，得到Date对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date startDate = sdf.parse(startStr);
Date endDate = sdf.parse(endStr);
Date orderDate1 = sdf.parse(orderStr1);
Date orderDate2 = sdf.parse(orderStr2);
//3.得到所有时间的毫秒值
long startTime = startDate.getTime();
long endTime = endDate.getTime();
long orderTime1 = orderDate1.getTime();
long orderTime2 = orderDate2.getTime();
//4.判断
if((startTime <= orderTime1)&&(orderTime1 <= endTime)) {
System.out.println("小贾同学秒杀成功了！");
}else{
System.out.println("小贾同学秒杀失败了...");
}
if((startTime <= orderTime2)&&(orderTime2 <= endTime)) {
System.out.println("小皮同学秒杀成功了！");
}else{
System.out.println("小皮同学秒杀失败了...");
}
}
}
1.3 Calendar
Calendar 就是日历类，它是时间类的补充，可以单独修改、获取事件中的年，月，日。
值得注意的是，Calendar 是一个抽象类，它不能直接创建对象。
我们需要通过一个静态方法来获取当前时间的日历对象。
public static Calendar getInstance()
Calendar 中常用的方法有这些：
| 方法名 | 说明 |
|---|---|
| public final Date getTime() | 获取日期对象 |
| public final setTime(Date date) | 给日历设置日期对象 |
| public long getTimeInMillis() | 拿到时间的毫秒值 |
| public void setTimeInMillis(long millis) | 给日历设置时间毫秒值 |
| public int get(int field) | 取得日历中某个字段的信息 |
| public void set(int field,int value) | 修改日历中的某个字段信息 |
| public void add(int field,int amount) | 为某个字段增加/减少指定的值 |
下面通过一个练习，熟悉一下这些方法。
package DateClass;
import java.util.Calendar;
import java.util.Date;
public class CalenderDemo1 {
public static void main(String[] args) {
//1.获取日历对象
//Calender是一个抽象类，不能直接new，而是通过一个静态方法获取子类对象
Calendar c = Calendar.getInstance();
//底层原理：
//会根据系统的不同时区来获取不同的日历对象
//把时间中的纪元，年，月，日，时，分，秒，星期，等等放到一个数组当中
//2.修改一下日历代表的时间为时间原点
//获取的时间信息有细节
// 月份范围：0~11，0代表一月，11代表十二月
// 星期：星期日是第一天，值为1；星期六的值为7
Date d = new Date(0L);
c.setTime(d);
//3.获取日期中某个字段信息
//参数为int类型
//0:纪元 1:年 2:月 3:一年中的第几周 ...
//Java当中，把索引数字都定义为了常量
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int date = c.get(Calendar.DAY_OF_MONTH);
int week = c.get(Calendar.DAY_OF_WEEK);
System.out.println(year + ", " + month + ", "+ date+ ", " + getWeek(week));
//4.修改日历中某个字段
c.set(Calendar.YEAR, 2000);
c.set(Calendar.MONTH,12);
//月份12是指13月，这是不存在的
//系统会自动把年份调成次年
//5.为某个字段增加/减少值
c.add(Calendar.MONTH, -1);
}
//传入对应的数字：1~7
//返回对应的星期
//查表法：在方法中让数据跟索引产生对应关系
public static String getWeek(int index) {
String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
return arr[index];
}
}
二、JDK8新增的时间相关类
JDK8 新增的时间相关类，解决了 JDK7 代码麻烦的问题，而且在安全层面下有了突破。
JDK7 在多线程环境下会导致数据安全问题产生，而 JDK8 的时间日期对象都是不可变的，解决了这个问题。
JDK8 主要新增了以下四种类：
2.1 Date 相关类
2.1.1 ZoneId 时区
时区类常用方法如下。
package DateClass;
import java.time.ZoneId;
import java.util.Set;
public class CalenderDemo2 {
public static void main(String[] args) {
/*
时区
*/
//1.获取所有的时区名称
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
System.out.println(zoneIds);
System.out.println(zoneIds.size());
//2.获取当前系统的默认时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId);
//3.获取指定的时区
ZoneId zoneId1 = ZoneId.of("Asia/Aqtau");
System.out.println(zoneId1);
}
2.1.2 Instant 时间戳
时间戳是一种新的计算时间方法，它可以精确到时间的纳秒值（标准时间）。
package DateClass;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class DateDemo6 {
public static void main(String[] args) {
//1.获取当前时间的Instant对象（标准时间）
Instant now = Instant.now();
System.out.println(now); //2024-08-16T10:35:23.164490400Z
//2.根据（秒/毫秒/纳秒）获取Instant对象
//获取原初时间戳
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
//获取1秒+1000000000纳秒后的时间
Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);
System.out.println(instant3); //1970-01-01T00:00:02Z
//3.指定时区
//指定时区后再获得当前系统时间，中国在东八区，会自动加上8个小时
ZonedDateTime zonedDateTime = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(zonedDateTime); //2024-08-16T18:45:01.710355900+08:00[Asia/Shanghai]
//4.isXxx 判断
Instant instant4 = Instant.ofEpochMilli(0L);
Instant instant5 = Instant.ofEpochMilli(1000L);
boolean result1 = instant4.isBefore(instant5);
System.out.println(result1); //true
boolean result2 = instant4.isAfter(instant5);
System.out.println(result2); //false
//5.增减时间
Instant instant6 = Instant.ofEpochMilli(3000L);
System.out.println(instant6); //1970-01-01T00:00:03Z
Instant instant7 = instant6.minusSeconds(1L);
System.out.println(instant7); //1970-01-01T00:00:02Z
Instant instant8 = instant6.plusMillis(5000L);
System.out.println(instant8); //1970-01-01T00:00:08Z
}
}
2.1.3 ZoneDateTime 带时区的时间
带时区的时间就是带上时区的时间。
package DateClass;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class DateDemo7 {
public static void main(String[] args) {
//1.获取当前带时区的时间对象
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);
//2.获取指定的带时区时间对象
//年月日时分秒纳秒方式指定
ZonedDateTime time1 = ZonedDateTime.of(2023,10,1,11,12,12,0, ZoneId.of("Asia/Shanghai"));
System.out.println(time1);
//通过Instant + 时区的方式获取指定时间对象
Instant instant = Instant.ofEpochMilli(0L);
ZoneId zoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(time2); //1970-01-01T08:00+08:00[Asia/Shanghai]
//3.withXxx 修改时间系列的方法，可以单独修改年月日等
ZonedDateTime time3 = time2.withYear(2000);
System.out.println(time3); //2000-01-01T08:00+08:00[Asia/Shanghai]
//4.减少时间
ZonedDateTime time4 = time3.minusYears(1);
System.out.println(time4);
//5.增加时间
ZonedDateTime time5 = time3.plusYears(1);
System.out.println(time5);
//细节：
//JDK8新增的时间对象都是不可变的
//如果我们进行任何形式的修改，调用者本身都不会改变，而是会产生一个新的时间
}
}
2.2 DateTimeFormat 相关类
2.2.1 DateTimeFormatter 时间的格式化和解析类
两个方法用来时间格式化和解析。被解析的时间对象可以是ZonedDateTime （带时区的时间类对象）。
package DateClass;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
public class DateDemo8 {
public static void main(String[] args) {
//获取时间对象
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
//生成对象
DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EE a");
//格式化时间对象
System.out.println(dtf1.format(time));
}
}
2.3 Calendar 相关类
2.3.1 LocalDate、LocalTime、LocalDateTime
这三个类是这种关系，LocalDateTime 能表示的最全，年月日时分秒都可以，LocalDate 只能表示年月日，LocalTime 只能表示时分秒。LocalDate 和 LocalTime 之间可以互转。
LocalDate 类用法如下。
package DateClass;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.MonthDay;
public class LocalDateDemo {
public static void main(String[] args) {
//1.获取当前时间的日历对象（包含年月日）
LocalDate nowDate = LocalDate.now();
//2.获取指定的时间的日历对象
LocalDate ldDate = LocalDate.of(2023, 1, 1);
System.out.println("指定日期:" + ldDate);
System.out.println("===============================");
//3.get系列方法获取日历中的每一个属性值
//获取年
int year = ldDate.getYear();
System.out.println("year:" + year);
//获取月
//方式一：通过Month对象获取
Month m = ldDate.getMonth();
System.out.println(m);
System.out.println(m.getValue());
//方式二：用int变量接收
int month = ldDate.getMonthValue();
System.out.println(month);
//获取日
int day = ldDate.getDayOfMonth();
System.out.println("day:" + day);
//获取一年的第几天
int dayOfYear = ldDate.getDayOfYear();
System.out.println("dayOfYear:" + dayOfYear);
//获取星期
DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
System.out.println(dayOfWeek);
System.out.println(dayOfWeek.getValue());
//is方法表判断
System.out.println(ldDate.isBefore(ldDate));
System.out.println(ldDate.isAfter(ldDate));
//with开头方法表示修改，只能修改年月日
//修改传回的是一个新的对象
LocalDate withLocalDate = ldDate.withYear(2000);
System.out.println(withLocalDate);
System.out.println(withLocalDate == ldDate); //false
//minus减少年月日
LocalDate minusLocalDate = ldDate.minusYears(1);
System.out.println(minusLocalDate);
//plus增加年月日
LocalDate plusLocalDate = ldDate.plusDays(1);
System.out.println(plusLocalDate);
//------------------------------
//判断今天是否是你的生日
LocalDate birDate = LocalDate.of(2000, 1, 1);
LocalDate nowDate1 = LocalDate.now();
//月日对象
MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
MonthDay nowMd = MonthDay.of(nowDate1.getMonthValue(), nowDate1.getDayOfMonth());
System.out.println("今天是你的生日吗？" + birMd.equals(nowMd));
}
}
LocalTime 类用法如下。
package DateClass;
import java.time.LocalTime;
public class LocalTimeDemo {
public static void main(String[] args) {
//获取本地时间的日历对象（时分秒）
LocalTime nowTime = LocalTime.now();
System.out.println("今天的时间:" + nowTime);
int hour = nowTime.getHour(); //时
System.out.println("hour:" + hour);
int minute = nowTime.getMinute(); //分
System.out.println("minute:" + minute);
int second = nowTime.getSecond(); //秒
System.out.println("second:" + second);
int nano = nowTime.getNano(); //纳秒
System.out.println("nano:" + nano);
System.out.println("------------------------");
System.out.println(LocalTime.of(8, 20, 30)); //时分秒
LocalTime mTime = LocalTime.of(8, 20, 30, 150);
//is系列方法
System.out.println(nowTime.isBefore(mTime));
System.out.println(nowTime.isAfter(mTime));
//with系列方法，只能修改时分秒
System.out.println(nowTime.withHour(10));
//minus系列
System.out.println(nowTime.minusHours(10));
//plus系列
System.out.println(nowTime.plusHours(10));
}
}
2.4 JDK8 新增的三个工具类
它们是：
- Duration：时间间隔（秒，纳秒）
- Period：时间间隔（年，月，日）
- ChronoUnit：时间间隔（所有单位）
Period - 计算年月日之间的时间间隔。
package DateClass;
import java.time.LocalDate;
import java.time.Period;
public class TimeUtils {
public static void main(String[] args) {
//当前本地年月日
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());
}
}
Duration - 计算时分秒之间的时间间隔
package DateClass;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
public class TimeUtils {
public static void main(String[] args) {
//当前本地年月日
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
//出生日期的时间对象
LocalDateTime birthDate = LocalDateTime.of(2000,1,1,0,00,00);
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());
}
}
ChronoUnit - 计算年月日时分秒的时间间隔。
package DateClass;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
public class ChronoUnitDemo {
public static void main(String[] args) {
//当前时间
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));
}
}
扫一扫
609
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
