For loop 为什么在Kotlin中删除了索引for循环？

我仍然认为使用for循环的“传统”方法非常强大，可以完全控制索引。为什么它在科特林被移除

使用以下java代码在kotlin中应该做什么

for (int i = 0; i < n - 1; i++) {
   for (int j = i + 1; j < n; j++) {
   ....

for（int i=0；i

答案是：因为他们决定删除它。 您仍然可以使用以下语法：

for (a in 1..10) print("$a ")              // >>> 1 2 3 4 5 6 7 8 9 10

for (a in 10 downTo 1 step 2) print("$a ") // >>> 10 8 6 4 2 

---

有关详细信息：&

无需对Kotlin中的循环使用传统的，因为您可以使用Kotlin lambdas使代码更具表达力和可读性。例如：

arrayOf(1, 2, 3).forEachIndexed { index, item -> /**TODO**/}

repeat(5){index-> /**TODO**/}

Kotlin仅支持循环， 循环接受任何

Iterable

s/

Array

s/类型有一个

迭代器

运算符

如果您想返回使用循环表达式，您可以按照以下方式编写代码，您可以看到循环将比lamda占用更多的代码，这就是为什么在中引入了流api和函数接口：

如果您需要回到传统的循环，您可以使用重复，例如：

arrayOf(1, 2, 3).forEachIndexed { index, item -> /**TODO**/}

repeat(5){index-> /**TODO**/}

---

我认为他们之所以这样做（“不删除”）是因为他们想让Kotlin更有表现力

例如，在java中，我们可以创建如下的For循环：

for(int x = 1; x <= 10; x++) {
   System.out.print(x);
}

---

您可以创建自己的函数来实现“完全控制索引的传统循环”。 或者非传统的。 例如，混合

forachinedexed（）

，

with（）

，

count（）

，索引为1进行计数

inline fun <T> Iterable<T>.forWithIndexed1(action: T.(index: Int) -> Unit): Int {
    var index = 0
    for (item in this) item.action(++index)
    return index
}

inlinefuniterable.forWithIndexed1（操作：T.（索引：Int）->单位：Int{
var指数=0
对于（此项中的项）item.action（++索引）
回报指数
}

它没有被“删除”。新语言的设计不是从任何现有语言的功能集开始的；我们从一种没有任何功能的语言开始，并开始添加一些功能，这些功能是以一种优美的、惯用的方式表达某些行为所必需的。到目前为止，我们还不知道任何行为中C风格的“for”循环是最好的，也是最有效的用一种独特的方式来表达它。

为什么？ “传统”循环是导致“索引越界”异常的原因

---

集合项上的循环。

它没有被删除。只是语法不同而已。 Java代码的等价物：

for (int i = 0; i < n - 1; i++) {
   for (int j = i + 1; j < n; j++) {

---

为了代码的简洁性，Kotlin使用定义循环的迭代器。

另一种保留这些索引的有用方法是使用该方法来迭代某些内容（即an）。例如：

arrayOf(1, 2, 3).forEachIndexed { index, item -> /**TODO**/}

repeat(5){index-> /**TODO**/}

myIterable.withIndex（）中（（i，元素）的

{
//对你的元素和现在已知的索引做点什么，我
}

我注意到，这与回答中的建议相同，但我认为，如果我们使用Iterables为此类情况提供的内置方法，而不是再次实现它们，则会更好。这也可以说与lambda类似：

myIterable.forachined{i，元素->
//在这里也做点什么
}

这没有任何意义，因为有时您希望有更多带有自定义步骤的自定义循环，而这种结构会从逻辑中删除这些步骤

var数组=[“-m”、“/test/app”、“-w”、“us”]；
对于（变量i=0；i}

Kotlin正在尝试强制执行fluent迭代，这涵盖了绝大多数循环构造。然而，我需要一个传统的for循环（如java），具有立即终止的状态范围、在循环体执行之前计算的退出条件和执行后操作（我的用例很复杂：我需要重复使用基于压缩例程和2次幂的动态退出条件）。我提出了以下一般功能：

fun <S> forloop(state: S, condition: (s: S) -> Boolean, postExecution: (s: S) -> Unit, block: (s: S) -> Unit) {
  while (condition(state)) {
    block(state)
    postExecution(state)
  }
}

data class SingleIndex(var i: Int)
fun forloop(i: Int, condition: (s: SingleIndex) -> Boolean, postExecution: (s: SingleIndex) -> Unit, block: (s: SingleIndex) -> Unit) {
  forloop(SingleIndex(i), condition, postExecution, block)
}

funforloop（状态：S，条件：（S:S）->布尔，执行后：（S:S）->单元，块：（S:S）->单元）{
while（条件（状态））{
块（状态）
执行后（状态）
}
}
数据类SingleIndex（变量i:Int）
fun-forloop（i:Int，条件：（s:SingleIndex）->布尔，后执行：（s:SingleIndex）->单元，块：（s:SingleIndex）->单元）{
forloop（单索引（i）、条件、执行后、块）
}

示例：

fun main（）{
forloop（0，{it.i<10}，{++it.i}）{
println（“forloop测试：i=${it.i}”）
}
数据类状态（变量i:Int，变量j:Int）
forloop（状态（0，1），{it.i<10}，{++it.i；it.j+=it.i}）{
println（“forloop测试：i=${it.i}，j=${it.j}”）
}
}

---

不过，根据语言原理，您只能在极少数情况下使用此选项。

对于这种情况，可以使用以下双循环：

for (i in 0 until n) {
        for (j in (i + 1) .. n) {

for（i in-generateSequence（0）{it+2}.takeWhile{it

生成序列（0）{it+2}.takeWhile{it

如果要同时获取索引和值，可以使用此选项

for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}

这很简单

---

来源：

可能是因为它们提供了几种替代方法，不需要您读取正在迭代的集合的索引。如果您需要循环到任意数字，您可以始终在for循环中使用一个范围，或者只使用while循环。

（0..collection.size-1）有什么问题.forEach

？它为您增加索引，您可以使用

集合[It]=blah

对元素进行变异。或者您可以使用：

for（i in 0..（n-1））

我喜欢传统循环的一点是，我可以在任意布尔条件下结束循环。我不知道如何在Kotlin中不使用while循环来结束循环。我理解这一点，但有没有任何文档可以解释第二个循环语法？我以前尝试过学习Kotlin，但我厌倦了，因为文档没有看起来很好。嗨，老师

generateSequence(0) { it + 2 }.takeWhile { it < array.length }.forEach {
    // Do something useful
}

for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}