Question

我有一个ParentObject列表。 Foreach parentObject，它有2个childObject。像这样的图片

val listParent: MutableList<ParentObject> = mutableList() 

ParentObject {  
 ChildOjbect1{}   // object1 can not be NULL
 ChildOjbect2{}   // object2 can be NULL
}

而且，我想构建一个ChildObject的mutableList。

val listChild: MutableList<ChildObject> = mutableList()  

list.add(parentObject.childOjbect1) // Because childObj1 can not be null  
parentOjbect.childObject2?.let { child ->  
  list.add(child)  
}

问题：
我只需要有6个项目的listChild（基本上我想将listChild的大小固定为6）
我在Kotlin中进行如下编码：

fun buildListChild(): List<ChildOjbect> {
  val listChild // instance mutable listChild
  forEach( parent: listParent) {
    listChild.add(parent.childObject1)
    parent.childOjbect2?.let {  it ->
    listChild.add(it)
  }
  return listChild.take(6)
}

我认为性能不好，因为它会在所有父项中循环播放。除此之外，我真的不想在添加之前总是检查listChild的大小。
解决问题的最佳方法是什么？

Answer 1

您可以创建大小固定的列表或数组，但是在这种情况下，您需要将其初始化为val childList = arrayOfNulls<ChildObject>(6)（没有其他选项可以在不初始化的情况下使用大小固定的数组），并进行循环检查如果已满（或添加最后一个元素时）并从方法返回。

在这种情况下，您不需要遍历所有父元素，并且在剪切之后，只需进行简单的检查即可。

Answer 2

您可以使用简化的语法（已更新，感谢@ alexey-romanov）：

fun buildListChild() = parent
    .flatMap{it -> listOf(parent.childObject1, parent.childOjbect2)}
    .filterNotNull()

listOf()是不可变的。

如果列表中唯一存在的引用是只读的   种类繁多，我们可以认为集合是完全不变的。一个简单的方法   创建这样的集合就像这样：

val items = listOf(1, 2, 3)

当前，listOf方法是   使用数组列表实现，但将来会提高内存效率   可以返回利用   他们知道自己无法改变的事实。

Answer 3

这是一个简单的完整解决方案。

fun buildListChild(parents: List<ParentObject>) = parents
    .flatMap { listOfNotNull(it.childObject1, it.childObject2) }
    .take(6)
    .toMutableList()

或者您甚至可以避免创建嵌套列表，如下所示。

fun buildListChild(parents: List<ParentObject>) = sequence {
    for (parent in parents) {
        yield(parent.childObject1)
        if (parent.childObject2 != null) {
            yield(parent.childObject2)
        }
    }
}.take(6).toMutableList()

在Kotlin中固定List大小的最佳方法是什么

3 个答案: