How do I create an enum from a Int in Kotlin?

enum class Types(val value: Int) {
    FOO(1),
    BAR(2),
    FOO_BAR(3);

    companion object {
        fun fromInt(value: Int) = Types.values().first { it.value == value }
    }
}

You may want to add a safety check for the range and return null.


Enum#valueOf is based on name. Which means in order to use that, you'd need to use valueof("FOO"). The valueof method also takes a String, which explains the error. A String isn't an Int; types matter. The reason I mentioned what it does too, is so you know this isn't the method you're looking for.

If you want to grab one based on an int value, you need to define your own function to do so. You can get the values in an enum using values(), which returns an Array<Types> in this case. You can use firstOrNull as a safe approach, or first if you prefer an exception over null.

So add a companion object (which are static relative to the enum, so you can call Types.getByValue(1234) (Types.COMPANION.getByValue(1234) from Java) over Types.FOO.getByValue(1234).

companion object {
    private val VALUES = values();
    fun getByValue(value: Int) = VALUES.firstOrNull { it.value == value }
}

values() returns a new Array every time it's called, which means you should cache it locally to avoid re-creating one every single time you call getByValue. If you call values() when the method is called, you risk re-creating it repeatedly (depending on how many times you actually call it though), which is a waste of memory.

The function could also be expanded and check based on multiple parameters, if that's something you want to do. These types of functions aren't limited to one argument.

Naming of the function is entirely up to you though. It doesn't have to be getByValue.


If you are using integer value only to maintain order, which you need to access correct value, then you don't need any extra code. You can use build in value ordinal. Ordinal represents position of value in enum declaration.

Here is an example:

enum class Types {
    FOO,               //Types.FOO.ordinal == 0 also position == 0
    BAR,               //Types.BAR.ordinal == 1 also position == 1
    FOO_BAR            //Types.FOO_BAR.ordinal == 2 also position == 2
}

You can access ordinal value simply calling:

Types.FOO.ordinal

To get correct value of enum you can simply call:

Types.values()[0]      //Returns FOO
Types.values()[1]      //Returns BAR
Types.values()[2]      //Returns FOO_BAR

Types.values() returns enum values in order accordingly to declaration.

Summary:

Types.values(Types.FOO.ordinal) == Types.FOO //This is true

If integer values don't match order (int_value != enum.ordinal) or you are using different type (string, float...), than you need to iterate and compare your custom values as it was already mentioned in this thread.

Tags:

Kotlin

Recent Posts