KotlinのEnum.values()で全てのEnum値を取得する方法と応用事例

enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

fun getDirectionMessage(direction: Direction) {
    when (direction) {
        Direction.NORTH -> println("You are heading North.")
        Direction.SOUTH -> println("You are heading South.")
        Direction.EAST  -> println("You are heading East.")
        Direction.WEST  -> println("You are heading West.")
    }
}

fun main() {
    getDirectionMessage(Direction.NORTH)
}

You are heading North.

val allValues = EnumClass.values()

enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

fun main() {
    val directions = Direction.values()
    for (direction in directions) {
        println(direction)
    }
}

NORTH  
SOUTH  
EAST  
WEST  

fun main() {
    val count = Direction.values().size
    println("Total directions: $count")
}

Total directions: 4

enum class Color {
    RED, GREEN, BLUE, YELLOW
}

fun main() {
    val colors = Color.values()
    for (color in colors) {
        println(color)
    }
}

RED  
GREEN  
BLUE  
YELLOW  

enum class WeekDay {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY
}

fun main() {
    WeekDay.values().forEachIndexed { index, day ->
        println("Day $index: $day")
    }
}

Day 0: MONDAY  
Day 1: TUESDAY  
Day 2: WEDNESDAY  
Day 3: THURSDAY  
Day 4: FRIDAY  

enum class Status {
    PENDING, APPROVED, REJECTED, COMPLETED
}

fun main() {
    val filteredStatuses = Status.values().filter { it.name.startsWith("C") }
    for (status in filteredStatuses) {
        println(status)
    }
}

COMPLETED  

enum class Level {
    LOW, MEDIUM, HIGH
}

fun displayLevelMessage(level: Level) {
    when (level) {
        Level.LOW -> println("Low level - Proceed with caution.")
        Level.MEDIUM -> println("Medium level - Stay alert.")
        Level.HIGH -> println("High level - Take immediate action!")
    }
}

fun main() {
    for (level in Level.values()) {
        displayLevelMessage(level)
    }
}

Low level - Proceed with caution.  
Medium level - Stay alert.  
High level - Take immediate action!  

enum class Color {
    RED, GREEN, BLUE
}

fun main() {
    val colors = Color.values()
    for (color in colors) {
        println(color)
    }
}

RED  
GREEN  
BLUE  

enum class Color {
    RED, GREEN, BLUE
}

fun main() {
    val color = Color.valueOf("GREEN")
    println(color)
}

GREEN  

enum class Color {
    RED, GREEN, BLUE
}

fun main() {
    try {
        val color = Color.valueOf("YELLOW")
        println(color)
    } catch (e: IllegalArgumentException) {
        println("Error: ${e.message}")
    }
}

Error: No enum constant Color.YELLOW  

enum class Status {
    PENDING, APPROVED, REJECTED, COMPLETED
}

fun main() {
    for (status in Status.values()) {
        println("Current status: $status")
    }
}

Current status: PENDING  
Current status: APPROVED  
Current status: REJECTED  
Current status: COMPLETED  

enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

fun main() {
    Direction.values().forEachIndexed { index, direction ->
        println("Index $index: $direction")
    }
}

Index 0: NORTH  
Index 1: SOUTH  
Index 2: EAST  
Index 3: WEST  

enum class Priority {
    LOW, MEDIUM, HIGH, CRITICAL
}

fun main() {
    for (priority in Priority.values()) {
        if (priority == Priority.HIGH || priority == Priority.CRITICAL) {
            println("Attention required for: $priority")
        }
    }
}

Attention required for: HIGH  
Attention required for: CRITICAL  

enum class Level {
    BEGINNER, INTERMEDIATE, ADVANCED
}

fun displayLevels() {
    Level.values().forEach { level ->
        println("Level: $level")
    }
}

fun main() {
    displayLevels()
}

Level: BEGINNER  
Level: INTERMEDIATE  
Level: ADVANCED  

enum class ScreenState {
    LOADING, SUCCESS, ERROR
}

fun updateUI(state: ScreenState) {
    when (state) {
        ScreenState.LOADING -> println("Loading... Please wait.")
        ScreenState.SUCCESS -> println("Content loaded successfully!")
        ScreenState.ERROR   -> println("An error occurred. Please try again.")
    }
}

fun main() {
    updateUI(ScreenState.LOADING)
    updateUI(ScreenState.SUCCESS)
    updateUI(ScreenState.ERROR)
}

Loading... Please wait.  
Content loaded successfully!  
An error occurred. Please try again.  

enum class NetworkStatus {
    CONNECTED, DISCONNECTED, CONNECTING
}

fun displayNetworkStatus(status: NetworkStatus) {
    when (status) {
        NetworkStatus.CONNECTED    -> println("You are connected to the internet.")
        NetworkStatus.DISCONNECTED -> println("No internet connection.")
        NetworkStatus.CONNECTING   -> println("Connecting to the internet...")
    }
}

enum class ItemType {
    HEADER, CONTENT, FOOTER
}

fun getItemViewType(itemType: ItemType): Int {
    return when (itemType) {
        ItemType.HEADER  -> 0
        ItemType.CONTENT -> 1
        ItemType.FOOTER  -> 2
    }
}

enum class ThemeOption {
    LIGHT, DARK, SYSTEM_DEFAULT
}

fun applyTheme(option: ThemeOption) {
    when (option) {
        ThemeOption.LIGHT          -> println("Light theme applied.")
        ThemeOption.DARK           -> println("Dark theme applied.")
        ThemeOption.SYSTEM_DEFAULT -> println("System default theme applied.")
    }
}

fun main() {
    applyTheme(ThemeOption.DARK)
}

Dark theme applied.

enum class Status {
    PENDING, APPROVED, REJECTED
}

fun main() {
    val status = Status.APPROVED
    println(status.name) // 文字列として出力
}

APPROVED

fun main() {
    try {
        val status = Status.valueOf("REJECTED")
        println(status)
    } catch (e: IllegalArgumentException) {
        println("Invalid status name")
    }
}

REJECTED

enum class Priority {
    LOW, MEDIUM, HIGH
}

fun main() {
    val priority = Priority.HIGH
    println("Priority: ${priority.name}, Index: ${priority.ordinal}")
}

Priority: HIGH, Index: 2

fun getPriorityByIndex(index: Int): Priority? {
    val priorities = Priority.values()
    return if (index in priorities.indices) priorities[index] else null
}

fun main() {
    println(getPriorityByIndex(1)) // MEDIUM
    println(getPriorityByIndex(3)) // null
}

MEDIUM  
null

enum class ErrorCode(val code: Int, val message: String) {
    NOT_FOUND(404, "Resource not found"),
    UNAUTHORIZED(401, "Unauthorized access"),
    SERVER_ERROR(500, "Internal server error")
}

fun main() {
    for (error in ErrorCode.values()) {
        println("Code: ${error.code}, Message: ${error.message}")
    }
}

Code: 404, Message: Resource not found  
Code: 401, Message: Unauthorized access  
Code: 500, Message: Internal server error  

val errorMap = ErrorCode.values().associateBy { it.code }

fun main() {
    println(errorMap[404]) // NOT_FOUND
}

NOT_FOUND

enum class Status {
    PENDING, APPROVED, REJECTED
}

enum class Direction {
    NORTH, SOUTH
}

fun main() {
    val dir = Direction.NORTH
    if (dir == Direction.NORTH) {
        println("Going North")
    }
}

Going North

try {
    val status = Status.valueOf("INVALID")
} catch (e: IllegalArgumentException) {
    println("Invalid status")
}

Invalid status

interface Describable {
    fun getDescription(): String
}

enum class Priority : Describable {
    LOW {
        override fun getDescription() = "Low priority task"
    },
    HIGH {
        override fun getDescription() = "High priority task"
    }
}

fun main() {
    println(Priority.LOW.getDescription())
    println(Priority.HIGH.getDescription())
}

Low priority task  
High priority task