1. Overview

A leap year contains an additional day – 366 days instead of 365 days. So, while working with date and time systems and use cases, it’s essential to account for the extra day.

In this tutorial, we’ll learn different ways to check leap year in Kotlin.

2. Algorithm

To check if a year is a leap year, we can check if the year is evenly divisible by 4. Further, for a century year, we also need to check it’s evenly divisible by 400.

Using this approach, we can say that 2024 is a leap year because it’s evenly divisible by 4. Similarly, 1900 isn’t a leap year because it’s not evenly divisible by 400 despite being divisible by 4.

Now that we understand the algorithm, we’ll implement it using different programming constructs available in Kotlin.

3. Using If–Else

Our algorithm is based on checking a few conditions, so let’s start by implementing it using the ifelse construct.

For this purpose, we’ll write the isLeapYearUsingIfElse() function:

fun isLeapYearUsingIfElse(year: Int): Boolean {
    if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
        return true
    } else {
        return false
    }
}

The implementation is quite intuitive. We check for the arithmetic conditions for leap year and return true when the condition is met. Otherwise, we return false.

Now, let’s verify the isLeapYearUsingIfElse() function for a few leap years:

Assertions.assertTrue(isLeapYearUsingIfElse(2024))
Assertions.assertTrue(isLeapYearUsingIfElse(2000))

Similarly, let’s check a few negative scenarios where our function should return false:

Assertions.assertFalse(isLeapYearUsingIfElse(2023))
Assertions.assertFalse(isLeapYearUsingIfElse(1900))

Perfect! It looks like we’ve got this one right.

4. Using Single Expression

We can further simplify our implementation by having a single expression in the return statement:

fun isLeapYearUsingSingleExpression(year: Int): Boolean {
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
}

Like always, we must check the outcome for different scenarios:

Assertions.assertTrue(isLeapYearUsingSingleExpression(2024))
Assertions.assertTrue(isLeapYearUsingSingleExpression(2000))
Assertions.assertFalse(isLeapYearUsingSingleExpression(2023))
Assertions.assertFalse(isLeapYearUsingSingleExpression(1900))

It works!

5. Using when Expression

In Kotlin, we can make our conditional statements more readable by using when expressions. Let’s see how we can use this idiom to write the isLeapYearUsingWhenExpression() function that uses a when expression:

fun isLeapYearUsingWhenExpression(year: Int): Boolean {
    when {
        (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) -> return true
        else -> return false
    }
}

We can see that the condition remains the same, but our code is much more concise.

Next, let’s verify it for both positive and negative scenarios:

Assertions.assertTrue(isLeapYearUsingWhenExpression(2024))
Assertions.assertTrue(isLeapYearUsingWhenExpression(2000))
Assertions.assertFalse(isLeapYearUsingWhenExpression(2023))
Assertions.assertFalse(isLeapYearUsingWhenExpression(1900))

The results are correct.

6. Using Extension Function

We can also write an extension function for the Calendar class that checks whether a calendar year is a leap year:

fun Calendar.isLeapYearCalendar(): Boolean {
    val daysInYear = this.getActualMaximum(Calendar.DAY_OF_YEAR)
    return daysInYear > 365
}

It’s worth noting that we call the getActualMaximum() function with Calendar.DAY_OF_YEAR property to get the number of days in the calendar year. Further, we can directly call the isLeapYearCalendar() function for Calendar values.

So, let’s go ahead and verify it for both scenarios:

val calendar = Calendar.getInstance()
calendar.set(Calendar.YEAR, 2024)
Assertions.assertTrue(calendar.isLeapYearCalendar())
calendar.set(Calendar.YEAR, 2000)
Assertions.assertTrue(calendar.isLeapYearCalendar())
calendar.set(Calendar.YEAR, 2023)
Assertions.assertFalse(calendar.isLeapYearCalendar())
calendar.set(Calendar.YEAR, 1900)
Assertions.assertFalse(calendar.isLeapYearCalendar())

Great! It looks like we nailed this one.

7. Conclusion

In this article, we learned how to check leap year in Kotlin. Furthermore, we explored concepts like when expression, ifelse construct, and extension function while solving the use case.

As always, the code from this article is available over on GitHub.

Comments are closed on this article!