在forEach中继续类型行为

list.forEach { item -> // here forEach give you data item and you can use it 
    if () {
        // your code
        return@forEach // Same as continue
    }

    // your code
}

对于中断类型的行为，你必须使用for in，直到或for in，因为每个列表是可空的或不可空的

对于Nullable列表: For (index in 0 until list.size) { Val item = list[index] //你可以使用数据项了 If () { //你的代码 打破 ｝ //你的代码 ｝ 对于非空列表: For (item in list){//数据项立即可用 If () { //你的代码 打破 ｝ //你的代码 ｝

也许把forEach改成这样:

for (it in myList) {
    if (condition) {
        doSomething()
    } else {
        break // or continue
    }
} 

它适用于HashMap的:

 for (it in myMap) {
     val k = it.key
     val v = it.value

     if (condition) {
         doSomething()
     } else {
         break // or continue
     }
 }

我有一个完美的解决方案(:

list.apply{ forEach{ item ->
    if (willContinue(item)) return@forEach
    if (willBreak(item)) return@apply
}}

编辑: 根据Kotlin的文档，可以使用注释来模拟继续。

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach lit@ {
        if (it == 3) return@lit // local return to the caller of the lambda, i.e. the forEach loop
        print(it)
    }
    print(" done with explicit label")
}

如果您想模拟中断，只需添加一个运行块

fun foo() {
    run lit@ {
        listOf(1, 2, 3, 4, 5).forEach {
            if (it == 3) return@lit // local return to the caller of the lambda, i.e. the forEach loop
            print(it)
        }
        print(" done with explicit label")
    }
}

最初的回答: 因为你提供了一个(Int) ->单元，你不能中断它，因为编译器不知道它是在循环中使用的。

你有几个选择:

使用常规的for循环:

for (index in 0 until times) {
    // your code here
}

如果循环是方法中的最后一个代码 您可以使用return来退出方法(如果不是单元方法，则返回值)。

使用方法 创建一个自定义重复方法，该方法返回用于继续的布尔值。

public inline fun repeatUntil(times: Int, body: (Int) -> Boolean) {
    for (index in 0 until times) {
        if (!body(index)) break
    }
}

正如Kotlin文档所说，使用return是正确的方法。Kotlin的好处是，如果你有嵌套函数，你可以使用标签显式地写你的返回值来自哪里:

函数范围

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        /** Non-local return directly to the caller of foo(). */
        if (it == 3) return
        print(it)
    }

    println("this point is unreachable")
}

当地的回报

它不会在forEach循环中停止(它就像for循环中的continue)。

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach lit@{
        /** Local return to the caller of the lambda, i.e. the forEach loop. */
        if (it == 3) return@lit
        print(it)
    }

    print(" done with explicit label")
}

看看文档，它真的很好:)

可以使用以下方法实现中断:

//Will produce "12 done with nested loop"
//Using "run" and a tag will prevent the loop from running again.
//Using return@forEach if I>=3 may look simpler, but it will keep running the loop and checking if i>=3 for values >=3 which is a waste of time.
fun foo() {
    run loop@{
        listOf(1, 2, 3, 4, 5).forEach {
            if (it == 3) return@loop // non-local return from the lambda passed to run
            print(it)
        }
    }
    print(" done with nested loop")
}

可以通过以下方式实现continue:

//Will produce: "1245 done with implicit label"
fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach // local return to the caller of the lambda, i.e. the forEach loop
        print(it)
    }
    print(" done with implicit label")
}

正如在座各位所推荐的……阅读文档:P https://kotlinlang.org/docs/reference/returns.html#return-at-labels

编辑: 虽然主要问题是关于forEach的，但重要的是要考虑好的旧“for”。使用Kotlin并不意味着我们需要一直使用forEach。使用古老的“for”是完全可以的，有时甚至比forEach更有表现力和简洁:

fun foo() {
    for(x in listOf(1, 2, 3, 4, 5){
        if (x == 3) break //or continue
        print(x)
    }
    print("done with the good old for")
}