Year
Java 8中，Year类是一个不可变、线程安全的类，用于表示和操作年份。它主要用于处理与年份相关的日期和时间操作，例如获取当前年份、创建指定年份的Date对象等。
核心方法：
**now()**：该方法返回表示当前日期的Year对象。该方法使用系统默认的时区来获取当前年份。
**now(Clock clock)**：该方法返回表示指定时间戳的Year对象。该方法使用指定的Clock对象来获取当前年份。
**of(int year)**：该方法用于创建一个表示指定年份的Year对象。如果输入的年份参数不在范围内（公元1年-公元9999年），则会抛出IllegalArgumentException异常。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| public void test1() {
Year year = Year.now();
int currentYear = year.getValue();
System.out.println("当前年份：" + currentYear);
Clock clock = Clock.systemDefaultZone();
Year yearFromClock = Year.now(clock);
int yearFromClockValue = yearFromClock.getValue();
System.out.println("指定时间戳的年份：" + yearFromClockValue);
Year customYear = Year.of(2024);
int customYearValue = customYear.getValue();
System.out.println("自定义年份：" + customYearValue);
}
|
1
2
3
| 当前年份：2024
指定时间戳的年份：2024
自定义年份：2024
|
YearMonth
YearMonth类代表一个特定的年和月，可以表示任何合法的年和月组合，例如2020-02。它主要用于处理与年和月相关的日期和时间操作。
核心方法：
**now()**：获取当前年份和月份。例如，YearMonth.now()将返回当前的年和月。
**String format(DateTimeFormatter formatter)**：使用特定的格式格式化year-month。
**int get(TemporalField field)**：返回日期中特定域的int类型
**of(int year, int month)**：创建一个表示特定年和月的YearMonth对象。例如，YearMonth.of(2024, 1)将创建一个表示2024年1月的YearMonth对象。
**lengthOfMonth()**：返回当前YearMonth实例有多少天。例如，YearMonth.of(2020, 2).lengthOfMonth()将返回29，因为2020年是闰年，2月有29天。
1
2
3
4
5
6
7
8
| public void test2() {
YearMonth currentYearMonth = YearMonth.now();
System.out.printf("这个月的年月 %s 有 %d 天 %n", currentYearMonth, currentYearMonth.lengthOfMonth());
YearMonth creditCardExpiry = YearMonth.of(2025, Month.JULY);
System.out.printf("你输入的年月是 %s %n", creditCardExpiry);
}
|
1
2
| 这个月的年月 2024-01 有 31 天
你输入的年月是 2025-07
|
这个示例中，YearMonth.now()方法获取了当前的年和月，并使用lengthOfMonth()方法获取了当前年月的天数。另外，YearMonth.of(2025, Month.JULY)方法创建了一个表示2025年7月的YearMonth对象，并输出了该对象。
格式化为字符串
1
2
3
4
5
6
7
8
| public void test3(){
YearMonth ym = YearMonth.now();
String s = ym.format(DateTimeFormatter.ofPattern("MM yyyy"));
System.out.println(s);
YearMonth start = YearMonth.parse("2023-01-01", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
boolean flag = ym.isAfter(start);
System.out.println(ym + "比" + start + "时间更晚吗?" + flag);
}
|
1
2
| 01 2024
2024-01比2023-01时间更晚吗?true
|
获取特定域
1
2
3
4
5
6
7
| public void test4(){
YearMonth y = YearMonth.now();
long l1 = y.get(ChronoField.YEAR);
System.out.println(l1);
long l2 = y.get(ChronoField.MONTH_OF_YEAR);
System.out.println(l2);
}
|
增加月份
1
2
3
4
5
6
| public void test5(){
YearMonth ym1 = YearMonth.now();
System.out.println(ym1);
YearMonth ym2 = ym1.plus(Period.ofYears(2));
System.out.println(ym1 + "加两年后为" + ym2);
}
|
1
2
| 2024-01
2024-01加两年后为2026-01
|
YearMonth与LocalDate的转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public static LocalDate parseDateYearMonth(YearMonth yearMonth){
return LocalDate.of(yearMonth.getYear(),yearMonth.getMonthValue(),1);
}
public static YearMonth parseYearMonth(LocalDate localDate){
return YearMonth.of(localDate.getYear(),localDate.getMonthValue());
}
public void test6(){
YearMonth curYM = YearMonth.now();
System.out.println(curYM);
LocalDate curYMlocalDate = parseDateYearMonth(curYM);
System.out.println("LocalDate类型的当前年月为" + curYMlocalDate);
YearMonth curYearMonth = parseYearMonth(curYMlocalDate);
System.out.println("YearMonth类型的当前年月为" + curYearMonth);
}
|
1
2
3
| 2024-01
LocalDate类型的当前年月为2024-01-01
YearMonth类型的当前年月为2024-01
|
Java比较时间差几年/几个月
1
2
3
4
5
6
7
8
9
10
11
12
| public static void test7() {
YearMonth yearMonthFirst = YearMonth.of(2022, 6);
YearMonth yearMonthSecond = YearMonth.of(2022, 1);
YearMonth yearMonthNow = YearMonth.now();
int FirstToSecond = yearMonthFirst.compareTo(yearMonthSecond);
int FirstToNow = yearMonthFirst.compareTo(yearMonthNow);
int NowToFirst = yearMonthNow.compareTo(yearMonthFirst);
System.out.println(FirstToSecond);
System.out.println(FirstToNow);
System.out.println(NowToFirst);
}
|
MonthDay
在Java 8中，MonthDay是一个非常实用的类，它用于处理只有月和日的信息，而没有年和其他时间信息的情况。这可以用于处理生日、纪念日和星座等周期性问题。
核心方法：
of(int month, int day): 创建一个表示特定月日的MonthDay对象。
from(LocalDate): 从给定的LocalDate对象中提取月和日的信息，创建一个新的MonthDay对象。
equals(Object): 比较两个MonthDay对象是否相等。
这些方法的具体使用示例如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| public void test8() {
MonthDay monthDay = MonthDay.of(1, 15);
LocalDate localDate = LocalDate.now();
MonthDay day = MonthDay.from(localDate);
if (monthDay.equals(day)) {
System.out.println("两个MonthDay对象相等");
} else {
System.out.println("两个MonthDay对象不相等");
}
LocalDate nowDate = LocalDate.now();
LocalDate date = LocalDate.of(2024, Month.JANUARY, 1);
long days = ChronoUnit.DAYS.between(date, nowDate);
System.out.println(nowDate + "距离" + date + "有" + days + "天");
}
|
1
2
| 两个MonthDay对象相等
2024-01-15距离2024-01-01有14天
|
此外，你还可以使用MonthDay对象来计算两个日期之间相差的天数、月数或年数。例如，要计算两个给定的日期之间包含多少天，多少周或者多少年，可以使用**ChronoUnit.DAYS.between()，ChronoUnit.WEEKS.between()，ChronoUnit.YEARS.between()**等方法。
DayOfWeek
Java 8中的DayOfWeek是一个不可变的、线程安全的枚举，表示一周中的一天，如MONDAY、TUESDAY等，适用于需要表示一周中某一天的场景。除了日期名称，DayOfWeek也有一个数字值。可以使用数字值来获取日期名称，也可以通过日期名称来获取数字值。
核心方法：
**getValue()**：获取数字值（1-7）。
**toString()**：获取日期名称（如MONDAY、TUESDAY等）。
**of()**：通过数字值创建DayOfWeek对象。
1
2
3
4
5
6
7
8
9
10
11
| public void test9() {
DayOfWeek dayOfWeek = DayOfWeek.MONDAY;
int dayNumber = dayOfWeek.getValue();
System.out.println(dayNumber);
dayOfWeek = DayOfWeek.MONDAY;
String dayName = dayOfWeek.toString();
System.out.println(dayName);
DayOfWeek dayOfWeekFromNumber = DayOfWeek.of(1);
System.out.println(dayOfWeekFromNumber);
}
|
总结
Year、YearMonth、MonthDay、DayOfWeek是Java 8中新增的日期时间API的一部分，它们提供了更灵活和强大的日期和时间处理能力。这些类都是不可变的，意味着一旦创建了对象，其值就不能更改。这种设计使得对这些对象的并发操作更加安全和高效。同时，这些类都实现了Comparable接口，可以根据时间顺序进行比较。
