日期时间API的使用整合 - 注意事项与测试代码
- 注意事项
- （一）日期字符串格式
- 测试代码
注意事项
（一）日期字符串格式
- 错误的：“yyyy-MM-dd 24:00:00”
- 正确的：“yyyy-MM-dd 23:59:59”
测试代码
不包含以下这些类的具体测试：
- java.text.SimpleDateFormat
- java.util.TimeZone
- java.time.OffsetDateTime
- java.time.temporal.ChronoUnit
- java.time.format.DateTimeFormatter
- java.time.temporal.TemporalAdjusters
import org.junit.jupiter.api.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
/**
* 测试Java提供的关于日期和时间的API
*/
public class DateAndTimeTest {
/**
* Date的局限性
* <p>
* 易于误解 ：Date 类的方法命名不够直观，容易造成混淆。
* <p>
* 可变性 ：Date 是可变的，不适合多线程环境。
* <p>
* 缺乏时区支持 ：Date 本身不包含时区信息。
*
* @throws ParseException ParseException
*/
@Test
public void testDate() throws ParseException {
/*
1. 传统的 java.util.Date 类
创建 Date 对象
java.util.Date 类表示一个特定的时间，精确到毫秒。可以通过以下几种方式创建Date对象：
*/
// 当前日期和时间
Date now = new Date();
System.out.println(now);
// 指定时间（自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数）
Date specificDate = new Date(1633039200000L); // 2021-10-01 00:00:00 GMT
System.out.println(specificDate);
/*
2.格式化和解析日期
需要使用 java.text.SimpleDateFormat 类来格式化和解析 Date 对象：
*/
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 格式化Date对象
String formattedDate = formatter.format(now);
System.out.println(formattedDate);
// 解析字符串到日期
String dateStr = "2021-10-01 12:00:00";
Date parsedDate = formatter.parse(dateStr);
System.out.println(parsedDate);
}
@Test
public void java8NewTimeAPIs(){
/* 1.创建日期和时间对象 */
//当前日期
LocalDate currentDate = LocalDate.now();
System.out.println(currentDate);
//当前时间
LocalTime currentTime = LocalTime.now();
System.out.println(currentTime);
//当前日期和时间
LocalDateTime currentDateTime = LocalDateTime.now();
System.out.println(currentDateTime);
//当前日期和时间（有时区）
ZonedDateTime currentZonedDateTime = ZonedDateTime.now();
System.out.println(currentZonedDateTime);
//时间戳
Instant timestamp = Instant.now();
System.out.println(timestamp);
System.out.println("========================================================================================================");
/* 2.自定义日期和时间 */
LocalDate myBirthday = LocalDate.of(1990, 1, 1);
LocalTime meetingTime = LocalTime.of(13, 30);
LocalDateTime appointment = LocalDateTime.of(2021, 10, 1, 10, 0);
ZonedDateTime zonedDateTime = ZonedDateTime.of(appointment, ZoneId.of("America/New_York"));
ZonedDateTime zonedDateTime2 = ZonedDateTime.of(appointment, ZoneId.of("Asia/Shanghai"));
System.out.println(myBirthday);
System.out.println(meetingTime);
System.out.println(appointment);
System.out.println(zonedDateTime);
System.out.println(zonedDateTime2);
System.out.println("========================================================================================================");
/*
3.格式化和解析日期时间
使用 DateTimeFormatter 类来格式化和解析日期和时间：
*/
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//将LocalDateTime格式化为字符串
String formattedDateTime = currentDateTime.format(formatter);
System.out.println(formattedDateTime);
//解析字符串到LocalDateTime
String dateTimeStr = "2021-10-01 12:00:00";
LocalDateTime parsedDateTime = LocalDateTime.parse(dateTimeStr, formatter);
System.out.println(parsedDateTime);
System.out.println("========================================================================================================");
/*
4.日期时间的操作
现代API还提供丰富的方法来操作日期和时间，例如加减日期、比较日期：
*/
//加一天
LocalDate tomorrow = currentDate.plusDays(1);
System.out.println(tomorrow);
//减一个月
LocalDate lastMonth = currentDate.minusMonths(1);
System.out.println(lastMonth);
//比较日期
boolean isBefore = myBirthday.isBefore(tomorrow);
System.out.println(isBefore);
//计算两个日期之间的间隔
Period period = Period.between(myBirthday, currentDate);
System.out.println(period.getYears() + " years " + period.getMonths() + " months " + period.getDays() + " days");
}
@Test
public void testInstant() throws InterruptedException {
/* 1. 创建 Instant 对象 */
//1.1获取当前时间的 Instant
//可以使用静态方法 Instant.now() 来获取当前时间的 Instant 对象：
Instant now = Instant.now();
System.out.println("当前时间的 Instant: " + now);
//1.2 从时间戳创建 Instant
//可以通过从1970年1月1日00:00:00 UTC以来的秒数或毫秒数来创建 Instant 对象：
// 从秒数创建 Instant
Instant fromEpochSecond = Instant.ofEpochSecond(1633039200L);
System.out.println("从秒数创建的 Instant: " + fromEpochSecond);
// 从毫秒数创建 Instant
Instant fromEpochMilli = Instant.ofEpochMilli(1633039200000L);
System.out.println("从毫秒数创建的 Instant: " + fromEpochMilli);
/* 2. 操作 Instant 对象 */
//2.1加减时间
//可以使用 plus 和 minus 方法来进行时间的加减操作：
// 加1小时
Instant oneHourLater = now.plusSeconds(3600);
System.out.println("加1小时后的 Instant: " + oneHourLater);
// 减30分钟
Instant thirtyMinutesBefore = now.minusSeconds(1800);
System.out.println("减30分钟前的 Instant: " + thirtyMinutesBefore);
//2.2计算两个 Instant 之间的时间差
//可以使用 Duration 类来计算两个 Instant 之间的时间差：
Instant start = Instant.now();
// 模拟一些处理时间
Thread.sleep(2000);
Instant end = Instant.now();
Duration duration = Duration.between(start, end);
System.out.println("处理时间: " + duration.toMillis() + " 毫秒");
/* 3. 转换 Instant 和其他日期时间类型 */
//3.1转换为 LocalDateTime
//可以将 Instant 转换为 LocalDateTime，需要通过指定一个 ZoneId（时区）来进行转换：
Instant instant = Instant.now();
LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
System.out.println("转换为 LocalDateTime: " + localDateTime);
//3.2转换为 ZonedDateTime
//可以将 Instant 转换为 ZonedDateTime，需要通过指定一个 ZoneId（时区）来进行转换：
ZonedDateTime zonedDateTime = instant.atZone(ZoneId.systemDefault());
System.out.println("转换为 ZonedDateTime: " + zonedDateTime);
//3.3转换为 Date
//虽然现代API大多数时候不需要转换到旧的 Date 类，但必要时仍可以进行转换：
Date date = Date.from(instant);
System.out.println("转换为 Date: " + date);
//3.4从 Date 转换为 Instant
//同样地，也可以从 Date 转换为 Instant：
Date date1 = new Date();
Instant instant1 = date1.toInstant();
System.out.println("从 Date 转换为 Instant: " + instant1);
/* 4. 格式化和解析 Instant */
//Instant 不能直接使用 DateTimeFormatter 进行格式化和解析，因为它是基于UTC的时间戳。可以将 Instant 转换为 ZonedDateTime 或 OffsetDateTime 来进行格式化和解析：
ZonedDateTime zonedDateTime1 = instant.atZone(ZoneId.systemDefault());
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//格式化
String formatted = formatter.format(zonedDateTime1);
System.out.println("格式化 Instant: " + formatted);
String dateTimeStr = "2021-10-01 12:00:00";
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//解析
LocalDateTime localDateTime1 = LocalDateTime.parse(dateTimeStr, formatter1);
ZonedDateTime zonedDateTime2 = localDateTime1.atZone(ZoneId.systemDefault());
Instant instant2 = zonedDateTime2.toInstant();
System.out.println("解析字符串到 Instant: " + instant2);
/* 5. Instant的比较 */
//可以使用 Instant 类的 isBefore、isAfter 和 equals 方法进行比较：
Instant instant3 = Instant.now();
Instant instant4 = instant3.plusSeconds(10);
boolean isBefore = instant3.isBefore(instant4); // true
boolean isAfter = instant3.isAfter(instant4); // false
boolean isEqual = instant3.equals(instant4); // false
System.out.println("instant1 是否在 instant2 之前: " + isBefore);
System.out.println("instant1 是否在 instant2 之后: " + isAfter);
System.out.println("instant1 是否与 instant2 相等: " + isEqual);
}
@Test
public void testDuration() throws InterruptedException {
/* 1. 创建 Duration 对象 */
//1.1使用工厂方法
//可以通过静态工厂方法来创建 Duration 对象：
// 创建一个表示 5 秒的 Duration
Duration durationSeconds = Duration.ofSeconds(5);
System.out.println("Duration of 5 seconds: " + durationSeconds);
// 创建一个表示 3 分钟的 Duration
Duration durationMinutes = Duration.ofMinutes(3);
System.out.println("Duration of 3 minutes: " + durationMinutes);
// 创建一个表示 2 小时的 Duration
Duration durationHours = Duration.ofHours(2);
System.out.println("Duration of 2 hours: " + durationHours);
// 创建一个表示 1000 毫秒（1 秒）的 Duration
Duration durationMillis = Duration.ofMillis(1000);
System.out.println("Duration of 1000 milliseconds: " + durationMillis);
//1.2使用 between 方法
//可以通过两个时间点之间的差值来创建 Duration 对象：
Instant start = Instant.now();
// 模拟一些处理时间
Thread.sleep(2000);
Instant end = Instant.now();
Duration duration = Duration.between(start, end);
System.out.println("Duration between start and end: " + duration);
/* 2. 操作 Duration 对象 */
//2.1加和减
//可以使用 plus 和 minus 方法来对 Duration 进行加减操作：
// 创建一个初始的 Duration
Duration initialDuration = Duration.ofMinutes(10);
// 增加 5 分钟
Duration extendedDuration = initialDuration.plusMinutes(5);
System.out.println("Duration after adding 5 minutes: " + extendedDuration);
// 减少 3 分钟
Duration reducedDuration = initialDuration.minusMinutes(3);
System.out.println("Duration after subtracting 3 minutes: " + reducedDuration);
//2.2转换为其他单位
//可以将 Duration 转换为特定单位的时间值，例如天、小时、分钟、秒和毫秒：
Duration duration1 = Duration.ofHours(1);
long hours = duration1.toHours();
System.out.println("Duration in hours: " + hours);
// 转换为分钟
long minutes = duration1.toMinutes();
System.out.println("Duration in minutes: " + minutes);
// 转换为秒
long seconds = duration1.getSeconds();
System.out.println("Duration in seconds: " + seconds);
// 转换为毫秒
long millis = duration1.toMillis();
System.out.println("Duration in milliseconds: " + millis);
// 转换为纳秒
long nanos = duration1.toNanos();
System.out.println("Duration in nanoseconds: " + nanos);
/* 3. 检查和比较 Duration */
//3.1检查零和负数
//可以使用 isZero 和 isNegative 方法来检查 Duration 是否为零或负数：
Duration zeroDuration = Duration.ofSeconds(0);
Duration positiveDuration = Duration.ofSeconds(5);
Duration negativeDuration = Duration.ofSeconds(-5);
System.out.println("Is zero duration zero? " + zeroDuration.isZero());
System.out.println("Is positive duration negative? " + positiveDuration.isNegative());
System.out.println("Is negative duration negative? " + negativeDuration.isNegative());
//3.2比较 Duration
//可以使用 compareTo 方法比较两个 Duration 对象：
Duration duration2 = Duration.ofMinutes(5);
Duration duration3 = Duration.ofMinutes(10);
int comparisonResult = duration2.compareTo(duration3);
if (comparisonResult > 0) {
System.out.println("duration2 is longer than duration3");
} else if (comparisonResult < 0) {
System.out.println("duration2 is shorter than duration3");
} else {
System.out.println("duration2 is equal to duration3");
}
/* 4. 格式化和解析 Duration */
//4.1转换为字符串
//可以通过 toString 方法将 Duration 对象转换为字符串表示：
Duration duration4 = Duration.ofHours(1).plusMinutes(30).plusSeconds(20);
String durationStr = duration4.toString();
System.out.println("String representation of Duration: " + durationStr);
//4.2从字符串解析
//可以使用 Duration.parse 方法从字符串解析 Duration 对象：
String durationStr1 = "PT1H30M20S";
Duration parsedDuration = Duration.parse(durationStr1);
System.out.println("Parsed Duration: " + parsedDuration);
/* 5. 与其他时间类的结合使用 */
//5.1使用 Instant
//可以结合 Instant 使用 Duration 来进行时间计算：
Instant now = Instant.now();
Duration duration5 = Duration.ofHours(2);
// 加 2 小时
Instant later = now.plus(duration5);
System.out.println("2 hours later: " + later);
// 减 2 小时
Instant earlier = now.minus(duration5);
System.out.println("2 hours earlier: " + earlier);
//5.2使用 LocalTime
//可以结合 LocalTime 使用 Duration 来进行时间计算：
LocalTime time = LocalTime.now();
Duration duration6 = Duration.ofMinutes(30);
// 加 30 分钟
LocalTime later1 = time.plus(duration6);
System.out.println("30 minutes later: " + later1);
// 减 30 分钟
LocalTime earlier2 = time.minus(duration6);
System.out.println("30 minutes earlier: " + earlier2);
}
@Test
public void testCalendar(){
/* 1.创建 Calendar 对象 */
//1.1获取当前日期和时间
//Calendar 类是一个抽象类，不能直接实例化。我们通常使用其静态方法 getInstance() 获取当前日期和时间的 Calendar 对象：
Calendar calendar = Calendar.getInstance();
System.out.println("Current date and time: " + calendar.getTime());
//1.2使用特定时间
//可以通过设置年、月、日、时、分、秒来创建一个特定时间的 Calendar 对象：
// TODO：注意月份从0开始，OCTOBER枚举类的int值为9
calendar.set(2023, Calendar.OCTOBER, 5, 14, 30, 0);
System.out.println("Specific date and time: " + calendar.getTime());
/* 2.操作 Calendar 对象 */
//2.1获取日期和时间的各个部分
//可以通过 Calendar 类的许多常量来获取日期和时间的各个部分：
Calendar calendar1 = Calendar.getInstance();
int year = calendar1.get(Calendar.YEAR);
int month = calendar1.get(Calendar.MONTH); // 注意月份从0开始
int day = calendar1.get(Calendar.DAY_OF_MONTH);
int hour = calendar1.get(Calendar.HOUR_OF_DAY);
int minute = calendar1.get(Calendar.MINUTE);
int second = calendar1.get(Calendar.SECOND);
System.out.println("Year: " + year);
// 月份的int值从0开始，所以需要加1
System.out.println("Month: " + (month + 1));
System.out.println("Day: " + day);
System.out.println("Hour: " + hour);
System.out.println("Minute: " + minute);
System.out.println("Second: " + second);
//2.2修改日期和时间
//可以通过 set 方法来修改 Calendar 对象的日期和时间：
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.YEAR, 2025);
calendar2.set(Calendar.MONTH, Calendar.DECEMBER); // 12月
calendar2.set(Calendar.DAY_OF_MONTH, 25);
System.out.println("Modified date: " + calendar2.getTime());
//2.3增加或减少日期和时间
//可以使用 add 和 roll 方法来增加或减少日期和时间。add 方法会调整较大的字段，而 roll 方法只会调整指定的字段，不会影响更大的字段。
Calendar calendar3 = Calendar.getInstance();
calendar3.add(Calendar.DAY_OF_MONTH, 10); // 增加 10 天
System.out.println("Date after adding 10 days: " + calendar3.getTime());
calendar3.add(Calendar.MONTH, -2); // 减少 2 个月
System.out.println("Date after subtracting 2 months: " + calendar3.getTime());
calendar3.roll(Calendar.DAY_OF_MONTH, 15); // 向回滚动 15 天
System.out.println("Date after rolling back 15 days: " + calendar3.getTime());
calendar3.roll(Calendar.DAY_OF_MONTH, -15); // 向后滚动 15 天
System.out.println("Date after rolling forward 15 days: " + calendar3.getTime());
/* 3.格式化和解析日期和时间 */
//尽管 Calendar 类本身并没有提供直接的格式化和解析功能，但可以与 SimpleDateFormat 类一起使用。
//3.1格式化日期和时间
//使用 SimpleDateFormat 将 Calendar 对象的时间格式化为指定格式的字符串：
Calendar calendar4 = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String formattedDate = sdf.format(calendar4.getTime());
System.out.println("Formatted date: " + formattedDate);
//3.2解析字符串为日期和时间
//同样可以使用 SimpleDateFormat 将字符串解析为 Date 对象，然后设置到 Calendar 对象中：
String dateStr = "2023-10-05 14:30:00";
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
Date date = sdf1.parse(dateStr);
Calendar calendar5 = Calendar.getInstance();
calendar5.setTime(date);
System.out.println("Parsed date: " + calendar5.getTime());
} catch (ParseException e) {
e.printStackTrace();
}
/* 4.时间比较和计算 */
//4.1时间比较
//可以使用 Calendar 类的 before、after 和 equals 方法来比较两个 Calendar 对象：
Calendar calendar6 = Calendar.getInstance();
calendar6.set(2023, Calendar.OCTOBER, 5);
Calendar calendar7 = Calendar.getInstance();
calendar7.set(2023, Calendar.NOVEMBER, 5);
boolean isBefore = calendar6.before(calendar7); // true
boolean isAfter = calendar6.after(calendar7); // false
System.out.println("calendar6 is before calendar7: " + isBefore);
System.out.println("calendar6 is after calendar7: " + isAfter);
//4.2计算两个日期之间的时间差
//可以通过计算两个 Calendar 对象的时间戳之差来获得时间差：
Calendar calendar8 = Calendar.getInstance();
calendar8.set(2023, Calendar.OCTOBER, 5);
Calendar calendar9 = Calendar.getInstance();
calendar9.set(2023, Calendar.NOVEMBER, 5);
long diffMillis = calendar9.getTimeInMillis() - calendar8.getTimeInMillis();
System.out.println("Difference in MillionSeconds: " + diffMillis);
long diffDays = diffMillis / (24 * 60 * 60 * 1000); // 毫秒转换为天
System.out.println("Difference in days: " + diffDays);
/* 5.时区处理 */
//获取和设置时区
//可以使用 Calendar 的 getTimeZone 和 setTimeZone 方法来处理不同的时区：
Calendar calendar10 = Calendar.getInstance();
// 获取当前时区
TimeZone timeZone = calendar10.getTimeZone();
System.out.println("Current TimeZone: " + timeZone.getID());
// 设置为其他时区
calendar10.setTimeZone(TimeZone.getTimeZone("America/New_York"));
System.out.println("Time in New York: " + calendar10.getTime());
}
@Test
public void testPeriod(){
/* 1.创建 Period 对象 */
//1.1使用工厂方法
//可以通过静态工厂方法来创建 Period 对象：
// 创建一个表示 1 年 2 个月 3 天的 Period
Period period = Period.of(1, 2, 3);
System.out.println("Period: " + period);
// 创建一个表示 5 天的 Period
Period daysPeriod = Period.ofDays(5);
System.out.println("Period of 5 days: " + daysPeriod);
// 创建一个表示 2 个月的 Period
Period monthsPeriod = Period.ofMonths(2);
System.out.println("Period of 2 months: " + monthsPeriod);
// 创建一个表示 1 年的 Period
Period yearsPeriod = Period.ofYears(1);
System.out.println("Period of 1 year: " + yearsPeriod);
//1.2使用 between 方法
//可以通过两个日期之间的差值来创建 Period 对象：
LocalDate startDate = LocalDate.of(2023, 1, 1);
LocalDate endDate = LocalDate.of(2024, 3, 15);
Period period1 = Period.between(startDate, endDate);
System.out.println("Period between start and end date: " + period1);
/* 2.操作 Period 对象 */
//2.1加和减
//可以使用 plus 和 minus 方法来对 Period 进行加减操作：
Period initialPeriod = Period.of(1, 2, 3);
// 增加 1 年 1 个月 1 天
Period extendedPeriod = initialPeriod.plus(Period.of(1, 1, 1));
System.out.println("Extended Period: " + extendedPeriod);
// 减少 1 年 1 个月 1 天
Period reducedPeriod = initialPeriod.minus(Period.of(1, 1, 1));
System.out.println("Reduced Period: " + reducedPeriod);
//2.2转换为其他单位
//可以将 Period 转换为特定单位的时间值，例如天、月、年：
Period period2 = Period.of(1, 2, 3);
// 获取总月数
long totalMonths = period2.toTotalMonths();
System.out.println("Total months: " + totalMonths);
/* 3.检查和设置 Period */
//3.1检查零和负数
//可以使用 isZero 和 isNegative 方法来检查 Period 是否为零或负数：
Period zeroPeriod = Period.of(0, 0, 0);
Period positivePeriod = Period.of(1, 2, 3);
Period negativePeriod = Period.of(-1, -2, -3);
System.out.println("Is zero period zero? " + zeroPeriod.isZero());
System.out.println("Is positive period negative? " + positivePeriod.isNegative());
System.out.println("Is negative period negative? " + negativePeriod.isNegative());
//3.2设置天数，月份，年份
//可以使用 withDays、withMonths、withYears方法来设置天数，月份，年份：
Period period5 = Period.of(2029, 3, 8);
System.out.println("Period with 12 Days: "+period5.withDays(12));
System.out.println("Period with 3 Months: "+period5.withMonths(3));
System.out.println("Period with 1 Years: "+period5.withYears(1));
/* 4.格式化和解析 Period */
//4.1转换为字符串
//可以通过 toString 方法将 Period 对象转换为字符串表示：
Period period3 = Period.of(1, 2, 3);
String periodStr = period3.toString();
System.out.println("String representation of Period: " + periodStr);
//4.2从字符串解析
//可以使用 Period.parse 方法从字符串解析 Period 对象：
String periodStr4 = "P1Y2M3D";
Period parsedPeriod = Period.parse(periodStr4);
System.out.println("Parsed Period: " + parsedPeriod);
/* 5. 与其他时间类的结合使用 */
//5.1使用 LocalDate
//可以结合 LocalDate 使用 Period 来进行日期计算：
LocalDate startDate1 = LocalDate.of(2023, 1, 1);
Period period4 = Period.of(1, 2, 3);
// 加 1 年 2 个月 3 天
LocalDate endDate1 = startDate1.plus(period4);
System.out.println("End date after adding period: " + endDate1);
// 减 1 年 2 个月 3 天
LocalDate earlierDate = startDate1.minus(period4);
System.out.println("Earlier date after subtracting period: " + earlierDate);
}
@Test
public void testLocalTime() {
/* 1. 创建 LocalTime 对象 */
//使用工厂方法
//LocalTime 提供了多个静态工厂方法来创建时间对象：
// 当前时间
LocalTime currentTime = LocalTime.now();
System.out.println("Current time: " + currentTime);
// 指定时间（小时和分钟）
LocalTime specificTime1 = LocalTime.of(14, 30);
System.out.println("Specific time (HH:MM): " + specificTime1);
// 指定时间（小时、分钟和秒）
LocalTime specificTime2 = LocalTime.of(14, 30, 45);
System.out.println("Specific time (HH:MM:SS): " + specificTime2);
// 指定时间（小时、分钟、秒和纳秒）
LocalTime specificTime3 = LocalTime.of(14, 30, 45, 123456789);
System.out.println("Specific time (HH:MM:SS.NNNNNNNNN): " + specificTime3);
/* 2. 获取时间的各个部分 */
//可以通过 LocalTime 类的方法获取时间的各个部分：
LocalTime time = LocalTime.of(14, 30, 45, 123456789);
int hour = time.getHour();
int minute = time.getMinute();
int second = time.getSecond();
int nano = time.getNano();
System.out.println("Hour: " + hour); // 14
System.out.println("Minute: " + minute); // 30
System.out.println("Second: " + second); // 45
System.out.println("Nano: " + nano); // 123456789
/* 3. 修改 LocalTime 对象 */
//LocalTime 提供了多种修改时间的方法，这些方法会返回一个新的 LocalTime 实例，因为 LocalTime 是不可变的。
//3.1加和减时间
LocalTime time1 = LocalTime.of(14, 30, 45);
// 加时间
LocalTime timePlusHours = time1.plusHours(2);
LocalTime timePlusMinutes = time1.plusMinutes(15);
LocalTime timePlusSeconds = time1.plusSeconds(30);
LocalTime timePlusNanos = time1.plusNanos(1000000);
System.out.println("Time plus 2 hours: " + timePlusHours);
System.out.println("Time plus 15 minutes: " + timePlusMinutes);
System.out.println("Time plus 30 seconds: " + timePlusSeconds);
System.out.println("Time plus 1 millisecond: " + timePlusNanos);
// 减时间
LocalTime timeMinusHours = time1.minusHours(2);
LocalTime timeMinusMinutes = time1.minusMinutes(15);
LocalTime timeMinusSeconds = time1.minusSeconds(30);
LocalTime timeMinusNanos = time1.minusNanos(1000000);
System.out.println("Time minus 2 hours: " + timeMinusHours);
System.out.println("Time minus 15 minutes: " + timeMinusMinutes);
System.out.println("Time minus 30 seconds: " + timeMinusSeconds);
System.out.println("Time minus 1 millisecond: " + timeMinusNanos);
//3.2设置时间
LocalTime time2 = LocalTime.of(14, 30, 45);
// 设置时间
LocalTime newTime1 = time2.withHour(10);
LocalTime newTime2 = time2.withMinute(20);
LocalTime newTime3 = time2.withSecond(50);
LocalTime newTime4 = time2.withNano(123456789);
System.out.println("Time with hour set to 10: " + newTime1);
System.out.println("Time with minute set to 20: " + newTime2);
System.out.println("Time with second set to 50: " + newTime3);
System.out.println("Time with nano set to 123456789: " + newTime4);
/* 4. 比较 LocalTime 对象 */
//LocalTime 提供了多种比较方法：
LocalTime time3 = LocalTime.of(14, 30, 45);
LocalTime time4 = LocalTime.of(16, 45, 30);
// 比较时间
boolean isBefore = time3.isBefore(time4); // true
boolean isAfter = time3.isAfter(time4); // false
System.out.println("time3 is before time4: " + isBefore);
System.out.println("time3 is after time4: " + isAfter);
// 使用 compareTo 方法
int comparisonResult = time3.compareTo(time4);
if (comparisonResult < 0) {
System.out.println("time3 is before time4");
} else if (comparisonResult > 0) {
System.out.println("time3 is after time4");
} else {
System.out.println("time3 is equal to time4");
}
/* 5. 格式化和解析 LocalTime */
//5.1转换为字符串
//LocalTime 支持使用 DateTimeFormatter 格式化为字符串：
LocalTime time5 = LocalTime.of(14, 30, 45);
// 使用默认格式
String defaultFormatted = time5.toString();
System.out.println("Default formatted time: " + defaultFormatted);
// 使用自定义格式
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
String customFormatted = time5.format(formatter);
System.out.println("Custom formatted time: " + customFormatted);
//5.2从字符串解析
//可以使用 DateTimeFormatter 从字符串解析 LocalTime 对象：
String timeStr = "14:30:45";
// 使用默认格式
LocalTime parsedTime1 = LocalTime.parse(timeStr);
System.out.println("Parsed time (default): " + parsedTime1);
// 使用自定义格式
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("HH:mm:ss");
LocalTime parsedTime2 = LocalTime.parse(timeStr, formatter1);
System.out.println("Parsed time (custom): " + parsedTime2);
/* 6. 其他实用方法 */
//6.1与 Duration 的结合使用
//LocalTime 可以与 Duration 类结合使用进行时间计算：
LocalTime time6 = LocalTime.of(14, 30, 45);
Duration duration = Duration.ofHours(2);
// 加一个时间段
LocalTime newTime = time6.plus(duration);
System.out.println("Time after adding duration: " + newTime);
// 减一个时间段
newTime = time6.minus(duration);
System.out.println("Time after subtracting duration: " + newTime);
//6.2与当前时间的比较
//可以使用 ChronoUnit 枚举计算两个时间之间的差异：
LocalTime time7 = LocalTime.of(14, 30, 45);
LocalTime time8 = LocalTime.of(16, 45, 30);
long hoursBetween = ChronoUnit.HOURS.between(time7, time8);
long minutesBetween = ChronoUnit.MINUTES.between(time7, time8);
long secondsBetween = ChronoUnit.SECONDS.between(time7, time8);
long secondsBetween1 = ChronoUnit.SECONDS.between(time8, time7);
System.out.println("Hours between: " + hoursBetween);
System.out.println("Minutes between: " + minutesBetween);
System.out.println("Seconds between: " + secondsBetween);
System.out.println("Seconds between1: " + secondsBetween1);
}
@Test
public void testLocalDate(){
/* 1. 创建 LocalDate 对象 */
//使用工厂方法
// 当前日期
LocalDate currentDate = LocalDate.now();
System.out.println("Current date: " + currentDate);
// 指定日期
LocalDate specificDate = LocalDate.of(2023, 10, 5);
System.out.println("Specific date: " + specificDate);
// 解析日期字符串
LocalDate parsedDate = LocalDate.parse("2023-10-05");
System.out.println("Parsed date: " + parsedDate);
/* 2. 获取日期的各个部分 */
//可以通过 LocalDate 的方法获取日期的各个部分：
LocalDate date = LocalDate.of(2023, 10, 5);
int year = date.getYear();
int month = date.getMonthValue();
int day = date.getDayOfMonth();
int dayOfYear = date.getDayOfYear();
String dayOfWeek = date.getDayOfWeek().name();
System.out.println("Year: " + year);
System.out.println("Month: " + month);
System.out.println("Day: " + day);
System.out.println("Day of year: " + dayOfYear);
System.out.println("Day of week: " + dayOfWeek);
/* 3. 修改 LocalDate 对象 */
//TODO：LocalDate 提供了多种方法来修改日期，这些方法会返回一个新的 LocalDate 对象，因为 LocalDate 是不可变的。
//3.1加和减日期
LocalDate date1 = LocalDate.of(2023, 10, 5);
// 加日期
LocalDate datePlusDays = date1.plusDays(10);
LocalDate datePlusWeeks = date1.plusWeeks(2);
LocalDate datePlusMonths = date1.plusMonths(1);
LocalDate datePlusYears = date1.plusYears(1);
System.out.println("Date plus 10 days: " + datePlusDays);
System.out.println("Date plus 2 weeks: " + datePlusWeeks);
System.out.println("Date plus 1 month: " + datePlusMonths);
System.out.println("Date plus 1 year: " + datePlusYears);
// 减日期
LocalDate dateMinusDays = date1.minusDays(10);
LocalDate dateMinusWeeks = date1.minusWeeks(2);
LocalDate dateMinusMonths = date1.minusMonths(1);
LocalDate dateMinusYears = date1.minusYears(1);
System.out.println("Date minus 10 days: " + dateMinusDays);
System.out.println("Date minus 2 weeks: " + dateMinusWeeks);
System.out.println("Date minus 1 month: " + dateMinusMonths);
System.out.println("Date minus 1 year: " + dateMinusYears);
//3.2设置日期
LocalDate date2 = LocalDate.of(2023, 10, 5);
// 设置日期
LocalDate newDateWithYear = date2.withYear(2022);
LocalDate newDateWithMonth = date2.withMonth(8);
LocalDate newDateWithDay = date2.withDayOfMonth(15);
System.out.println("Date with year set to 2022: " + newDateWithYear);
System.out.println("Date with month set to August: " + newDateWithMonth);
System.out.println("Date with day set to 15: " + newDateWithDay);
/* 4. 比较 LocalDate 对象 */
//LocalDate 提供了多种比较方法：
LocalDate date3 = LocalDate.of(2023, 10, 5);
LocalDate date4 = LocalDate.of(2024, 10, 5);
// 比较日期
boolean isBefore = date3.isBefore(date4); // true
boolean isAfter = date3.isAfter(date4); // false
boolean isEqual = date3.isEqual(date4); // false
System.out.println("date3 is before date4: " + isBefore);
System.out.println("date3 is after date4: " + isAfter);
System.out.println("date3 is equal to date4: " + isEqual);
// 使用 compareTo 方法
int comparisonResult = date3.compareTo(date4);
if (comparisonResult < 0) {
System.out.println("date3 is before date4");
} else if (comparisonResult > 0) {
System.out.println("date3 is after date4");
} else {
System.out.println("date3 is equal to date4");
}
/* 5. 格式化和解析 LocalDate */
//5.1转换为字符串
//LocalDate 支持使用 DateTimeFormatter 来格式化为字符串：
LocalDate date5 = LocalDate.of(2023, 10, 5);
// 使用默认格式
String formattedDate = date5.toString();
System.out.println("Default formatted date: " + formattedDate);
// 使用自定义格式
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
String customFormattedDate = date5.format(formatter);
System.out.println("Custom formatted date: " + customFormattedDate);
//5.2从字符串解析
//可以使用 DateTimeFormatter 从字符串解析 LocalDate 对象：
String dateStr = "05/10/2023";
// 使用默认格式
LocalDate parsedDate1 = LocalDate.parse("2023-10-05");
System.out.println("Parsed date (default): " + parsedDate1);
// 使用自定义格式
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("dd/MM/yyyy");
LocalDate parsedDate2 = LocalDate.parse(dateStr, formatter1);
System.out.println("Parsed date (custom): " + parsedDate2);
/* 6. 其他实用方法 */
//6.1检查闰年
//可以使用 isLeapYear 方法来检查某一年是否是闰年：
LocalDate date6 = LocalDate.of(2023, 10, 5);
boolean isLeapYear = date6.isLeapYear();
System.out.println("Is 2023 a leap year? " + isLeapYear);
//6.2获取一个月中的天数
//可以使用 lengthOfMonth 和 lengthOfYear 方法获取月份和年份的天数：
LocalDate date7 = LocalDate.of(2023, 10, 5);
int daysInMonth = date7.lengthOfMonth();
int daysInYear = date7.lengthOfYear();
System.out.println("Days in October 2023: " + daysInMonth);
System.out.println("Days in year 2023: " + daysInYear);
//6.3获取特定日期
//可以使用 with 方法来获取特定日期：
LocalDate date8 = LocalDate.of(2023, 10, 5);
// 获取该月的第一天
LocalDate firstDayOfMonth = date8.with(TemporalAdjusters.firstDayOfMonth());
System.out.println("First day of month: " + firstDayOfMonth);
// 获取该月的最后一天
LocalDate lastDayOfMonth = date8.with(TemporalAdjusters.lastDayOfMonth());
System.out.println("Last day of month: " + lastDayOfMonth);
// 获取下一个星期一
LocalDate nextMonday = date8.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
System.out.println("Next Monday: " + nextMonday);
/* 7. 使用 Period */
//使用 Period 计算日期之间的差异
//Period 类可以用来计算两个日期之间的差异：
LocalDate startDate = LocalDate.of(2023, 1, 1);
LocalDate endDate = LocalDate.of(2024, 1, 1);
Period period = Period.between(startDate, endDate);
System.out.println("Period between start and end date: " + period);
System.out.println("Years: " + period.getYears());
System.out.println("Months: " + period.getMonths());
System.out.println("Days: " + period.getDays());
/* 8. 与其他时间类的结合使用 */
//LocalDate 可以与 LocalTime 和 LocalDateTime 结合使用以处理日期和时间：
LocalDate date9 = LocalDate.of(2023, 10, 5);
LocalTime time = LocalTime.of(14, 30, 45);
// 创建 LocalDateTime 对象
LocalDateTime dateTime = LocalDateTime.of(date9, time);
System.out.println("LocalDateTime: " + dateTime);
// 从 LocalDateTime 获取 LocalDate 和 LocalTime
LocalDate extractedDate = dateTime.toLocalDate();
LocalTime extractedTime = dateTime.toLocalTime();
System.out.println("Extracted LocalDate: " + extractedDate);
System.out.println("Extracted LocalTime: " + extractedTime);
}
@Test
public void testLocalDateTime() {
/* 1. 创建 LocalDateTime 对象 */
//使用工厂方法
//可以使用静态工厂方法来创建 LocalDateTime 对象：
// 当前日期和时间
LocalDateTime currentDateTime = LocalDateTime.now();
System.out.println("Current date and time: " + currentDateTime);
// 指定日期和时间
LocalDateTime specificDateTime = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
System.out.println("Specific date and time: " + specificDateTime);
// 使用 LocalDate 和 LocalTime 创建
LocalDate date = LocalDate.of(2023, 10, 5);
LocalTime time = LocalTime.of(14, 30, 45);
LocalDateTime dateTimeFromComponents = LocalDateTime.of(date, time);
System.out.println("DateTime from LocalDate and LocalTime: " + dateTimeFromComponents);
// 解析日期和时间字符串
LocalDateTime parsedDateTime = LocalDateTime.parse("2023-10-05T14:30:45");
System.out.println("Parsed date and time: " + parsedDateTime);
/* 2. 获取日期和时间的各个部分 */
//可以通过 LocalDateTime 的方法获取日期和时间的各个部分：
LocalDateTime dateTime = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
int year = dateTime.getYear();
int month = dateTime.getMonthValue();
int day = dateTime.getDayOfMonth();
int hour = dateTime.getHour();
int minute = dateTime.getMinute();
int second = dateTime.getSecond();
int nano = dateTime.getNano();
String dayOfWeek = dateTime.getDayOfWeek().name();
int dayOfMonth = dateTime.getDayOfMonth();
int dayOfYear = dateTime.getDayOfYear();
System.out.println("Year: " + year);
System.out.println("Month: " + month);
System.out.println("Day: " + day);
System.out.println("Hour: " + hour);
System.out.println("Minute: " + minute);
System.out.println("Second: " + second);
System.out.println("Nano: " + nano);
System.out.println("Day of week: " + dayOfWeek);
System.out.println("Day of Month: " + dayOfMonth);
System.out.println("Day of Year: " + dayOfYear);
/* 3. 修改 LocalDateTime 对象 */
//LocalDateTime 提供了多种方法来修改日期和时间，这些方法会返回一个新的 LocalDateTime 对象，因为 LocalDateTime 是不可变的。
//3.1加和减日期和时间
LocalDateTime dateTime1 = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
// 加日期和时间
LocalDateTime dateTimePlusDays = dateTime1.plusDays(10);
LocalDateTime dateTimePlusWeeks = dateTime1.plusWeeks(2);
LocalDateTime dateTimePlusMonths = dateTime1.plusMonths(1);
LocalDateTime dateTimePlusYears = dateTime1.plusYears(1);
LocalDateTime dateTimePlusHours = dateTime1.plusHours(2);
LocalDateTime dateTimePlusMinutes = dateTime1.plusMinutes(15);
LocalDateTime dateTimePlusSeconds = dateTime1.plusSeconds(30);
LocalDateTime dateTimePlusNanos = dateTime1.plusNanos(1000000);
System.out.println("DateTime plus 10 days: " + dateTimePlusDays);
System.out.println("DateTime plus 2 weeks: " + dateTimePlusWeeks);
System.out.println("DateTime plus 1 month: " + dateTimePlusMonths);
System.out.println("DateTime plus 1 year: " + dateTimePlusYears);
System.out.println("DateTime plus 2 hours: " + dateTimePlusHours);
System.out.println("DateTime plus 15 minutes: " + dateTimePlusMinutes);
System.out.println("DateTime plus 30 seconds: " + dateTimePlusSeconds);
System.out.println("DateTime plus 1 millisecond: " + dateTimePlusNanos);
// 减日期和时间
LocalDateTime dateTimeMinusDays = dateTime1.minusDays(10);
LocalDateTime dateTimeMinusWeeks = dateTime1.minusWeeks(2);
LocalDateTime dateTimeMinusMonths = dateTime1.minusMonths(1);
LocalDateTime dateTimeMinusYears = dateTime1.minusYears(1);
LocalDateTime dateTimeMinusHours = dateTime1.minusHours(2);
LocalDateTime dateTimeMinusMinutes = dateTime1.minusMinutes(15);
LocalDateTime dateTimeMinusSeconds = dateTime1.minusSeconds(30);
LocalDateTime dateTimeMinusNanos = dateTime1.minusNanos(1000000);
System.out.println("DateTime minus 10 days: " + dateTimeMinusDays);
System.out.println("DateTime minus 2 weeks: " + dateTimeMinusWeeks);
System.out.println("DateTime minus 1 month: " + dateTimeMinusMonths);
System.out.println("DateTime minus 1 year: " + dateTimeMinusYears);
System.out.println("DateTime minus 2 hours: " + dateTimeMinusHours);
System.out.println("DateTime minus 15 minutes: " + dateTimeMinusMinutes);
System.out.println("DateTime minus 30 seconds: " + dateTimeMinusSeconds);
System.out.println("DateTime minus 1 millisecond: " + dateTimeMinusNanos);
//3.2设置日期和时间
LocalDateTime dateTime2 = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
// 设置日期和时间
LocalDateTime newDateTimeWithYear = dateTime2.withYear(2022);
LocalDateTime newDateTimeWithMonth = dateTime2.withMonth(8);
LocalDateTime newDateTimeWithDay = dateTime2.withDayOfMonth(15);
LocalDateTime newDateTimeWithHour = dateTime2.withHour(10);
LocalDateTime newDateTimeWithMinute = dateTime2.withMinute(20);
LocalDateTime newDateTimeWithSecond = dateTime2.withSecond(50);
LocalDateTime newDateTimeWithNano = dateTime2.withNano(123456789);
System.out.println("DateTime with year set to 2022: " + newDateTimeWithYear);
System.out.println("DateTime with month set to August: " + newDateTimeWithMonth);
System.out.println("DateTime with day set to 15: " + newDateTimeWithDay);
System.out.println("DateTime with hour set to 10: " + newDateTimeWithHour);
System.out.println("DateTime with minute set to 20: " + newDateTimeWithMinute);
System.out.println("DateTime with second set to 50: " + newDateTimeWithSecond);
System.out.println("DateTime with nano set to 123456789: " + newDateTimeWithNano);
/* 4. 比较 LocalDateTime 对象 */
//LocalDateTime 提供了多种比较方法：
LocalDateTime dateTime3 = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
LocalDateTime dateTime4 = LocalDateTime.of(2024, 10, 5, 14, 30, 45);
// 比较日期和时间
boolean isBefore = dateTime3.isBefore(dateTime4); // true
boolean isAfter = dateTime3.isAfter(dateTime4); // false
boolean isEqual = dateTime3.isEqual(dateTime4); // false
System.out.println("dateTime3 is before dateTime4: " + isBefore);
System.out.println("dateTime3 is after dateTime4: " + isAfter);
System.out.println("dateTime3 is equal to dateTime4: " + isEqual);
// 使用 compareTo 方法
int comparisonResult = dateTime3.compareTo(dateTime4);
if (comparisonResult < 0) {
System.out.println("dateTime3 is before dateTime4");
} else if (comparisonResult > 0) {
System.out.println("dateTime3 is after dateTime4");
} else {
System.out.println("dateTime3 is equal to dateTime4");
}
/* 5. 格式化和解析 LocalDateTime */
//5.1转换为字符串
//LocalDateTime 支持使用 DateTimeFormatter 来格式化为字符串：
LocalDateTime dateTime5 = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
// 使用默认格式
String formattedDateTime = dateTime5.toString();
System.out.println("Default formatted date and time: " + formattedDateTime);
// 使用自定义格式
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String customFormattedDateTime = dateTime5.format(formatter);
System.out.println("Custom formatted date and time: " + customFormattedDateTime);
//5.2从字符串解析
//可以使用 DateTimeFormatter 从字符串解析 LocalDateTime 对象：
String dateTimeStr = "2023-10-05 14:30:45";
// 使用默认格式
LocalDateTime parsedDateTime1 = LocalDateTime.parse("2023-10-05T14:30:45");
System.out.println("Parsed date and time (default): " + parsedDateTime1);
// 使用自定义格式
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime parsedDateTime2 = LocalDateTime.parse(dateTimeStr, formatter1);
System.out.println("Parsed date and time (custom): " + parsedDateTime2);
/* 6. 其他实用方法 */
//6.1获取 LocalDate 和 LocalTime
//可以从 LocalDateTime 对象中提取 LocalDate 和 LocalTime 对象：
LocalDateTime dateTime6 = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
// 获取 LocalDate 和 LocalTime
LocalDate date1 = dateTime6.toLocalDate();
LocalTime time1 = dateTime6.toLocalTime();
System.out.println("Date: " + date1);
System.out.println("Time: " + time1);
//6.2获取特定日期和时间
//可以使用 with 方法来获取特定日期和时间：
LocalDateTime dateTime7 = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
// 获取该月的第一天
LocalDateTime firstDayOfMonth = dateTime7.with(TemporalAdjusters.firstDayOfMonth());
System.out.println("First day of month: " + firstDayOfMonth);
// 获取该月的最后一天
LocalDateTime lastDayOfMonth = dateTime7.with(TemporalAdjusters.lastDayOfMonth());
System.out.println("Last day of month: " + lastDayOfMonth);
// 获取下一个星期一
LocalDateTime nextMonday = dateTime.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
System.out.println("Next Monday: " + nextMonday);
/* 7. 使用 Period 和 Duration */
LocalDateTime startDateTime = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
LocalDateTime endDateTime = LocalDateTime.of(2025, 10, 5, 16, 30, 45);
//7.1使用 Period 计算日期之间的差异
//Period 类可以用来计算两个日期之间的差异：
Period period = Period.between(startDateTime.toLocalDate(), endDateTime.toLocalDate());
System.out.println("Years: " + period.getYears());
System.out.println("Months: " + period.getMonths());
System.out.println("Days: " + period.getDays());
//7.2使用 Duration 计算时间之间的差异
//Duration 类可以用来计算两个时间点之间的差异，并用于时间计算：
Duration duration = Duration.between(startDateTime, endDateTime);
System.out.println("Hours: " + duration.toHours());
System.out.println("Minutes: " + duration.toMinutes());
System.out.println("Seconds: " + duration.getSeconds());
/* 8. 与时区结合使用 */
//LocalDateTime 不包含时区信息，但可以与 ZonedDateTime 结合使用来处理时区：
LocalDateTime dateTime8 = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
ZoneId zoneId = ZoneId.of("America/New_York");
// 转换为 ZonedDateTime
ZonedDateTime zonedDateTime = dateTime8.atZone(zoneId);
System.out.println("ZonedDateTime: " + zonedDateTime);
// 从 ZonedDateTime 获取 LocalDateTime
LocalDateTime localDateTimeFromZoned = zonedDateTime.toLocalDateTime();
System.out.println("LocalDateTime from ZonedDateTime: " + localDateTimeFromZoned);
}
@Test
public void testZonedDateTime() {
/* 1. 创建 ZonedDateTime 对象 */
//使用工厂方法
//可以使用静态工厂方法创建 ZonedDateTime 对象：
// 当前日期和时间，使用默认时区
ZonedDateTime currentDateTime = ZonedDateTime.now();
System.out.println("Current date and time: " + currentDateTime);
// 当前日期和时间，使用指定时区
ZonedDateTime currentDateTimeInZone = ZonedDateTime.now(ZoneId.of("America/New_York"));
System.out.println("Current date and time in New York: " + currentDateTimeInZone);
// 指定日期和时间，使用指定时区
LocalDateTime localDateTime = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
ZonedDateTime specificDateTime = ZonedDateTime.of(localDateTime, ZoneId.of("Asia/Tokyo"));
System.out.println("Specific date and time in Tokyo: " + specificDateTime);
// 解析日期和时间字符串
ZonedDateTime parsedDateTime = ZonedDateTime.parse("2023-10-05T14:30:45+09:00[Asia/Tokyo]");
System.out.println("Parsed date and time: " + parsedDateTime);
/* 2. 获取日期、时间和时区的各个部分 */
//可以通过 ZonedDateTime 的方法获取日期、时间和时区的各个部分：
ZonedDateTime dateTime = ZonedDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
int year = dateTime.getYear();
int month = dateTime.getMonthValue();
int day = dateTime.getDayOfMonth();
int hour = dateTime.getHour();
int minute = dateTime.getMinute();
int second = dateTime.getSecond();
int nano = dateTime.getNano();
String dayOfWeek = dateTime.getDayOfWeek().name();
ZoneId zone = dateTime.getZone();
System.out.println("Year: " + year);
System.out.println("Month: " + month);
System.out.println("Day: " + day);
System.out.println("Hour: " + hour);
System.out.println("Minute: " + minute);
System.out.println("Second: " + second);
System.out.println("Nano: " + nano);
System.out.println("Day of week: " + dayOfWeek);
System.out.println("Zone: " + zone);
/* 3. 修改 ZonedDateTime 对象 */
//ZonedDateTime 提供了多种方法来修改日期、时间和时区，这些方法会返回一个新的 ZonedDateTime 对象，因为 ZonedDateTime 是不可变的。
//3.1加和减日期和时间
ZonedDateTime dateTime1 = ZonedDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
// 加日期和时间
ZonedDateTime dateTimePlusDays = dateTime1.plusDays(10);
ZonedDateTime dateTimePlusWeeks = dateTime1.plusWeeks(2);
ZonedDateTime dateTimePlusMonths = dateTime1.plusMonths(1);
ZonedDateTime dateTimePlusYears = dateTime1.plusYears(1);
ZonedDateTime dateTimePlusHours = dateTime1.plusHours(2);
ZonedDateTime dateTimePlusMinutes = dateTime1.plusMinutes(15);
ZonedDateTime dateTimePlusSeconds = dateTime1.plusSeconds(30);
ZonedDateTime dateTimePlusNanos = dateTime1.plusNanos(1000000);
System.out.println("DateTime plus 10 days: " + dateTimePlusDays);
System.out.println("DateTime plus 2 weeks: " + dateTimePlusWeeks);
System.out.println("DateTime plus 1 month: " + dateTimePlusMonths);
System.out.println("DateTime plus 1 year: " + dateTimePlusYears);
System.out.println("DateTime plus 2 hours: " + dateTimePlusHours);
System.out.println("DateTime plus 15 minutes: " + dateTimePlusMinutes);
System.out.println("DateTime plus 30 seconds: " + dateTimePlusSeconds);
System.out.println("DateTime plus 1 millisecond: " + dateTimePlusNanos);
// 减日期和时间
ZonedDateTime dateTimeMinusDays = dateTime1.minusDays(10);
ZonedDateTime dateTimeMinusWeeks = dateTime1.minusWeeks(2);
ZonedDateTime dateTimeMinusMonths = dateTime1.minusMonths(1);
ZonedDateTime dateTimeMinusYears = dateTime1.minusYears(1);
ZonedDateTime dateTimeMinusHours = dateTime1.minusHours(2);
ZonedDateTime dateTimeMinusMinutes = dateTime1.minusMinutes(15);
ZonedDateTime dateTimeMinusSeconds = dateTime1.minusSeconds(30);
ZonedDateTime dateTimeMinusNanos = dateTime1.minusNanos(1000000);
System.out.println("DateTime minus 10 days: " + dateTimeMinusDays);
System.out.println("DateTime minus 2 weeks: " + dateTimeMinusWeeks);
System.out.println("DateTime minus 1 month: " + dateTimeMinusMonths);
System.out.println("DateTime minus 1 year: " + dateTimeMinusYears);
System.out.println("DateTime minus 2 hours: " + dateTimeMinusHours);
System.out.println("DateTime minus 15 minutes: " + dateTimeMinusMinutes);
System.out.println("DateTime minus 30 seconds: " + dateTimeMinusSeconds);
System.out.println("DateTime minus 1 millisecond: " + dateTimeMinusNanos);
//3.2设置日期、时间和时区
ZonedDateTime dateTime2 = ZonedDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
// 设置日期和时间
ZonedDateTime newDateTimeWithYear = dateTime2.withYear(2022);
ZonedDateTime newDateTimeWithMonth = dateTime2.withMonth(8);
ZonedDateTime newDateTimeWithDay = dateTime2.withDayOfMonth(15);
ZonedDateTime newDateTimeWithHour = dateTime2.withHour(10);
ZonedDateTime newDateTimeWithMinute = dateTime2.withMinute(20);
ZonedDateTime newDateTimeWithSecond = dateTime2.withSecond(50);
ZonedDateTime newDateTimeWithNano = dateTime2.withNano(123456789);
System.out.println("DateTime with year set to 2022: " + newDateTimeWithYear);
System.out.println("DateTime with month set to August: " + newDateTimeWithMonth);
System.out.println("DateTime with day set to 15: " + newDateTimeWithDay);
System.out.println("DateTime with hour set to 10: " + newDateTimeWithHour);
System.out.println("DateTime with minute set to 20: " + newDateTimeWithMinute);
System.out.println("DateTime with second set to 50: " + newDateTimeWithSecond);
System.out.println("DateTime with nano set to 123456789: " + newDateTimeWithNano);
// 设置时区
ZonedDateTime dateTimeInNewZone = dateTime2.withZoneSameInstant(ZoneId.of("Europe/London"));
System.out.println("DateTime in new zone (London): " + dateTimeInNewZone);
/* 4. 比较 ZonedDateTime 对象 */
//ZonedDateTime 提供了多种比较方法：
ZonedDateTime dateTime3 = ZonedDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
ZonedDateTime dateTime4 = ZonedDateTime.of(2024, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
// 比较日期和时间
boolean isBefore = dateTime3.isBefore(dateTime4); // true
boolean isAfter = dateTime3.isAfter(dateTime4); // false
boolean isEqual = dateTime3.isEqual(dateTime4); // false
System.out.println("dateTime3 is before dateTime4: " + isBefore);
System.out.println("dateTime3 is after dateTime4: " + isAfter);
System.out.println("dateTime3 is equal to dateTime4: " + isEqual);
// 使用 compareTo 方法
int comparisonResult = dateTime3.compareTo(dateTime4);
if (comparisonResult < 0) {
System.out.println("dateTime3 is before dateTime4");
} else if (comparisonResult > 0) {
System.out.println("dateTime3 is after dateTime4");
} else {
System.out.println("dateTime3 is equal to dateTime4");
}
/* 5. 格式化和解析 ZonedDateTime */
//5.1转换为字符串
//ZonedDateTime 支持使用 DateTimeFormatter 来格式化为字符串：
ZonedDateTime dateTime5 = ZonedDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
// 使用默认格式
String formattedDateTime = dateTime5.toString();
System.out.println("Default formatted date and time: " + formattedDateTime);
// 使用自定义格式
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss Z z");
String customFormattedDateTime = dateTime5.format(formatter);
System.out.println("Custom formatted date and time: " + customFormattedDateTime);
//5.2从字符串解析
//可以使用 DateTimeFormatter 从字符串解析 ZonedDateTime 对象：
String dateTimeStr = "2023-10-05 14:30:45 +0900 JST";
// 使用默认格式
ZonedDateTime parsedDateTime1 = ZonedDateTime.parse("2023-10-05T14:30:45+09:00[Asia/Tokyo]");
System.out.println("Parsed date and time (default): " + parsedDateTime1);
// 使用自定义格式
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss Z z");
ZonedDateTime parsedDateTime2 = ZonedDateTime.parse(dateTimeStr, formatter1);
System.out.println("Parsed date and time (custom): " + parsedDateTime2);
/* 6. 其他实用方法 */
//6.1与 Instant 结合使用
//可以将 ZonedDateTime 转换为 Instant，并相互转换：
ZonedDateTime dateTime6 = ZonedDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
// 转换为 Instant
Instant instant = dateTime6.toInstant();
System.out.println("Instant: " + instant);
// 从 Instant 转换回 ZonedDateTime
ZonedDateTime dateTimeFromInstant = instant.atZone(ZoneId.of("Asia/Tokyo"));
System.out.println("ZonedDateTime from Instant: " + dateTimeFromInstant);
//6.2获取 LocalDateTime
//可以从 ZonedDateTime 提取 LocalDateTime 对象：
ZonedDateTime dateTime7 = ZonedDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
// 获取 LocalDateTime
LocalDateTime localDateTime2 = dateTime7.toLocalDateTime();
System.out.println("LocalDateTime: " + localDateTime2);
//6.3转换为其他时区
//可以将 ZonedDateTime 转换为其他时区：
ZonedDateTime dateTime8 = ZonedDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
// 转换为其他时区
ZonedDateTime dateTimeInNewZone1 = dateTime8.withZoneSameInstant(ZoneId.of("Europe/London"));
System.out.println("DateTime in new zone (London): " + dateTimeInNewZone1);
/* 7. 使用 Period 和 Duration */
//7.1使用 Period 计算日期之间的差异
//Period 类可以用来计算两个日期之间的差异：
ZonedDateTime startDateTime = ZonedDateTime.of(2023, 1, 1, 0, 0, 0, 0, ZoneId.of("Asia/Tokyo"));
ZonedDateTime endDateTime = ZonedDateTime.of(2024, 1, 1, 0, 0, 0, 0, ZoneId.of("Asia/Tokyo"));
Period period = Period.between(startDateTime.toLocalDate(), endDateTime.toLocalDate());
System.out.println("Years: " + period.getYears());
System.out.println("Months: " + period.getMonths());
System.out.println("Days: " + period.getDays());
//7.2使用 Duration 计算时间之间的差异
//Duration 类可以用于计算两个时间点之间的差异，并用于时间计算：
ZonedDateTime startDateTime1 = ZonedDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
ZonedDateTime endDateTime2 = ZonedDateTime.of(2023, 10, 5, 16, 30, 45, 0, ZoneId.of("Asia/Tokyo"));
Duration duration = Duration.between(startDateTime1, endDateTime2);
System.out.println("Hours: " + duration.toHours());
System.out.println("Minutes: " + duration.toMinutes());
System.out.println("Seconds: " + duration.getSeconds());
}
@Test
public void testOffsetDateTime(){
// 当前日期和时间，使用系统默认的偏移量
OffsetDateTime currentDateTime = OffsetDateTime.now();
System.out.println("Current date and time: " + currentDateTime);
// 当前日期和时间，使用指定的偏移量
OffsetDateTime currentDateTimeWithOffset = OffsetDateTime.now(ZoneOffset.ofHours(-5));
System.out.println("Current date and time with offset: " + currentDateTimeWithOffset);
// 指定日期和时间，使用指定的偏移量
LocalDateTime localDateTime = LocalDateTime.of(2023, 10, 5, 14, 30, 45);
ZoneOffset offset = ZoneOffset.ofHours(9);
OffsetDateTime specificDateTime = OffsetDateTime.of(localDateTime, offset);
System.out.println("Specific date and time with offset: " + specificDateTime);
// 解析日期和时间字符串
OffsetDateTime parsedDateTime = OffsetDateTime.parse("2023-10-05T14:30:45+09:00");
System.out.println("Parsed date and time: " + parsedDateTime);
OffsetDateTime dateTime = OffsetDateTime.of(2023, 10, 5, 14, 30, 45, 0, ZoneOffset.ofHours(9));
int year = dateTime.getYear();
int month = dateTime.getMonthValue();
int day = dateTime.getDayOfMonth();
int hour = dateTime.getHour();
int minute = dateTime.getMinute();
int second = dateTime.getSecond();
int nano = dateTime.getNano();
String dayOfWeek = dateTime.getDayOfWeek().name();
ZoneOffset zoneOffset = dateTime.getOffset();
System.out.println("Year: " + year);
System.out.println("Month: " + month);
System.out.println("Day: " + day);
System.out.println("Hour: " + hour);
System.out.println("Minute: " + minute);
System.out.println("Second: " + second);
System.out.println("Nano: " + nano);
System.out.println("Day of week: " + dayOfWeek);
System.out.println("Zone offset: " + zoneOffset);
}
@Test
public void testSimpleDateFormat(){
try {
// 定义日期格式
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 获取当前日期和时间
Date now = new Date();
System.out.println("Current date and time: " + now);
// 格式化当前日期和时间
String formattedDate = dateFormat.format(now);
System.out.println("Formatted date: " + formattedDate);
// 定义一个日期字符串
String dateString = "2023-10-05 14:30:45";
System.out.println("Date string to parse: " + dateString);
// 解析日期字符串为 Date 对象
Date parsedDate = dateFormat.parse(dateString);
System.out.println("Parsed date: " + parsedDate);
// 使用自定义格式
SimpleDateFormat customDateFormat = new SimpleDateFormat("EEEE, MMMM dd, yyyy 'at' hh:mm:ss a z");
String customFormattedDate = customDateFormat.format(now);
System.out.println("Custom formatted date: " + customFormattedDate);
} catch (Exception e) {
System.out.println("An error occurred: " + e.getMessage());
}
}
}
扫一扫
5375
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
