从两个列表中获取不常见的元素 - KOTLIN

Question

我有两个相同模型类（STUDENT）的列表，示例学生对象结构如下，

{
  "_id": "5a66d78690429a1d897a91ed",
  "division": "G",
  "standard": "X",
  "section": "Secondary",
  "lastName": "Sawant",
  "middleName": "Sandeep",
  "firstName": "Shraddha",
  "pin": 12345,
  "isEditable": true,
  "isTracked": false
}

一个列表有 3 个对象，其他 2 个。假设列表 A 有 1、2、3 个学生，列表 B 有 1、2 个

所以我的问题是，是否有任何内置函数可以通过仅比较 id 来获取不常见元素 ？如果不是，我该如何解决这个问题。

仅供参考，以下是我解决的两种方法，但失败得很惨。

方法 1。

internal fun getDistinctStudents(studentsList: List<Students>, prefStudents: List<Students>): List<Students> {
    val consolidated = prefStudents.filter {
        prefStudents.any { students: Students -> it._id == students._id }
    }
    return prefStudents.minus(consolidated)
}

方法 2。

internal fun getDistinctStudents(studentsList: List<Students>, prefStudents: List<Students>): List<Students> {
    val consolidatedStudents = studentsList + prefStudents
    val distinctStudents = consolidatedStudents.distinctBy{ it._id }
    return prefStudents.minus(distinctStudents)
}

我们将不胜感激任何形式的帮助。

谢谢

Answer 1

在有人想出一个更简洁、更简洁的解决方案之前，我认为这是一个很容易阅读的可行方案：

internal fun getDistinctStudents(studentsList: List<Students>, prefStudents: List<Students>): List<Students> {
    val studentsIds = studentsList.map { it._id }          // [ 1, 2, 3 ]
    val prefStudentIds = prefStudents.map { it._id }       // [ 1, 2 ]
    val commonIds = studentsIds.intersect(prefStudentIds)  // [ 1, 2 ]

    val allStudents = studentsList + prefStudents      // [ Student1, Student2, Student3, Student1, Student2 ]
    return allStudents.filter { it._id !in commonIds } // [ Student3 ]
}

---

如果您有大量学生（数百人），请考虑在各个步骤中使用序列，也许在连接最后两个列表之前进行过滤也会有所帮助：

val filteredStudents = studentsList.filter { it._id !in commonIds }
val filteredPrefStudents = prefStudents.filter { it._id !in commonIds }
return filteredStudents + filteredPrefStudents

编辑：见this answer instead。

Answer 2

这是使用 HashMap 的解决方案，代码可能会更好，但我对 kotlin 很陌生

fun getDistinctStudents(studentsList: List<Student>, prefStudents: List<Student>): List<Student> {
    val studentsOccurrences = HashMap<Student, Int>()
    val consolidatedStudents = studentsList + prefStudents
    for (student in consolidatedStudents) {
        val numberOfOccurrences = studentsOccurrences[student]
        studentsOccurrences.put(student, if(numberOfOccurrences == null) 1 else numberOfOccurrences + 1)
    }
    return consolidatedStudents.filter { student -> studentsOccurrences[student] == 1 }
}

你的学生类应该是一个数据类或至少覆盖哈希码和等于用作键。

Answer 3

实现 Ahmed Hegazy 所发布内容的更多 Kotlin 方式。该地图将包含元素列表，而不是键和计数。

使用 HashMap 和 Kotlin 内置插件。 groupBy 使用 Lambda 中定义的键（本例中为 id）和项目列表（本例中为列表）创建一个 Map

然后过滤掉列表大小不是 1 的条目。

最后，将其转换为单个学生列表（因此调用 flatMap）

val list1 = listOf(Student("1", "name1"), Student("2", "name2"))
val list2 = listOf(Student("1", "name1"), Student("2", "name2"), Student("3", "name2"))

val sum = list1 + list2
return sum.groupBy { it.id }
    .filter { it.value.size == 1 }
    .flatMap { it.value }

Answer 4

在对 Kotlin 文档进行一些搜索之后，我终于找到了解决方案。我正在寻找的功能是filterNot

这是我尝试过的完整解决方案。

internal fun getDistinctStudents(studentsList: List<Students>, prefStudents: List<Students>): List<Students> {
    return prefStudents.filterNot { prefStudent ->
         studentsList.any {
             prefStudent._id == it._id
         }
    } 
}

返回不常见的元素。

Answer 5

目前在移动设备上，因此我无法对其进行测试，但这可能会满足您的需求。 使用 stdlib 中的减法 https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/subtract.html

internal fun getDistinctStudents(studentsList: List<Students>, prefStudents: 
List<Students>): List<Students> {
    return prefStudents.subtract(studentList) + studentList.subtract(prefStudents)
}

Answer 6

我知道这是一篇旧帖子，但我相信有一个更简洁、更短的解决方案。请参阅下面的示例，使用 Mikezx6r 的数据，其答案已被上述接受。

val list1 = listOf(Student("1", "name1"), Student("2", "name2"))
val list2 = listOf(Student("1", "name1"), Student("2", "name2"), Student("3", "name2"))

val difference = list2.toSet().minus(list1.toSet())

Answer 7

这是一个扩展功能，基本上可以满足您的需求。它假设元素E 知道如何被识别，例如Student._id 在您的示例中：

infix fun <E> Collection<E>.symmetricDifference(other: Collection<E>): Set<E> {
    val left = this subtract other
    val right = other subtract this
    return left union right
}

这是一个如何使用它的示例：

val disjunctiveUnion: List<Student> = listA symmetricDifference listB

我为其编写的示例测试用例：

@Test
fun `symmetric difference with one of either set`() {
    val left = listOf(1, 2, 3)
    val right = listOf(2, 3, 4)

    val result = left symmetricDifference right

    assertEquals(setOf(1, 4), result)
}

Answer 8

如果您有两个列表，其中元素被标识，例如通过某种 id (item.id)，然后您可以执行以下操作：

fisrtList.filter { it.id !in secondList.map { item -> item.id } }

我假设 firstList 和 secondList 自然包含相同类型的对象。