Kotlinでうるう年を判定する10選の方法

はじめに
●Kotlinとは
- ○Kotlinの特徴とメリット
●うるう年とは
- ○うるう年の定義
●Kotlinでうるう年を判定する方法10選
●Kotlinのうるう年判定の応用例
- ○サンプルコード11：うるう年の月日数計算
- ○サンプルコード12：次のうるう年までの日数計算
●注意点と対処法
- ○初心者が陥りがちなエラーとその解決方法
●カスタマイズ方法
- ○判定結果の出力形式を変更する方法
まとめ

はじめに

Kotlinは、最近のアプリケーション開発やサーバーサイドプログラミングの現場で非常に注目されているプログラミング言語です。

Androidアプリの開発を中心に多くの開発者がこの言語を取り入れており、それに伴いさまざまな実用的なプログラムやコードが作成されています。

本記事では、その中でも「うるう年を判定する方法」をKotlinを用いて、10の異なる手法で解説します。

うるう年の判定は、カレンダーアプリや日付計算のプログラムなど、さまざまな場面で使われるため、習得しておくと非常に便利です。

●Kotlinとは

Kotlinは、ロシアのソフトウェア開発会社JetBrainsが開発したプログラミング言語で、Javaの代わりや補完として使用されることが多い言語です。

Javaとの互換性がありつつ、より簡潔で読みやすい文法を持つことから、急速に人気を集めています。

○Kotlinの特徴とメリット

Kotlinの特徴は、Javaとの高い互換性が挙げられます。

Javaのライブラリやフレームワークをそのまま利用することができるため、Javaでの開発経験がある人には非常に馴染みやすい言語といえます。

また、Kotlinは「Null安全」を重視して設計されています。

この機能は、Nullポインタ例外を防ぐためのもので、これによりプログラムのバグを大幅に減少させることが期待されています。

次に、Kotlinの文法は非常に簡潔です。Javaと比べてもコード量が大幅に少なくなるため、可読性が高く、メンテナンスも容易になります。

さらに、Kotlinは関数型プログラミングの要素を取り入れているため、より効率的なプログラムを簡単に書くことができます。

具体的には、ラムダ式や拡張関数など、さまざまな便利な機能をサポートしています。

●うるう年とは

うるう年は、約365.24日となる地球が太陽の周りを1周する時間、すなわち太陽年を基にして、その約0.24日の差分を調整するために導入される特別な年のことを指します。

通常の年は365日ですが、この0.24日を無視し続けると、数十年、数百年と経過するうちに暦と季節のずれが大きくなってしまいます。

そのため、4年に1回、うるう年として1日を追加し、366日としています。具体的には、2月28日の次の日を2月29日とすることで、この調整を行います。

○うるう年の定義

うるう年の判定方法は、次の3つのルールで決まります。

年数が4で割り切れる年は、うるう年です。
ただし、年数が100で割り切れる年は、うるう年ではありません。
しかし、その例外として、年数が400で割り切れる年は、うるう年とします。

これらのルールをもとに、例えば2000年は400で割り切れるためうるう年となりますが、1900年は100で割り切れるものの400で割り切れないため、うるう年ではありません。

このようにして、うるう年は太陽年とのずれを調整するために存在しており、このルールに従った判定方法で、うるう年を判断することができます。

●Kotlinでうるう年を判定する方法10選

うるう年は、暦の調整のために導入された特別な年です。この特定の年は、他の年よりも1日多く、計366日となります。

プログラミングの世界でも、このうるう年の存在は特に日付やカレンダーの処理で重要となります。

今回は、Kotlinというプログラミング言語を用いて、うるう年をどのように判定するのか、10種類の方法を取り上げます。

初心者の方でも理解しやすいよう、それぞれの方法に対してサンプルコードを添え、実行後の結果も詳しく説明いたします。

○サンプルコード1：基本的な判定方法

まず最初に、うるう年の基本的な判定方法を紹介します。

先述したうるう年ルールを元に、Kotlinでのうるう年の判定を次のサンプルコードで行います。

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

fun main() {
    val year = 2024
    if (isLeapYear(year)) {
        println("$year 年はうるう年です。")
    } else {
        println("$year 年はうるう年ではありません。")
    }
}

このコードでは、isLeapYearという関数を定義して、与えられた年がうるう年かどうかを判定しています。

main関数内では、2024年がうるう年かどうかをチェックしています。

このコードを実行すると、”2024 年はうるう年です。”と表示されます。

2024年は4で割り切れるため、うるう年と判定されています。

○サンプルコード2：関数を使った判定

次に、関数を使った方法を紹介します。

前述の基本的な判定方法をベースに、より一般的な形にアレンジします。

下記のコードでは、任意の年を入力して、その年がうるう年かどうかをチェックするプログラムを表しています。

fun checkLeapYear(year: Int) {
    if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) {
        println("$year 年はうるう年です。")
    } else {
        println("$year 年はうるう年ではありません。")
    }
}

fun main() {
    println("年を入力してください：")
    val inputYear = readLine()!!.toInt()
    checkLeapYear(inputYear)
}

このコードを実行し、例えば1900年を入力すると、”1900 年はうるう年ではありません。”と表示されます。

1900年は100で割り切れるが400で割り切れないため、うるう年ではないと判定されています。

○サンプルコード3：拡張関数を利用した方法

Kotlinでは、すでに存在するクラスに新しい関数を追加することができる「拡張関数」という機能が提供されています。

この機能を用いると、Int型などの基本型にも独自の関数を追加することができます。

うるう年の判定を行う拡張関数を作成してみましょう。

下記のコードは、Int型の変数に対して、.isLeapYear()という関数を追加する例です。

fun Int.isLeapYear(): Boolean {
    return (this % 4 == 0 && this % 100 != 0) || this % 400 == 0
}

fun main() {
    val year = 2024
    if (year.isLeapYear()) {
        println("$year 年はうるう年です。")
    } else {
        println("$year 年はうるう年ではありません。")
    }
}

このコードでは、Int.isLeapYear()という拡張関数を用いてうるう年の判定を行っています。

この関数は、ある整数が4で割り切れ、かつ100で割り切れない、または400で割り切れる場合にうるう年であると判定します。

main関数の中で、任意の年を指定してこの拡張関数を使用しています。

このコードを実行すると、次のように2024年がうるう年であるかどうかを確認できます。

2024年はうるう年です。

拡張関数を使用することで、コードがシンプルになり、可読性も向上します。

特に、同じ処理を繰り返し使用する場合や、既存のクラスに特定の機能を追加したい場合に、拡張関数は非常に役立ちます。

○サンプルコード4：ライブラリを活用した判定

Kotlinの強力なエコシステムには、多数のライブラリが存在します。

これらのライブラリの中には、日付や時間に関する処理を助けるものもあります。

うるう年の判定も、特定のライブラリを利用することで、簡単に実現できます。

ここでは、Javaの標準ライブラリの一部であるjava.timeパッケージを活用してうるう年を判定する方法を解説します。

このパッケージは、Java 8から導入された新しい日付と時間のAPIを提供しており、Kotlinからもアクセス可能です。

import java.time.Year

fun isLeapYear(year: Int): Boolean {
    return Year.isLeap(year)
}

fun main() {
    val year = 2024
    if (isLeapYear(year)) {
        println("$year 年はうるう年です。")
    } else {
        println("$year 年はうるう年ではありません。")
    }
}

このコードではjava.time.Yearクラスを使っています。

このクラスにはisLeapという静的メソッドがあり、引数として渡された年がうるう年であるかを判定します。

結果はBoolean型として返されます。

主関数のmain内では、2024年がうるう年であるかを確認しています。

もし判定結果がうるう年であれば、”$year 年はうるう年です。”と表示し、そうでなければ、”$year 年はうるう年ではありません。”と表示します。

このコードを実行すると、”2024 年はうるう年です。”という結果が表示されます。

これは、2024年がうるう年であるためです。

○サンプルコード5：リストを使ったうるう年のリストアップ

うるう年を一覧で表示したい時、特定の年数の範囲内でうるう年だけを取り出して表示するという要件が考えられます。

このような場合、リストを活用してうるう年を効率的に取得する方法を紹介します。

まず、初めに考えられる方法は、特定の範囲内の全ての年を繰り返し処理でチェックし、うるう年の条件を満たす年だけを新しいリストに追加するという方法です。

Kotlinでのサンプルコードを紹介します。

fun main() {
    val startYear = 2000
    val endYear = 2020
    val leapYears = mutableListOf<Int>()

    for (year in startYear..endYear) {
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
            leapYears.add(year)
        }
    }

    println(leapYears)
}

このコードでは、2000年から2020年までの範囲でうるう年をチェックしています。

条件文には、うるう年の条件である「4で割り切れ、かつ100で割り切れない、または400で割り切れる」を利用しています。

該当する年をleapYearsというリストに追加して、最後にそのリストを出力しています。

このコードを実行すると、2000年から2020年までのうるう年がリストとして表示されます。

具体的には、[2000, 2004, 2008, 2012, 2016, 2020]というリストが得られることになります。

○サンプルコード6：年数の範囲での判定

うるう年の判定を一つの年だけでなく、複数の年に対して行いたい場合があります。

そんなときに役立つのが、年数の範囲での判定です。

特定の年から別の年までの間で、うるう年となる年をすべて調べることができます。

例として、2000年から2100年までの間で、うるう年となる年を調査するコードを作成してみましょう。

fun main() {
    val startYear = 2000
    val endYear = 2100

    for (year in startYear..endYear) {
        if (isLeapYear(year)) {
            println("$year 年はうるう年です。")
        }
    }
}

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

このコードでは、startYearからendYearまでの範囲をforループを使って順に処理しています。

各年について、isLeapYear関数でうるう年かどうかの判定を行っています。

うるう年の条件は、4で割り切れて100で割り切れない、または400で割り切れる、というものです。

このコードを実行すると、指定した範囲内でうるう年となる年が順に表示されます。

具体的には、2000年から2100年の間でうるう年となる年が出力される結果となります。

これにより、例えば、近い未来のうるう年を知りたいというようなニーズに応えることができます。

○サンプルコード7：入力からのうるう年判定

うるう年の判定は、西暦の年を4で割り切れる年がうるう年となります。

ただし、100で割り切れる年はうるう年ではありませんが、それが400で割り切れる場合はうるう年となる、というルールがあります。

このルールに基づいて、Kotlinを使用してユーザーからの入力を受け取り、うるう年かどうかを判定するプログラムを紹介します。

fun main() {
    println("西暦の年を入力してください：")
    val year = readLine()?.toIntOrNull()

    if (year != null) {
        if (isLeapYear(year)) {
            println("$year 年はうるう年です。")
        } else {
            println("$year 年はうるう年ではありません。")
        }
    } else {
        println("無効な入力です。")
    }
}

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

このコードでは、まずreadLine()を使ってユーザーからの入力を受け取ります。

その後、入力がnullでないか、正しく整数に変換できるかを確認します。

問題なければ、isLeapYear関数を呼び出して、入力された年がうるう年かどうかを判定します。

isLeapYear関数では、前述のルールに従い、うるう年かどうかを確認し、結果をBoolean型で返します。

このコードを実行すると、ユーザーが任意の年を入力することができます。入力された年がうるう年の場合、”〇〇年はうるう年です。”というメッセージが表示されます。

うるう年でない場合、”〇〇年はうるう年ではありません。”というメッセージが表示されます。

また、不正な入力がされた場合、”無効な入力です。”というメッセージを表示します。

たとえば、2024年を入力する場合、”2024年はうるう年です。”という結果が出力されます。

これは、2024が4で割り切れるため、うるう年の条件を満たしています。

○サンプルコード8：例外処理を取り入れた判定

Kotlinでのプログラミングを進める際、特にユーザーからの入力を受け取る場合など、不正な値や予期せぬ値が入力される可能性があります。

その際にプログラムがクラッシュしてしまうと、ユーザー体験が悪化してしまいます。

そのようなシチュエーションを避けるためには、例外処理を適切に取り入れることが必要です。

このセクションでは、例外処理を用いてうるう年の判定を行う方法について紹介します。

具体的には、ユーザーからの入力値が整数であるかどうかを確認し、整数でない場合や不正な値の場合にはエラーメッセージを表示するという方法をとります。

まず、次のサンプルコードをご覧ください。

import java.lang.NumberFormatException

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

fun main() {
    print("年を入力してください: ")
    val input = readLine()

    try {
        val year = input?.toInt() ?: throw NumberFormatException()
        if (isLeapYear(year)) {
            println("$year 年はうるう年です。")
        } else {
            println("$year 年はうるう年ではありません。")
        }
    } catch (e: NumberFormatException) {
        println("正しい年を入力してください。")
    }
}

このコードでは、isLeapYear関数を用いてうるう年の判定を行っています。

メイン関数内ではユーザーからの入力を受け取り、この値が整数であるかどうかをtry-catchブロックを用いて確認しています。

もし整数でない場合や入力が存在しない場合、NumberFormatExceptionが発生し、エラーメッセージが表示されます。

このコードを実行すると、ユーザーは年数を入力するよう求められます。整数を入力した場合、その年がうるう年であるかどうかが表示されます。

整数以外の文字列を入力した場合、”正しい年を入力してください。”というエラーメッセージが表示されます。

○サンプルコード9：複数の年を一度に判定する方法

Kotlinを使って複数の年をまとめてうるう年かどうかを判定する方法を解説します。

例えば、ある期間に含まれるうるう年を一括して取得したい場合や、特定の年のリストからうるう年のみを取り出したい場合など、効率的に判定したいシチュエーションが想定されます。

早速、複数の年を一度に判定するためのサンプルコードを作成していきましょう。

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

fun getLeapYears(years: List<Int>): List<Int> {
    return years.filter { isLeapYear(it) }
}

fun main() {
    val yearsList = listOf(2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2100)
    val leapYears = getLeapYears(yearsList)
    println(leapYears)
}

このコードでは、isLeapYear関数を使って指定された年がうるう年かどうかを判定しています。

次にgetLeapYears関数では、複数の年が格納されたリストを引数として受け取り、その中からうるう年だけをフィルタリングして新しいリストとして返します。

最後にmain関数で、2000年から2100年までの一部の年のリストを用意し、うるう年だけを取り出す例を表しています。

このコードを実行すると、指定した年のリストからうるう年だけが取り出され、次のような結果が得られます。

うるう年のリスト：[2000, 2004, 2008]

○サンプルコード10：クラスを活用した判定方法

Kotlinでは、データや機能をまとめるためのクラスを利用することができます。

クラスを使ってうるう年の判定を行う方法について詳しく見ていきましょう。

class LeapYearChecker(val year: Int) {
    fun isLeap(): Boolean {
        return when {
            year % 400 == 0 -> true
            year % 100 == 0 -> false
            year % 4 == 0 -> true
            else -> false
        }
    }
}

fun main() {
    val checker = LeapYearChecker(2020)
    val result = if (checker.isLeap()) "うるう年" else "うるう年ではありません"
    println("2020年は$result")
}

このコードでは、LeapYearCheckerというクラスを定義しています。

このクラスには、うるう年の判定を行うisLeapというメソッドが含まれており、うるう年の条件に基づいてBooleanの結果を返します。

main関数内で、LeapYearCheckerクラスのインスタンスを生成し、2020年がうるう年であるかを判定しています。

このインスタンス生成時に、判定対象となる年を引数として与え、isLeapメソッドを呼び出して判定結果を取得します。

そして、その結果に基づいてメッセージを表示しています。

このコードを実行すると、”2020年はうるう年”と表示されます。

なぜなら、2020年は4で割り切れるため、うるう年の条件を満たしているからです。

同じくこのクラスのインスタンスを生成する際に、他の年を引数として渡せば、その年がうるう年であるかどうかの判定結果を得ることができます。

●Kotlinのうるう年判定の応用例

うるう年の判定をKotlinで行う方法を理解した後、さらにその知識を応用して、うるう年に関するさまざまな計算や操作を行う方法を探ることができます。

ここでは、うるう年に関する応用的な計算や操作のサンプルコードを2つ紹介します。

○サンプルコード11：うるう年の月日数計算

うるう年では2月が29日までありますが、通常の年は28日までです。

この差異をKotlinで計算し、特定の年がうるう年であるかどうかに基づいて、2月の日数を返す関数を作成します。

fun getFebruaryDays(year: Int): Int {
    // うるう年の判定
    val isLeapYear = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
    // うるう年であれば29日、そうでなければ28日を返す
    return if (isLeapYear) 29 else 28
}

val year = 2024
val days = getFebruaryDays(year)
println("$year 年の2月は $days 日です。")

このコードではgetFebruaryDaysという関数を使って、引数として受け取った年がうるう年であるかを判定し、2月の日数を返しています。

このコードを実行すると、うるう年では「2024年の2月は29日です。」と出力され、通常の年では「2023年の2月は28日です。」と出力されます。

○サンプルコード12：次のうるう年までの日数計算

次に、ある年から次のうるう年までの日数を計算する方法を紹介します。

これにより、現在の年から次のうるう年までの待ち時間を知ることができます。

fun daysToNextLeapYear(year: Int): Int {
    var currentYear = year
    while (true) {
        currentYear++
        val isLeapYear = (currentYear % 4 == 0 && currentYear % 100 != 0) || currentYear % 400 == 0
        if (isLeapYear) {
            break
        }
    }
    return (currentYear - year) * 365 + (currentYear - year) / 4 - (currentYear - year) / 100 + (currentYear - year) / 400
}

val year = 2022
val days = daysToNextLeapYear(year)
println("$year 年から次のうるう年まで $days 日です。")

このコードではdaysToNextLeapYearという関数を使用して、指定された年から次のうるう年までの日数を計算しています。

この関数内では、指定された年を基にして次のうるう年を検出するまで年数を1つずつ増やしています。

また、その間の日数も考慮して最終的な日数を計算しています。

このコードを実行すると、例えば「2022年から次のうるう年まで 730日です。」というような結果が得られます。

●注意点と対処法

Kotlinでうるう年の判定を行う際、初心者がプログラムを書く上で直面する可能性のある一般的なエラーやミスを紹介します。

それぞれの問題点に対する対処法や回避策も合わせて解説します。

○初心者が陥りがちなエラーとその解決方法

□条件式の誤りによるうるう年判定のミス

多くの初心者が、うるう年の条件を正確に理解せずにコードを書いてしまうことがあります。

正確には、年が4で割り切れる場合、うるう年となりますが、年が100で割り切れる場合はうるう年ではありません。

しかし、400で割り切れる場合は再びうるう年となります。

このコードでは、上記の条件を正確に判定しています。

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

このコードを実行すると、指定した年がうるう年かどうかを真偽値で返します。

たとえば、isLeapYear(2024)を実行すると、trueが返ってきます。

□関数の戻り値の型が不正確

特に型推論を多用するKotlinでよく見られるエラーです。

例えば、うるう年の判定結果をString型で返そうとした場合、返り値の型を指定していないとコンパイルエラーが発生します。

正しい方法は、関数の返り値の型をしっかりと指定することです。

上のisLeapYear関数では、返り値の型をBooleanと明示しています。

□未初期化の変数の使用

KotlinはNull安全な言語であるため、初期化されていない変数の使用はコンパイルエラーとなります。

初心者の中には、変数を宣言しただけで使用しようとする方もいます。

解決策は、変数を宣言する際に初期値を与えるか、後で必ず値を代入することを確認することです。

var year: Int = 2023 // 初期値を与える

また、もし変数がnullを許容する場合は、型の後に?を付けて宣言します。

var year: Int? = null

□Kotlinのバージョンやライブラリの互換性問題

Kotlinのバージョンや使用しているライブラリのバージョンによっては、一部のメソッドや機能が利用できない場合があります。

特に、新しい機能を利用しようとしたときに問題が発生することがよくあります。

対処法としては、公式ドキュメントや関連するライブラリのドキュメントを確認し、互換性のあるバージョンを使用することをおすすめします。

また、プロジェクトのビルド設定や依存関係の管理ツールでバージョンを明示することで、予期せぬ問題を避けることができます。

●カスタマイズ方法

Kotlinでうるう年を判定する際、結果の出力形式や細かい判定の仕方など、多くのカスタマイズが可能です。

ここでは、判定結果の出力形式を変更する一つのカスタマイズ方法を取り上げます。

このカスタマイズにより、よりユーザーフレンドリーな表示や、異なる利用シーンに応じた出力が実現可能となります。

○判定結果の出力形式を変更する方法

□基本的な出力

最もシンプルなうるう年判定の結果を出力するコードは次のようになります。

fun main() {
    val year = 2024
    if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) {
        println("$year 年はうるう年です。")
    } else {
        println("$year 年はうるう年ではありません。")
    }
}

このコードでは2024を使ってうるう年の判定を行います。

年数を変えることで任意の年に対しての判定が可能です。

□結果を変数に格納して後で利用

結果を直接出力するのではなく、変数に結果を格納して後で利用したい場合は次のようにします。

fun main() {
    val year = 2024
    val result: String

    if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) {
        result = "$year 年はうるう年です。"
    } else {
        result = "$year 年はうるう年ではありません。"
    }
    println(result)
}

こちらの方法では、判定結果をresultという変数に格納しています。

この変数は後で他の処理に利用することができます。

□関数化して再利用性を高める

同じ判定ロジックを何度も書くのは効率的ではありません。関

関数化することで、判定ロジックの再利用性を高めることができます。

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

fun main() {
    val year = 2024
    val result = if (isLeapYear(year)) "$year 年はうるう年です。" else "$year 年はうるう年ではありません。"
    println(result)
}

このようにすると、isLeapYear関数を使って、任意の年に対してうるう年判定を簡単に行うことができます。