反向查找在Kotlin中有效的枚举？

我正在尝试找到对Kotlin枚举进行“反向查找”的最佳方法。我从有效Java中获得的收获之一是，您在枚举内部引入了静态映射以处理反向查找。使用一个简单的枚举将其移植到Kotlin可使我编写如下代码：

enum class Type(val value: Int) {
    A(1),
    B(2),
    C(3);

    companion object {
        val map: MutableMap<Int, Type> = HashMap()

        init {
            for (i in Type.values()) {
                map[i.value] = i
            } 
        }

        fun fromInt(type: Int?): Type? {
            return map[type]
        }
    }
}

我的问题是，这是最好的方法，还是有更好的方法？如果我有几个遵循类似模式的枚举怎么办？Kotlin中是否有办法使此代码在枚举中更可重用？

首先，的参数fromInt()应该是Int，而不是Int?。尝试Type使用null显然会导致null，并且调用方甚至不应尝试这样做。在Map还没有理由是可变的。该代码可以简化为：

companion object {
    private val map = Type.values().associateBy(Type::value)
    fun fromInt(type: Int) = map[type]
}

该代码太短了，坦率地说，我不确定是否值得尝试找到可重用的解决方案。

我们可以使用findwhich 返回与给定谓词匹配的第一个元素；如果找不到此类元素，则返回null。

companion object {
   fun valueOf(value: Int): Type? = Type.values().find { it.value == value }
}

在这种情况下，这没有多大意义，但这是@JBNized解决方案的“逻辑提取”：

open class EnumCompanion<T, V>(private val valueMap: Map<T, V>) {
    fun fromInt(type: T) = valueMap[type]
}

enum class TT(val x: Int) {
    A(10),
    B(20),
    C(30);

    companion object : EnumCompanion<Int, TT>(TT.values().associateBy(TT::x))
}

//sorry I had to rename things for sanity

通常，关于可重复使用的伴随对象的事情（不同于Java类中的静态成员）

可以认为更“惯用”的另一个选择是：

companion object {
    private val map = Type.values().associateBy(Type::value)
    operator fun get(value: Int) = map[value]
}

然后可以像这样使用Type[type]。

我发现自己通过自定义，手工编码，值几次进行反向查找，并提出了以下方法。

使enums实现一个共享接口：

interface Codified<out T : Serializable> {
    val code: T
}

enum class Alphabet(val value: Int) : Codified<Int> {
    A(1),
    B(2),
    C(3);

    override val code = value
}

该接口（尽管名称很奇怪：））将某个值标记为显式代码。目标是能够编写：

val a = Alphabet::class.decode(1) //Alphabet.A
val d = Alphabet::class.tryDecode(4) //null

可以使用以下代码轻松实现：

interface Codified<out T : Serializable> {
    val code: T

    object Enums {
        private val enumCodesByClass = ConcurrentHashMap<Class<*>, Map<Serializable, Enum<*>>>()

        inline fun <reified T, TCode : Serializable> decode(code: TCode): T where T : Codified<TCode>, T : Enum<*> {
            return decode(T::class.java, code)
        }

        fun <T, TCode : Serializable> decode(enumClass: Class<T>, code: TCode): T where T : Codified<TCode> {
            return tryDecode(enumClass, code) ?: throw IllegalArgumentException("No $enumClass value with code == $code")
        }

        inline fun <reified T, TCode : Serializable> tryDecode(code: TCode): T? where T : Codified<TCode> {
            return tryDecode(T::class.java, code)
        }

        @Suppress("UNCHECKED_CAST")
        fun <T, TCode : Serializable> tryDecode(enumClass: Class<T>, code: TCode): T? where T : Codified<TCode> {
            val valuesForEnumClass = enumCodesByClass.getOrPut(enumClass as Class<Enum<*>>, {
                enumClass.enumConstants.associateBy { (it as T).code }
            })

            return valuesForEnumClass[code] as T?
        }
    }
}

fun <T, TCode> KClass<T>.decode(code: TCode): T
        where T : Codified<TCode>, T : Enum<T>, TCode : Serializable 
        = Codified.Enums.decode(java, code)

fun <T, TCode> KClass<T>.tryDecode(code: TCode): T?
        where T : Codified<TCode>, T : Enum<T>, TCode : Serializable
        = Codified.Enums.tryDecode(java, code)

以下是一些先前的建议的变体，使用ordinal field和getValue：

enum class Type {
A, B, C;

companion object {
    private val map = values().associateBy(Type::ordinal)

    fun fromInt(number: Int): Type {
        require(number in 0 until map.size) { "number out of bounds (must be positive or zero & inferior to map.size)." }
        return map.getValue(number)
    }
}

}

另一个示例实现。OPEN如果没有输入匹配任何枚举选项，这还将设置默认值（此处为）：

enum class Status(val status: Int) {
OPEN(1),
CLOSED(2);

companion object {
    @JvmStatic
    fun fromInt(status: Int): Status =
        values().find { value -> value.status == status } ?: OPEN
}

}

提出了更通用的解决方案

inline fun <reified T : Enum<*>> findEnumConstantFromProperty(predicate: (T) -> Boolean): T? =
T::class.java.enumConstants?.find(predicate)

用法示例：

findEnumConstantFromProperty<Type> { it.value == 1 } // Equals Type.A

真正的惯用科特林方式。没有肿的反射代码：

interface Identifiable<T : Number> {

    val id: T
}

abstract class GettableById<T, R>(values: Array<R>) where T : Number, R : Enum<R>, R : Identifiable<T> {

    private val idToValue: Map<T, R> = values.associateBy { it.id }

    operator fun get(id: T): R = getById(id)

    fun getById(id: T): R = idToValue.getValue(id)
}

enum class DataType(override val id: Short): Identifiable<Short> {

    INT(1), FLOAT(2), STRING(3);

    companion object: GettableById<Short, DataType>(values())
}

fun main() {
    println(DataType.getById(1))
    // or
    println(DataType[2])
}

val t = Type.values（）[ordinal]

:)