Kotlin集合intersect操作如何自定义相等比较器（无需重写equals）

方案1：通过映射（Map）实现高效交集查找 #

适合数据量较大的场景，利用Map的O(1)查找特性提升效率。假设两个数据类共享id字段：

// 示例数据类
data class ExistingData(val id: String, val existingField: String)
data class IncomingData(val id: String, val incomingField: Int)

fun findIntersection(existingList: List<ExistingData>, incomingList: List<IncomingData>): List<ExistingData> {
    // 将现有集合转为id到对象的映射
    val existingById = existingList.associateBy { it.id }
    // 提取传入集合的所有id，找到与现有集合id的交集
    val commonIds = incomingList.map { it.id }.intersect(existingById.keys)
    // 根据交集id获取对应的现有对象
    return commonIds.mapNotNull { existingById[it] }
}

如果需要同时获取两边的交集对象，可以扩展为：

fun findBidirectionalIntersection(existingList: List<ExistingData>, incomingList: List<IncomingData>): Pair<List<ExistingData>, List<IncomingData>> {
    val existingById = existingList.associateBy { it.id }
    val incomingById = incomingList.associateBy { it.id }
    val commonIds = existingById.keys.intersect(incomingById.keys)
    return Pair(
        commonIds.mapNotNull { existingById[it] },
        commonIds.mapNotNull { incomingById[it] }
    )
}

方案2：使用filter+any快速实现（小数据量友好） #

如果集合规模较小，直接用filter结合any判断共同字段相等即可，代码更简洁：

fun findIntersectionSimple(existingList: List<ExistingData>, incomingList: List<IncomingData>): List<ExistingData> {
    return existingList.filter { existing ->
        incomingList.any { incoming -> existing.id == incoming.id }
    }
}

注意：该方案时间复杂度为O(n*m)，数据量大时性能会下降。

方案3：自定义包装类复用intersect函数 #

如果想直接使用Kotlin标准库的intersect函数，可以给原对象套一层仅比较共同字段的包装类，避免修改原数据类的equals方法：

// 通用包装类，仅根据传入的key判断相等性
data class KeyWrapper<T>(val key: String, val original: T) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false
        other as KeyWrapper<*>
        return key == other.key
    }

    override fun hashCode(): Int {
        return key.hashCode()
    }
}

fun findIntersectionWithWrapper(existingList: List<ExistingData>, incomingList: List<IncomingData>): List<ExistingData> {
    val wrappedExisting = existingList.map { KeyWrapper(it.id, it) }
    val wrappedIncoming = incomingList.map { KeyWrapper(it.id, it) }
    // 使用intersect获取包装类的交集，再还原为原对象
    return wrappedExisting.intersect(wrappedIncoming).map { it.original }
}

这样既利用了标准库的intersect实现，又不会影响原数据类的默认相等性判断。

内容的提问来源于stack exchange，提问作者pbuchheit