android - 为什么在 kotlin 中启动 flatMap 时需要调用 toList()？

Question

当我使用 my.flatMap {it.toList()} 时我可以得到正确的结果.

我认为 val my是 List<String> ，所以我不需要调用 toList() , 但代码 var ok3=my.flatMap { it }无法编译，为什么？

还有更多，代码var ok2=my.flatMap { bb }得到错误结果，为什么？

代码A

var my=listOf("abc","cef")
var bb=my.toList()

var ok1=my.flatMap {it.toList()}
var ok2=my.flatMap { bb }
//var ok3=my.flatMap { it }  //It's wrong

结果

致 Naetmul:

谢谢!

为什么你认为 it是String输入代码 val ok3=my.flatMap { it }

在我看来，it应该是 my输入 lambda 表达式，然后输入 my是List<String>类型。

图片

Answer 1

旁注:如果您不重新分配，val比 var 更受欢迎.

---

val my = listOf("abc","cef")
val bb = my.toList()

在这里，my 的类型是List<String> , 它的元素是 "abc"和 "cef" .

bb 的类型是List<String>因为List转化为List ,
它的元素是"abc"和 "cef" .

即 my和 bb是等价的，尽管它们是不同的实例。你不需要 bb .

---

var ok1 = my.flatMap {it.toList()}

这类似于

var ok1 = listOf<Char>() // empty List
for (it in my) {
    // `it` is the `String` type.
    // For the 1st iteration, it = "abc"
    // For the 2nd iteration, it = "cef"

    val chars: List<Char> = it.toList() // String is transformed into List of Chars

    ok1 = ok1 + chars
}

---

var ok2 = my.flatMap { bb }

这类似于

var ok2 = listOf<String>() // empty List
for (it in my) {
    // `it` is the `String` type.
    // For the 1st iteration, it = "abc"
    // For the 2nd iteration, it = "cef"

    ok2 = ok1 + bb // You know, bb = listOf("abc, "cef")
}

所以，ok2 = bb + bb (for 循环迭代两次，因为 my 有 2 个元素。)
这意味着 ok2 = listOf("abc", "cef") + listOf("abc", "cef")
这意味着 ok2 = listOf("abc", "cef", "abc", "cef")

---

val ok3=my.flatMap { it }  //It's wrong

这类似于

var ok3 = listOf<?>() // empty List
for (it in my) {
    // `it` is the `String` type.
    // For the 1st iteration, it = "abc"
    // For the 2nd iteration, it = "cef"

    ok3 = ok3 + it
}

ok3必须是 List类型。然而，it是String类型，类型不匹配。所以，编译错误!

---

如果您需要连接 List的 String , 你可以使用 joinToString()方法。

val my = listOf("abc", "cef")
val concat = my.joinToString("") // insert empty string between elements.

---

引用Kotlin standard library document of List .

fun <T, R> Iterable<T>.flatMap(
    transform: (T) -> Iterable<R>
): List<R>

Returns a single list of all elements yielded from results of transform function being invoked on each element of original collection.

假设一个变量list类型为 List<T> .

如果我们要执行val newList = list.flatMap(function) , 然后

function应该有函数类型 (T) -> Iterable<R> .
( function 的参数是 T 类型，它返回 Iterable<R> 。List 是 Collection 的子类型，并且 Collection is a subtype of 可迭代 , so 列表 is a subtype of 可迭代。)

newList将具有类型 List<R> .

it问题中将是 function 的参数.

所以，it将是 T -类型，而不是 List<T> -类型。
即 it将是 String -类型，而不是 List<String> -类型。