Question

在Kotlin中，reified generics的形式有限。有没有办法使用具体化来过滤通用类型而不使用getClass()或as或任何类型的奇怪注释，即。只需使用is关键字？例如，我有以下结构：

import java.util.*

internal class Layout<out T : LayoutProtocol>(val t: T) {
    fun getName(): String {
        return t.getName()
    }
}

interface LayoutProtocol {
    fun getName(): String
}

internal class Vertical : LayoutProtocol {
    override fun getName(): String {
        return "Vertical"
    }
}

internal class Horizontal : LayoutProtocol {
    override fun getName(): String {
        return "Horizontal"
    }
}

fun main(args: Array<String>) {
    val layouts = LinkedList<Layout<*>>()
    layouts.add(Layout<Horizontal>(Horizontal()))
    layouts.add(Layout<Vertical>(Vertical()))
    println("Horizontal layouts:")
    layouts.filterIsInstance<Layout<Horizontal>>().forEach { println(it.getName()) }
}

输出：

Horizontal layouts:
Horizontal
Vertical

我希望输出以下内容。有没有办法得到：

Horizontal layouts:
Horizontal

如果我们查看filterIsInstance(...)的源代码，Kotlin会做一些棘手的事情来规避类型擦除，但仍然不起作用：

/**
 * Returns a list containing all elements that are instances of specified type parameter R.
 */
public inline fun <reified R> Iterable<*>.filterIsInstance(): List<@kotlin.internal.NoInfer R> {
    return filterIsInstanceTo(ArrayList<R>())
}

/**
 * Appends all elements that are instances of specified type parameter R to the given [destination].
 */
public inline fun <reified R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C {
    for (element in this) if (element is R) destination.add(element)
    return destination
}

如果在Kotlin中无法做到这一点，是否有任何语言（JVM或非JVM）可以让我执行以下操作：

inline fun <reified R: LayoutProtocol> filterVerticals(from: Iterable<Layout<R>>): Iterable<Layout<Vertical>> {
    val dest = ArrayList<Layout<Vertical>>()

    for (element in from)
        if (element is Layout<Vertical>)
            dest.add(element)

    return dest
}

Answer 1

只需按布局类的layouts属性过滤t: T LinkedList。

layouts.filter { it.t is Horizontal }.forEach { println(it.getName()) }

它会打印出你想要的。即。

Horizontal layouts:
Horizontal

Answer 2

由于类型擦除，没有简单的方法可以做到这一点，但是如果你真的想要并且性能/可读性/错误倾向不是你担心的，你可以做一些技巧：

首先，让我们为Layout添加工厂方法以保留已删除的类型

open internal class Layout<T : LayoutProtocol>(val t: T) {
  ...
  companion object {
    inline fun <reified T: LayoutProtocol> create(instance: T): Layout<T> {
      return object: Layout<T>(instance) {}
    }
  }
}

（注意：这里我为了简单起见删除了差异）

其次，你需要一个助手类

open class TypeLiteral<T> {
  val type: Type = getSuperclassTypeParameter(javaClass)

  companion object {
    fun getSuperclassTypeParameter(subclass: Class<*>) =
      (subclass.genericSuperclass as ParameterizedType).actualTypeArguments[0]
  }
}

（注意：Guice DI使用了相同的方法，它包含生产就绪的TypeLiteral实施方案）

最后我们自己的过滤方法

inline fun <reified R> Iterable<*>.genericFilterIsInstance() where R : Any =
  filterIsInstance<R>()
  .filter { object : TypeLiteral<R>() {}.type == it.javaClass.genericSuperclass }

现在它打印出你想要的东西

fun main(args: Array<String>) {
  val layouts = LinkedList<Layout<*>>()
  layouts.add(Layout.create(Horizontal()))
  layouts.add(Layout.create(Vertical()))
  println("Horizontal layouts:")
  layouts.genericFilterIsInstance<Layout<Horizontal>>().forEach { println(it.getName()) }
  /* prints:
  Horizontal layouts:
  Horizontal
   */
}

但请不要在生产代码中使用此答案。在现实生活中，传递一个类实例进行过滤总是更可取。

过滤掉没有反射或投射的通用类型

2 个答案: