How Do I Create An Enum From A String In Kotlin

When working with Kotlin, enums are a powerful tool for defining a fixed set of constants or values. They allow you to group related constants together and provide a type-safe way to work with these values. However, there may be situations where you need to convert a string into an enum value. In this article, we will explore various techniques for creating an enum from a string in Kotlin.

Understanding Enums in Kotlin

Before we dive into the details of converting a string to an enum in Kotlin, let’s have a quick overview of what enums are and how they work in the language.

What Are Enums?

Enums, short for enumerations, are a way to represent a fixed set of values in Kotlin. They provide a convenient and type-safe way to work with constants. In Kotlin, enum classes are declared using the enum class keyword, and each value in the enum is separated by a comma.

Here’s a simple example of an enum in Kotlin:

enum class Color {

In this example, Color is an enum class with three values: RED, GREEN, and BLUE. You can use these values like any other class or data type.

Enum Properties and Methods

Enum classes can also have properties and methods just like regular classes. Each enum value can have its own properties and methods, making enums a versatile tool for modeling data.

enum class DayOfWeek(val abbreviation: String) {
    MONDAY("Mon"), TUESDAY("Tue"), WEDNESDAY("Wed"),
    THURSDAY("Thu"), FRIDAY("Fri"), SATURDAY("Sat"), SUNDAY("Sun")

    fun isWeekend(): Boolean {
        return this == SATURDAY || this == SUNDAY

In this example, the DayOfWeek enum has a property abbreviation and a method isWeekend().

Creating an Enum from a String

Now that we have a basic understanding of enums in Kotlin, let’s explore different approaches to create an enum from a string.

Approach 1: Using valueOf() Function

Kotlin provides a built-in function called valueOf() that can be used to convert a string into an enum value. This function is automatically generated for every enum class and is case-sensitive.

Here’s how you can use valueOf() to convert a string into an enum:

val colorString = "RED"
val colorEnum = Color.valueOf(colorString) // Throws an IllegalArgumentException if the string does not match any enum value

In this example, colorString is a string containing the value “RED,” and we use valueOf() to convert it into a Color enum value.

Approach 2: Using enumValues() and find Extension Function

If you want to perform a case-insensitive lookup for enum values, you can use the enumValues() function in combination with the find extension function. This approach allows you to find an enum value based on a string without throwing an exception if no matching value is found.

val colorString = "red"
val colorEnum = enumValues<Color>().find {, ignoreCase = true) }

In this example, enumValues<Color>() returns an array of all Color enum values, and we use the find function to search for a matching value in a case-insensitive manner.

Approach 3: Using a Custom Mapping Function

If you have more complex requirements for mapping strings to enums, you can create a custom mapping function. This approach is useful when the string-to-enum mapping is not straightforward.

enum class Status {

fun mapStringToStatus(input: String): Status {
    return when (input.toLowerCase()) {
        "open" -> Status.OPEN
        "in_progress" -> Status.IN_PROGRESS
        "completed" -> Status.COMPLETED
        "canceled" -> Status.CANCELED
        else -> throw IllegalArgumentException("Invalid status string: $input")

In this example, we have an enum Status with values and a custom function mapStringToStatus that converts a string to the corresponding enum value.

Handling Invalid Strings

When working with string-to-enum conversion, it’s important to consider how to handle invalid input strings. In the examples above, we either used valueOf() (which throws an exception) or provided a custom mapping function (which also throws an exception for invalid input). Depending on your use case, you may want to handle invalid input differently, such as returning a default enum value or reporting an error.

Here’s an example of handling invalid input by returning a default enum value:

enum class Direction {

fun mapStringToDirection(input: String): Direction {
    return when (input.toLowerCase()) {
        "north" -> Direction.NORTH
        "south" -> Direction.SOUTH
        "east" -> Direction.EAST
        "west" -> Direction.WEST
        else -> Direction.NORTH // Default to NORTH for invalid input

In this example, if the input string doesn’t match any valid direction, it defaults to Direction.NORTH.

Frequently Asked Questions

How can I convert a string to an enum in Kotlin?
To convert a string to an enum in Kotlin, you can use the valueOf() function provided by the enum class. For example:

   val inputString = "ENUM_VALUE"
   val enumValue = EnumType.valueOf(inputString)

What should I do if the input string doesn’t match any enum value?
If the input string doesn’t match any enum value, a java.lang.IllegalArgumentException will be thrown. You should handle this exception to provide appropriate error handling in your code.

Is there a way to perform a case-insensitive enum conversion?
By default, valueOf() performs a case-sensitive lookup. If you want to perform a case-insensitive conversion, you can define a custom function like this:

   inline fun <reified T : Enum<T>> enumValueOfOrNull(name: String): T? =
       enumValues<T>().find {, ignoreCase = true) }

This function returns null if no matching enum value is found.

Can I create an enum from a string using a default value if it doesn’t exist?
Yes, you can create an enum from a string using a default value by using the enumValueOfOrNull function mentioned in the previous answer and providing a default value when null is returned:

   val inputString = "UNKNOWN"
   val enumValue = enumValueOfOrNull<EnumType>(inputString) ?: EnumType.DEFAULT

Is there a way to avoid exceptions when converting strings to enums?
Using enumValueOfOrNull as mentioned in previous answers helps you avoid exceptions when converting strings to enums. This way, you can gracefully handle cases where the input string doesn’t match any enum value without throwing an exception.

In Kotlin, enums provide a powerful way to work with a fixed set of values, and there are several techniques for converting a string into an enum value. Whether you choose to use the built-in valueOf() function, perform a case-insensitive lookup with enumValues() and find, or create a custom mapping function, the choice depends on your specific requirements.

When working with string-to-enum conversion, always consider how to handle invalid input to ensure robust and error-resistant code. By understanding and applying these techniques, you can efficiently work with enums and strings in your Kotlin projects.

You may also like to know about:

Leave a Reply

Your email address will not be published. Required fields are marked *