04_使用API_日期和时间
JDK 8 之前传统的日期、时间
Date 类
- 代表的是日期和时间
import java.util.Date;
public class Test {
public static void main(String[] args) {
// 1. 创建一个Data对象，代表系统当前时间信息的
Date d = new Date();
System.out.println(d); // 输出的是日期与当前的时间信息
// 2. 拿到时间毫秒值
long time = d.getTime();
System.out.println(time); // 输出毫秒值
// 3. 把时间毫秒值转换成对象日期：2s之后的时间是多少
time += 2 * 1000; // 2 ms * 1000 == 2s
Date d2 = new Date(time);
// 4. 直接把日期对象的时间，通过setTime方法进行修改
Date d3 = new Date();
d3.setTime(time);
System.out.println(d3);
}
}
SimpleDateFormat 类
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test {
public static void main(String[] args) throws ParseException {
// 1. 准备一些时间
Date d = new Date();
System.out.println(d); // 日期+时间
long time = d.getTime();
System.out.println(time); // 时间毫秒值
// 2. 格式化日期对象，和时间毫秒值
SimpleDateFormat obj = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String res = obj.format(d);
String res2 = obj.format(time);
System.out.println(res);
System.out.println(res2);
// 3. 常见时间格式
/*
* y 年
* M 月
* d 日
* H 时
* m 分
* s 秒
* EEE 星期几
* a 上午/下午
* */
// 4. 将已被格式化的时间字符串，转变回原来的时间对象
String dateStr = "2023--15-20 15:35:21";
SimpleDateFormat obj2 = new SimpleDateFormat("yyyy--MM-dd HH:mm:ss");
Date d2 = obj2.parse(dateStr);
System.out.println(d2); // 日期+时间
}
}
Calendar 类
- Calendar 代表的是系统此刻时间对应的日历
- 通过它可以单独获取、修改时间中的年、月、日、时、分、秒等
import java.util.Calendar;
import java.util.Date;
public class Test {
public static void main(String[] args) {
// 1. 得到系统此刻时间对应的日历对象
Calendar obj = Calendar.getInstance();
System.out.println(obj);
// 2. 获取日历中的某个信息
int year = obj.get(Calendar.YEAR);
System.out.println(year); // 输出年份
int days = obj.get(Calendar.DAY_OF_YEAR);
System.out.println(days); // 一年365天中的第x天
// 3. 拿到日历中记录的日期对象
Date d = obj.getTime();
System.out.println(d);
// 4. 拿到时间毫秒值
long time = obj.getTimeInMillis();
System.out.println(time);
// 5. 修改日历中的某个信息
obj.set(Calendar.MONTH, 9); // 月份是从0开始计算，所以这里是修改为10月
System.out.println(obj.get(Calendar.MONTH)); // 9
obj.set(Calendar.DAY_OF_YEAR, 250); // 修改为一年中的第250天
System.out.println(obj.get(Calendar.DAY_OF_YEAR)); // 250
// 6. 为某个信息增加或者减少多少
obj.add(Calendar.DAY_OF_YEAR, 100);
obj.add(Calendar.DAY_OF_YEAR, -100);
System.out.println(obj.get(Calendar.DAY_OF_YEAR)); // 250
}
}
JDK 8 开始新增的日期、时间
它们的优点
- 设计更合理，功能丰富，使用更方便
- 都是不可变对象，修改后会返回新的时间对象，不会丢失最开始的时间
- 线程安全
- 能精确到毫秒、纳秒
LocalDate、LocalTime、LocalDateTime
- LocalDate：代表本地日期（年、月、日、星期）
- LocalTime：代表本地时间（时、分、秒、纳秒）
- LocalDateTime：代表本地日期、时间（年、月、日、星期、时、分、秒、纳秒）
// LocalDate
import java.time.LocalDate;
public class Test {
public static void main(String[] args) {
// 1. 获取本地日期对象（不可变对象）
LocalDate date = LocalDate.now();
System.out.println(date); // 2023-11-24
// 2. 获取日期对象中的信息
int year = date.getYear();
int month = date.getMonthValue();
int day = date.getDayOfMonth();
int dayOfYear = date.getDayOfYear(); // 一年365天中的第几天
int dayOfWeek = date.getDayOfWeek().getValue(); // 星期几
// 3. 修改信息（本质不是修改原来的，而是新建了一个对象）
LocalDate newDate = date.withYear(2050);
System.out.println(date); // 2023-11-24
System.out.println(newDate); // 2050-11-24
// 4. 把某个信息加(或者减)多少（本质不是修改原来的，而是新建了一个对象）
LocalDate date1 = date.plusYears(10);
LocalDate date2 = date.minusYears(10);
// 5. 指定日期的LocalDate对象
LocalDate date3 = LocalDate.of(2035, 10, 1);
// 6. 判断2个日期对象，是否相等，在前还是在后
System.out.println(date1.equals(date2)); // false
System.out.println(date1.isAfter(date2)); // true
System.out.println(date1.isBefore(date2)); // false
}
}
// LocalTime
import java.time.LocalTime;
public class Test {
public static void main(String[] args) {
// 1. 获取本地时间对象（不可变对象）
LocalTime time = LocalTime.now();
System.out.println(time); // 23:56:28.720309500
// 2. 获取时间对象中的信息
int hour = time.getHour();
int minute = time.getMinute();
int second = time.getSecond();
int nano = time.getNano(); // 纳秒
// 3. 修改信息（本质不是修改原来的，而是新建了一个对象）
LocalTime time1 = time.withHour(8);
// 4. 把某个信息加(或者减)多少（本质不是修改原来的，而是新建了一个对象）
LocalTime time2 = time.plusHours(8);
LocalTime time3 = time.minusHours(8);
// 5. 指定时间的LocalTime对象
LocalTime time4 = LocalTime.of(12, 15);
// 6. 判断2个时间对象，是否相等，在前还是在后
System.out.println(time1.equals(time2));
System.out.println(time1.isAfter(time2));
System.out.println(time1.isBefore(time2));
}
}
// LocalDateTime
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class Test {
public static void main(String[] args) {
LocalDateTime dateTime = LocalDateTime.now();
System.out.println(dateTime); // 2023-11-25T10:08:23.410530300
// 1. 可以获取日期和时间的全部信息
int year = dateTime.getYear();
int month = dateTime.getMonthValue();
int day = dateTime.getDayOfMonth();
int dayOfYear = dateTime.getDayOfYear();
int dayOfWeek = dateTime.getDayOfWeek().getValue();
int hour = dateTime.getHour();
int minute = dateTime.getMinute();
int second = dateTime.getSecond();
int nano = dateTime.getNano();
// 2. 修改时间
LocalDateTime dateTime1 = dateTime.withYear(2035);
// 3. 加减
LocalDateTime dateTime2 = dateTime.plusYears(5);
LocalDateTime dateTime3 = dateTime.minusYears(5);
// 4. 获取指定日期和时间的LocalDateTime对象
LocalDateTime dateTime4 = LocalDateTime.of(2055, 6, 1, 12, 30, 15, 3000);
System.out.println(dateTime4); // 2055-06-01T12:30:15.000003
// 5. 判断日期时间对象是否相等，在前还是在后
System.out.println(dateTime1.equals(dateTime2));
System.out.println(dateTime1.isAfter(dateTime2));
System.out.println(dateTime1.isBefore(dateTime2));
// 6. 可以把LocalDateTime对象，转为LocalDate和LocalTime
LocalDate date = dateTime.toLocalDate();
LocalTime time = dateTime.toLocalTime();
System.out.println(date); // 2023-11-25
System.out.println(time); // 10:20:04.680774700
}
}
时区
import java.time.Clock;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class Test {
public static void main(String[] args) {
// 1. 获取系统默认的时区
ZoneId obj = ZoneId.systemDefault();
System.out.println(obj); // GMT+08:00
System.out.println(obj.getId()); // GMT+08:00
// 2. 显示 Java 支持的全部时区 Id
System.out.println(ZoneId.getAvailableZoneIds()); // [Asia/Aden, America/Cuiaba, Etc/GMT+9, Etc/GMT+8, Africa/Nairobi......]
// 3. 把某个时区的id封装成ZoneId对象
ZoneId obj1 = ZoneId.of("America/Cuiaba");
// 4. 获取某个时区的ZonedDatetime对象
ZonedDateTime obj2 = ZonedDateTime.now(obj1);
System.out.println(obj2); // 输出 America/Cuiaba 时区当前的时间，如下所示
// 2023-11-24T22:50:05.534176500-04:00[America/Cuiaba]
// 5. 获取世界标准时间
ZonedDateTime obj3 = ZonedDateTime.now(Clock.systemUTC());
System.out.println(obj3); // 2023-11-25T02:54:06.575812300Z
// 6. 获取系统默认时区的ZonedDateTime对象
ZonedDateTime obj4 = ZonedDateTime.now();
System.out.println(obj4); // 2023-11-25T10:55:46.410093200+08:00[GMT+08:00]
}
}
Instant (时刻/时间戳)
- 传统的 Date 类只能精确到毫秒，并且是可变对象
- 新增的 Instant 类可以精确到纳秒，并且是不可变对象（推荐使用 Instant 替代 Date ）
import java.time.Instant;
public class Test {
public static void main(String[] args) {
// 1. 创建 Instant 的对象，获取此"刻"信息(该信息由两部分组成："总秒数" + "不够1秒的纳秒数")
Instant obj = Instant.now();
System.out.println(obj); // 2023-11-25T03:05:00.754167800Z
// 2. 获取总秒数
long second = obj.getEpochSecond();
System.out.println(second);
// 3. 获取纳秒数
int nano = obj.getNano();
System.out.println(nano);
// 4. 其他基本操作，类比之前的方法，它们的方法有共通性，而且都是不可变对象
Instant instant1 = Instant.now();
Instant instant2 = Instant.now();
System.out.println(instant1.equals(instant2)); // 判断是否相等
System.out.println(instant1.isAfter(instant2));
System.out.println(instant1.isBefore(instant2));
Instant instant3 = instant1.plusSeconds(5); // +5 秒
Instant instant4 = instant1.minusSeconds(5); // -5 秒
}
}
DateTimeFormatter (日期时间格式化器)
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Test {
public static void main(String[] args) {
// 1. 创建一个日期时间格式化器对象
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
// 2. 对时间进行格式化
// 2.0 准备一个时间
LocalDateTime dateTime = LocalDateTime.now(); // 创建日期时间对象
System.out.println(dateTime); // 输出该对象 2023-11-25T11:24:22.524304100
// 2.1 方法一
String str1 = formatter.format(dateTime); // 格式化这个日期时间对象
System.out.println(str1); // 输出格式化后的结果 2023年11月25日 11:24:22
// 2.2 方法二
String str2 = dateTime.format(formatter);
System.out.println(str2); // 2023年11月25日 11:24:22
// 4. 解析时间：一般使用 LocalDateTime 提供的解析方法来解析
String str = "2023年11月25日 11:25:25";
LocalDateTime obj = LocalDateTime.parse(str, formatter);
System.out.println(obj); // 2023-11-25T11:25:25
}
}
Period（一段时期）
用于计算两个 LocalDate 对象相差的年数、月数、天数
import java.time.LocalDate;
import java.time.Period;
public class Test {
public static void main(String[] args) {
LocalDate start = LocalDate.of(2030, 8, 6);
LocalDate end = LocalDate.of(2030, 8, 20);
// 1. 创建 Period 对象，封装两个日期对象
Period obj = Period.between(start, end);
// 2. 通过 Period 对象获取两个日期对象相差的信息
System.out.println(obj.getYears()); // 0
System.out.println(obj.getMonths()); // 0
System.out.println(obj.getDays()); // 14
}
}
Duration（持续时间）
用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数；支持 LocalTime、LocalDateTime、Instant 等时间
import java.time.Duration;
import java.time.LocalDateTime;
public class Test {
public static void main(String[] args) {
LocalDateTime start = LocalDateTime.of(2028, 5, 10, 12, 15, 30);
LocalDateTime end = LocalDateTime.of(2028, 5, 25, 8, 0, 0);
// 1. 得到 Duration 对象
Duration obj = Duration.between(start, end);
// 2. 获取两个时间对象间隔的信息
System.out.println(obj.toDays()); // 间隔多少天
System.out.println(obj.toHours()); // 间隔多少小时
System.out.println(obj.toMinutes()); // 间隔多少分
System.out.println(obj.toSeconds()); // 间隔多少秒
System.out.println(obj.toMillis()); // 间隔多少毫秒
System.out.println(obj.toNanos()); // 间隔多少纳秒
}
}