All 15 Java Date & Time API (java.time) questions
More in Java Date & Time API (java.time)
What is the difference between LocalDate, LocalTime, LocalDateTime, and ZonedDateTime, and when would you use each? How would you calculate the difference between two dates or times using Period and Duration, and what's the distinction between these two classes? How do you parse and format date/time values using DateTimeFormatter, and how does this replace the older, notoriously thread-unsafe SimpleDateFormat class? How would you use TemporalAdjusters to compute dates like 'the next Monday' or 'the last day of the month' relative to a given LocalDate? What is the significance of storing date-time values in UTC in a database or when transmitting between systems, rather than storing them in a specific local timezone? How would you determine whether a given year is a leap year, and calculate the number of days in a specific month, using the java.time API's built-in support rather than hand-writing this classic calendrical logic? How does the Instant class represent a point in time, and how does it differ fundamentally from ZonedDateTime in terms of what it actually represents and how it should be used? How would you correctly handle daylight saving time (DST) transitions when performing date-time arithmetic with ZonedDateTime, and what specific pitfalls exist around the 'spring forward' and 'fall back' transitions? How would you convert between the legacy java.util.Date/Calendar classes and the modern java.time API when working with older libraries or APIs that still require the legacy types? How would you implement a custom TemporalAdjuster to calculate business-specific date logic (like 'the next business day, skipping weekends and holidays')?
Advertisement
Back to results for “Date”
Java › Java Date & Time API (java.time)

How would you calculate a person's age or the number of days until a recurring annual event (like a birthday) using ChronoUnit, and what's a common pitfall with leap-year birthdays (February 29)?

Intermediate

Answer

ChronoUnit.YEARS.between(startDate, endDate) (or the more idiomatic Period.between() for calendar-based differences) computes a precise, calendar-aware age; a well-known edge case is a birthday falling on February 29 (a leap day), which doesn't exist in non-leap years -- different applications handle this differently (commonly treating either February 28 or March 1 as the observed birthday in non-leap years), and this business decision needs to be made explicitly and consistently rather than left to an unexamined default behavior of whatever date arithmetic happens to produce.
LocalDate birthDate = LocalDate.of(2000, 2, 29);  // a leap-day birthday
LocalDate nonLeapYear = LocalDate.of(2023, 1, 1);  // 2023 is NOT a leap year

long age = ChronoUnit.YEARS.between(birthDate, LocalDate.now());

// Handling the Feb 29 edge case explicitly for a non-leap year
LocalDate thisYearsBirthday = birthDate.withYear(2023).isLeapYear()
    ? birthDate.withYear(2023)
    : LocalDate.of(2023, 2, 28);  // or March 1, depending on the business's chosen convention
Real-world example A subscription renewal system explicitly decides and documents that a February 29 signup anniversary is treated as February 28 in non-leap years (rather than March 1, an equally valid alternative choice some other systems make), avoiding inconsistent or undefined behavior for the roughly 1-in-1461 users whose signup date happens to be a leap day.

Common follow-ups: What determines whether a given year is a leap year, and how does LocalDate.isLeapYear() implement this check?;How would ChronoUnit.DAYS.between() behave differently from Period.between().getDays() for computing a difference spanning multiple months?

Testing ASP.NET Core Applications;Design Patterns in Java
All 15 Java Date & Time API (java.time) questions