Kotlin enum classの使い方 entries・valueOf一覧

Kotlin の enum class（列挙型）とは、取り得る値をあらかじめ決めた定数の集まりを表すクラスです。 サイズ、曜日、状態のように「この中のどれか」と決まっているものを型にでき、決めていない値を書くとコンパイルの段階で気づけます。

この記事では、enum class に最初から付いているプロパティと関数を、戻り値と実行結果つきの一覧表にまとめました。Kotlin 1.9 から使える entries と従来の values() の違い、valueOf に存在しない名前を渡したときの例外の全文、それを null に変える書き方、プロパティ・メソッド・interface 実装・コード値からの逆引きまで、1つずつ動かして示します。

確認環境：Ubuntu 24.04 / Kotlin 2.4.20（kotlinc）/ OpenJDK 21.0.10。掲載した出力とエラー文は、すべてこの環境でコンパイル・実行して得たものです。

enum class の機能早見表

enum class Size { SMALL, MEDIUM, LARGE } に対する結果です。

全定数の一覧は entries、名前からの変換は valueOf（無い名前があり得るなら entries.find）と覚えておくと、ほとんどの用途をまかなえます。

まず動かす：基本の機能を1つのファイルで確認する

次のコードを Main.kt という名前で保存し、そのままコンパイルして実行できます。

import kotlin.enums.enumEntries

enum class Size { SMALL, MEDIUM, LARGE }

fun main() {
    val s = Size.MEDIUM
    println(s.name)                         // 定数名
    println(s.ordinal)                      // 0 始まりの宣言順
    println(s)                              // toString() は既定で name と同じ
    println(Size.entries)                   // 全定数のリスト
    println(Size.entries.size)
    println(Size.values().contentToString()) // 全定数の配列
    println(Size.valueOf("LARGE"))          // 名前から定数
    println(enumValueOf<Size>("SMALL"))     // 型引数で指定する版
    println(enumEntries<Size>())            // 型引数で指定する entries
    println(enumValues<Size>().contentToString())
    println(Size.SMALL.compareTo(Size.LARGE)) // ordinal の差
    println(Size.SMALL < Size.LARGE)
    println(Size.MEDIUM == Size.valueOf("MEDIUM"))
    println(Size.entries.sortedDescending())
    println(Size.entries[1])
    println(Size.entries.getOrNull(5))
    println(Size.MEDIUM.declaringJavaClass.simpleName)
}

kotlinc Main.kt -include-runtime -d main.jar
java -Dstdout.encoding=UTF-8 -jar main.jar

-Dstdout.encoding=UTF-8 は、日本語の出力を UTF-8 で表示するための指定です（このコードの出力は英数字だけですが、以降の例に合わせています）。

MEDIUM
1
MEDIUM
[SMALL, MEDIUM, LARGE]
3
[SMALL, MEDIUM, LARGE]
LARGE
SMALL
[SMALL, MEDIUM, LARGE]
[SMALL, MEDIUM, LARGE]
-2
true
true
[LARGE, MEDIUM, SMALL]
MEDIUM
null
Size

• 定数はカンマ区切りで並べるだけで定義できます。慣例として大文字とアンダースコアで書きます。
• enumEntries は import が必要です（kotlin.enums.enumEntries）。enumValueOf と enumValues は import なしで使えます。
• 定数どうしは == で比べられます。同じ定数は常に1個なので、valueOf で得たものとも等しくなります。

values() と entries の違い

全定数を得る方法は2つあります。Kotlin 1.9.0 で entries が安定版になり、公式ドキュメントでも entries が推奨されています。values() も引き続き使え、今回の環境ではコンパイル時の警告も出ませんでした。

enum class Size { SMALL, MEDIUM, LARGE }

fun main() {
    // values()：呼ぶたびに新しい配列
    val a = Size.values()
    val b = Size.values()
    println("values() === values() : ${a === b}")
    a[0] = Size.LARGE                         // 配列なので書き換えられる
    println("書き換えた配列       : ${a.contentToString()}")
    println("もう一度 values()    : ${Size.values().contentToString()}")

    // entries：毎回同じ不変リスト
    val x = Size.entries
    val y = Size.entries
    println("entries === entries   : ${x === y}")
    println("型                    : ${x::class.simpleName}")
    try {
        @Suppress("UNCHECKED_CAST")
        (x as MutableList<Size>).add(Size.SMALL)
    } catch (e: Exception) {
        println("追加しようとすると    : ${e::class.simpleName}")
    }
}

values() === values() : false
書き換えた配列       : [LARGE, MEDIUM, LARGE]
もう一度 values()    : [SMALL, MEDIUM, LARGE]
entries === entries   : true
型                    : EnumEntriesList
追加しようとすると    : ClassCastException

values() が毎回コピーを作るのは、配列が書き換え可能だからです。 呼び出し側が書き換えても元の定義に影響しないよう、新しい配列を渡しています。entries は書き換えられないリストなので、同じものを何度でも返せます。ループの中で何度も呼ぶ場面では、この差が効いてきます。

書き換えは多くの場合、次の置き換えで済みます。

文字列から enum に変換する：valueOf と例外

valueOf は、定数名と完全に一致する文字列を渡すとその定数を返します。存在しない名前を渡すとどうなるかを確かめます。

enum class Size { SMALL, MEDIUM, LARGE }

fun main() {
    println(Size.valueOf("XL"))
}

Exception in thread "main" java.lang.IllegalArgumentException: No enum constant Size.XL
    at java.base/java.lang.Enum.valueOf(Enum.java:293)
    at Size.valueOf(Main.kt)
    at MainKt.main(Main.kt:4)
    at MainKt.main(Main.kt)

IllegalArgumentException が発生し、メッセージは No enum constant Size.XL です。 画面の入力値や外部から届いた文字列のように、無い名前があり得る場面では、例外ではなく null で受け取る書き方が扱いやすくなります。

null に落とす書き方

enum class Size { SMALL, MEDIUM, LARGE }

// どの enum にも使える「見つからなければ null」
inline fun <reified T : Enum<T>> enumValueOrNull(name: String): T? =
    enumValues<T>().find { it.name == name }

fun main() {
    val input = "XL"

    // 1. entries.find：見つからなければ null
    println(Size.entries.find { it.name == input })
    // 2. firstOrNull も同じ意味
    println(Size.entries.firstOrNull { it.name == input })
    // 3. runCatching で例外を null に変える
    println(runCatching { Size.valueOf(input) }.getOrNull())
    // 4. 既定値に落とす
    println(Size.entries.find { it.name == input } ?: Size.MEDIUM)
    // 5. 大文字小文字や前後の空白をそろえてから探す
    println(Size.entries.find { it.name.equals(" large ".trim(), ignoreCase = true) })
    // 6. 型引数つきの共通関数
    println(enumValueOrNull<Size>("SMALL"))
    println(enumValueOrNull<Size>("XL"))
    // 7. 小文字のまま valueOf に渡すと例外になる
    try {
        Size.valueOf("small")
    } catch (e: IllegalArgumentException) {
        println(e.message)
    }
    try {
        enumValueOf<Size>("XL")
    } catch (e: IllegalArgumentException) {
        println(e.message)
    }
}

null
null
null
MEDIUM
LARGE
SMALL
null
No enum constant Size.small
No enum constant Size.XL

valueOf は大文字小文字も区別します。 "small" を渡すと No enum constant Size.small になります。入力をそのまま渡す場合は、前後の空白を trim で取り、ignoreCase で比べる形にすると安心です。

プロパティ・メソッド・抽象メソッド・interface 実装

enum class はクラスなので、コンストラクタ引数、プロパティ、メソッドを持てます。注文の状態を例に、よく使う機能を1つにまとめます。

interface Labeled {
    val label: String
    fun display(): String = "[$label]"
}

// プロパティ・メソッド・抽象メソッド・interface 実装をまとめた例
enum class OrderStatus(val code: Int, override val label: String) : Labeled {
    RECEIVED(10, "受付") {
        override fun next() = PACKING
    },
    PACKING(20, "梱包中") {
        override fun next() = SHIPPED
    },
    SHIPPED(30, "発送済み") {
        override fun next() = DELIVERED
        override fun display() = "<<$label>>"     // 定数ごとに上書きもできる
    },
    DELIVERED(40, "配達完了") {
        override fun next() = this
    };                                            // メンバーを続けるときはセミコロン

    abstract fun next(): OrderStatus              // 定数ごとに実装する

    val isFinal: Boolean get() = this == DELIVERED // 共通のプロパティ
    fun canCancel(): Boolean = this < SHIPPED      // 共通のメソッド（宣言順で比較）

    companion object {
        private val byCode = entries.associateBy { it.code }
        fun fromCode(code: Int): OrderStatus? = byCode[code]
    }
}

fun main() {
    for (s in OrderStatus.entries) {
        println("${s.name} code=${s.code} ${s.display()} next=${s.next()} cancel=${s.canCancel()} final=${s.isFinal}")
    }
    println(OrderStatus.fromCode(20))
    println(OrderStatus.fromCode(99))
    println(OrderStatus.fromCode(99)?.label ?: "不明なコード")
    val labeled: Labeled = OrderStatus.RECEIVED
    println(labeled.display())
}

RECEIVED code=10 [受付] next=PACKING cancel=true final=false
PACKING code=20 [梱包中] next=SHIPPED cancel=true final=false
SHIPPED code=30 <<発送済み>> next=DELIVERED cancel=false final=false
DELIVERED code=40 [配達完了] next=DELIVERED cancel=false final=true
PACKING
null
不明なコード
[受付]

押さえておきたい決まり

• 定数の後ろにメンバーを書くときは、最後の定数のあとにセミコロンを置きます。定数だけの enum では不要です。
• 抽象メソッドは全定数で実装が必要です。実装のない定数 B があると enum entry 'Step.B' does not implement abstract member というコンパイルエラーになり、定数を足したときの書き忘れに気づけます。
• enum class は interface を実装できますが、クラスは継承できません（Kotlin 公式ドキュメントに記載）。
• 宣言順がそのまま大小関係になります。this < SHIPPED は「SHIPPED より前に宣言された定数か」を意味します。順番を入れ替えると結果も変わるので、順番に意味を持たせる場合はコメントで残しておくと親切です。

コード値からの逆引き

データベースや API では、状態を 10・20 のようなコード値でやり取りすることがあります。コードから定数を得るには、companion object に Map を1回だけ作っておきます。

companion object {
    private val byCode = entries.associateBy { it.code }
    fun fromCode(code: Int): OrderStatus? = byCode[code]
}

associateBy は「コード → 定数」の Map を作ります。戻り値を OrderStatus? にしておくと、無いコードが来たときに null になり、呼び出し側は ?: で既定の動きを書けます（上の出力の「不明なコード」）。

保存や通信には、ordinal ではなく自分で決めたコード値か name を使うのがおすすめです。ordinal は定数の並び順で決まるので、途中に定数を足すと番号がずれます。

when で分岐する：網羅エラーとインスタンス化のエラー

enum を when で分岐すると、全定数を書いたかどうかをコンパイラが確かめてくれます。MEDIUM の分岐を書かずにコンパイルします。

enum class Size { SMALL, MEDIUM, LARGE }

fun price(size: Size): Int = when (size) {
    Size.SMALL -> 300
    Size.LARGE -> 500
}

fun main() {
    println(price(Size.SMALL))
    val s = Size()
}

Price.kt:3:30: error: 'when' expression must be exhaustive. Add the 'MEDIUM' branch or an 'else' branch.
fun price(size: Size): Int = when (size) {
                             ^^^^
Price.kt:10:13: error: cannot access 'constructor(): Size': it is private in 'Size'.
    val s = Size()
            ^^^^
Price.kt:10:13: error: enum types cannot be instantiated.
    val s = Size()
            ^^^^^^

• 1つ目：足りない定数の名前（MEDIUM）がエラー文に出ます。その分岐を足せば解決します。else を書いても通りますが、定数を足したときに気づけなくなるので、全定数を並べる書き方がおすすめです。
• 2・3つ目：enum class は自分でインスタンスを作れません。定数として宣言したものだけが存在します。

toString の上書き・集計・EnumMap

最後に、日々の作業でよく使う操作をまとめます。

import java.util.EnumMap
import java.util.EnumSet

enum class Size(val cm: Int) {
    SMALL(60), MEDIUM(80), LARGE(100);

    override fun toString(): String = "${name.lowercase()}(${cm}cm)"
}

enum class Day { MON, TUE, WED, THU, FRI, SAT, SUN }

fun price(size: Size): Int = when (size) {
    Size.SMALL -> 300
    Size.MEDIUM -> 400
    Size.LARGE -> 500
}

fun main() {
    // toString を上書きしても name は変わらない
    println(Size.SMALL)
    println(Size.SMALL.name)
    println(Size.valueOf("SMALL"))

    // when（else なしで全部の定数を書く）
    println(Size.entries.map { price(it) })

    // 集計・絞り込み・並べ替え
    println(Size.entries.filter { it.cm >= 80 })
    println(Size.entries.maxBy { it.cm })
    println(Size.entries.associate { it.name to it.cm })
    println(listOf(Size.LARGE, Size.SMALL, Size.MEDIUM).sorted())

    // enum をキーにした集計
    val orders = listOf(Size.SMALL, Size.LARGE, Size.SMALL, Size.SMALL)
    println(orders.groupingBy { it }.eachCount())
    val stock = EnumMap<Size, Int>(Size::class.java)
    stock[Size.LARGE] = 3
    stock[Size.SMALL] = 12
    println(stock)                       // 入れた順でなく宣言順に並ぶ

    // 範囲とセット
    val weekend = EnumSet.of(Day.SAT, Day.SUN)
    println(Day.FRI in weekend)
    println(Day.entries.filter { it in Day.TUE..Day.THU })
    println(Day.entries[(Day.SUN.ordinal + 1) % Day.entries.size])
}

small(60cm)
SMALL
small(60cm)
[300, 400, 500]
[medium(80cm), large(100cm)]
large(100cm)
{SMALL=60, MEDIUM=80, LARGE=100}
[small(60cm), medium(80cm), large(100cm)]
{small(60cm)=3, large(100cm)=1}
{small(60cm)=12, large(100cm)=3}
false
[TUE, WED, THU]
MON

toString を上書きしても name は変わりません。 表示は toString、保存や変換は name、と役割を分けて使えます。

enum class が向いている場面の目安

つまずきやすい点の一覧

よくある質問

Q. values() と entries はどちらを使えばよいですか？ A. entries がおすすめです。values() は呼ぶたびに新しい配列を作りますが、entries は毎回同じ読み取り専用リストを返します。List なので filter や find もそのまま使えます。Kotlin 1.9.0 以降で使えます。

Q. 文字列から enum に、例外なしで変換するには？ A. Size.entries.find { it.name == 文字列 } と書くと、無い名前のときに null が返ります。既定値にしたいときは ?: Size.MEDIUM を続けます。valueOf をそのまま使うなら runCatching { Size.valueOf(文字列) }.getOrNull() でも同じ結果になります。

Q. enum class にメソッドやプロパティを持たせられますか？ A. 持たせられます。コンストラクタ引数でプロパティを定義し、定数の並びの最後にセミコロンを置いてからメソッドを書きます。抽象メソッドを宣言して定数ごとに実装を変えることも、interface を実装することもできます。

Q. name と toString() は何が違いますか？ A. name は宣言した定数名そのもので、変えられません。toString() は既定で name と同じ文字列を返しますが、上書きできます。valueOf が使うのは name のほうです。

まとめ

• 全定数の一覧は entries。毎回同じ読み取り専用リストが返り、List の関数がそのまま使える
• values() は呼ぶたびに新しい配列を作る。置き換えは values() を entries にするだけで済む場面が多い
• valueOf は無い名前で IllegalArgumentException（No enum constant …）。大文字小文字も区別する
• null で受けたいときは entries.find。valueOf を使うなら runCatching と getOrNull
• プロパティ・メソッド・抽象メソッド・interface 実装を持てる。メンバーを書くときは定数の最後にセミコロン
• コード値からの逆引きは companion object の Map。保存には ordinal でなくコード値か name
• when は else なしで全定数を書くと、定数を足したときにコンパイラが場所を教えてくれる

参考・出典

• Kotlin 公式ドキュメント「Enum classes」（entries、valueOf、enumEntries、Comparable、interface 実装）: https://kotlinlang.org/docs/enum-classes.html
• Kotlin 公式ドキュメント「What's new in Kotlin 1.9.0」（entries の安定版化）: https://kotlinlang.org/docs/whatsnew19.html

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。