Java 判断当前时间是否为昨天

在Java开发中，经常需要处理与时间相关的逻辑，比如判断某个时间点是否为昨天。这个需求看似简单，但实际上它涉及到了Java日期时间API的使用，特别是从Java 8开始引入的新的日期时间API（java.time包下的类），这些API比旧的java.util.Date和java.util.Calendar更加直观和易用。下面，我们将深入探讨如何使用Java 8及之后的版本来判断当前时间是否为昨天，并给出具体的代码样例。

一、Java 8及之后版本的解决方案

Java 8引入了新的日期时间API，主要位于java.time包下，这些API设计用来解决旧的日期时间API的许多问题，比如可变性、线程安全以及清晰度不足等。在java.time包中，LocalDate类表示不包含时间的日期，非常适合用来判断日期是否为昨天。

1. 使用LocalDate和LocalDateTime

对于仅需要日期（不涉及时间）的判断，我们可以使用LocalDate。如果你还需要考虑时间（比如判断当前时间是否落在昨天的某个时间段内），则可以使用LocalDateTime。

示例代码（仅日期）：

import java.time.LocalDate;  
  
public class YesterdayChecker {  
  
    public static void main(String[] args) {  
        // 获取当前日期  
        LocalDate today = LocalDate.now();  
        // 获取昨天的日期  
        LocalDate yesterday = today.minusDays(1);  
  
        // 判断今天是否为昨天  
        boolean isYesterday = LocalDate.now().equals(yesterday);  
  
        // 注意：这里的逻辑是判断当前日期是否为“明天”的前一天，即今天是否为昨天  
        // 因为我们在比较之前已经计算了yesterday，所以这里应该用today与yesterday比较  
        // 上面的isYesterday实际上是判断“明天”是否为“今天”，显然总是false  
  
        // 正确的判断  
        boolean isTodayYesterday = today.equals(yesterday.plusDays(1).minusDays(1)); // 总是true，但这里只是演示  
        // 实际上，我们只需要判断today和yesterday是否相等  
        boolean isActuallyYesterday = today.minusDays(1).equals(yesterday); // 总是true，因为yesterday就是today减一天  
  
        // 更简洁的判断  
        boolean isReallyYesterday = today.minusDays(1).equals(LocalDate.now().minusDays(1));  
  
        System.out.println("Is today yesterday? (Incorrect way, for demonstration): " + isYesterday);  
        System.out.println("Correct way to check if today is yesterday (always true for demonstration): " + isActuallyYesterday);  
        System.out.println("Actual check if today is really yesterday: " + isReallyYesterday);  
    }  
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.

注意：在上面的代码中，isYesterday的命名和逻辑实际上是误导的，因为我们在计算yesterday之后立即用LocalDate.now()去比较，这会导致isYesterday总是为false（除非执行到这一行代码时，时间恰好跨过了午夜）。正确的逻辑是比较today和yesterday，或者如isReallyYesterday所示，用LocalDate.now().minusDays(1)重新计算昨天的日期并与yesterday比较（这其实是多余的，因为yesterday已经是我们需要的值）。

2. 考虑时间因素

如果你需要判断当前时间是否落在昨天的某个时间段内（比如，从昨天的00:00到23:59:59），你可以使用LocalDateTime。

示例代码（考虑时间）：

import java.time.LocalDateTime;  
  
public class YesterdayTimeChecker {  
  
    public static void main(String[] args) {  
        // 获取当前时间  
        LocalDateTime now = LocalDateTime.now();  
  
        // 获取昨天的起始和结束时间  
        LocalDateTime yesterdayStart = now.toLocalDate().minusDays(1).atStartOfDay();  
        LocalDateTime yesterdayEnd = now.toLocalDate().minusDays(1).plusDays(1).atStartOfDay().minusNanos(1);  
  
        // 判断当前时间是否在昨天的时间范围内  
        boolean isYesterday = !now.isBefore(yesterdayStart) && now.isBefore(yesterdayEnd);  
  
        System.out.println("Is current time within yesterday? " + isYesterday);  
    }  
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.

注意，这里我们使用了atStartOfDay()来获取一天的开始时间（即00:00:00.000），并使用plusDays(1).atStartOfDay().minusNanos(1)来获取前一天的结束时间（即23:59:59.999999999，即前一天的最后一纳秒之前的时间点）。这是因为LocalDateTime的精度可以达到纳秒级，所以我们用minusNanos(1)来确保时间范围包含前一天的最后一刻。

二、处理时区问题

在上面的示例中，我们没有显式地处理时区问题，因为LocalDateTime是不带时区的。然而，在实际应用中，经常需要处理带有时区的时间。这时，你可以使用ZonedDateTime或OffsetDateTime类。

示例代码（考虑时区）：

import java.time.ZoneId;  
import java.time.ZonedDateTime;  
  
public class YesterdayCheckerWithTimeZone {  
  
    public static void main(String[] args) {  
        // 假设我们使用系统默认时区  
        ZoneId zoneId = ZoneId.systemDefault();  
  
        // 获取当前时间（带时区）  
        ZonedDateTime now = ZonedDateTime.now(zoneId);  
  
        // 获取昨天的同一时间（带时区）  
        ZonedDateTime yesterdayAtSameTime = now.minusDays(1);  
  
        // 如果我们只需要判断日期，不需要考虑具体时间点  
        boolean isTodayActuallyYesterday = now.toLocalDate().equals(yesterdayAtSameTime.toLocalDate());  
  
        // 但这里我们考虑时间也相同的情况（这通常不是判断“昨天”的标准）  
        boolean isExactlyTheSameTimeYesterday = now.equals(yesterdayAtSameTime.plusDays(1).minusDays(1)); // 总是false，除非恰好是午夜  
  
        // 正确的逻辑：只比较日期部分  
        boolean isYesterdayByDate = now.toLocalDate().minusDays(1).equals(yesterdayAtSameTime.toLocalDate()); // 总是true  
  
        // 输出结果  
        System.out.println("Is today's date yesterday's date? " + isTodayActuallyYesterday);  
        System.out.println("Is the exact same time as yesterday? (Not usually what we mean by 'yesterday') " + isExactlyTheSameTimeYesterday);  
        System.out.println("Correct way to check if today's date is yesterday's date: " + isYesterdayByDate);  
  
        // 如果你需要判断当前时间是否在昨天的某个特定时间段内（考虑时区）  
        ZonedDateTime yesterdayStart = yesterdayAtSameTime.withHour(0).withMinute(0).withSecond(0).withNano(0);  
        ZonedDateTime yesterdayEnd = yesterdayStart.plusDays(1).minusNanos(1);  
        boolean isCurrentTimeWithinYesterday = !now.isBefore(yesterdayStart) && now.isBefore(yesterdayEnd);  
  
        System.out.println("Is current time within yesterday (considering time and timezone)? " + isCurrentTimeWithinYesterday);  
    }  
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.

在这个示例中，我们使用了ZonedDateTime来处理带时区的时间。注意，当我们比较两个时间点是否在同一天时，我们使用了toLocalDate()方法来忽略时间部分只比较日期。同样地，如果你需要判断当前时间是否在昨天的某个时间段内，你需要先计算出那个时间段的起始和结束时间点，然后再进行比较。

结论

判断当前时间是否为昨天，在Java中可以通过使用LocalDate、LocalDateTime或ZonedDateTime等类来实现。选择哪个类取决于你的具体需求，比如是否需要处理时区，是否需要精确到秒或纳秒等。在大多数情况下，如果你只关心日期而不关心具体时间，LocalDate就足够了。如果你需要处理带时区的时间，那么ZonedDateTime会是更好的选择。