Control Flow & Ranges

Loops and iteration read more cleanly in Kotlin, largely because of one feature: ranges are first-class values. The C-style for (int i = 0; i < n; i++) loop - a fixture of Java since forever - is gone, replaced by iterating over a range or a collection directly. It's more readable, harder to get wrong (no off-by-one from a misplaced <=), and ranges turn out to be useful well beyond loops.

for iterates over things, not counters

Kotlin's for loop always iterates over something iterable - a range, a collection, an array. There's no three-part counter loop:

for (i in 1..5) println(i)              // 1 2 3 4 5 - iterate a range
for (name in names) println(name)        // iterate a collection directly
for (c in "hello") println(c)            // iterate a string's characters

To loop with an index over a collection, you use helpers rather than a manual counter:

for (i in names.indices) println(names[i])           // indices gives the valid index range
for ((i, name) in names.withIndex()) {               // both index and value, destructured
    println("$i: $name")
}

This eliminates the classic off-by-one bugs of for (int i = 0; i <= n; i++) (should it be < or <=?) - you name the range you mean, and the loop can't run past it.

Ranges are first-class

A range like 1..5 is a real object (IntRange), and Kotlin gives you a small vocabulary to build exactly the sequence you want:

1..5            // 1, 2, 3, 4, 5      (inclusive on both ends)
1..<5           // 1, 2, 3, 4         (exclusive end; older syntax: 1 until 5)
5 downTo 1      // 5, 4, 3, 2, 1      (descending)
1..10 step 2    // 1, 3, 5, 7, 9      (custom step)
'a'..'z'        // a range of characters

Because a range is a value, it's not just for loops - you use it in when (in 4..10, from the expressions lesson) and in membership checks:

if (age in 18..65) { ... }              // readable membership test
if (index !in list.indices) return      // "not in" - out of bounds check
val isDigit = c in '0'..'9'             // instead of c >= '0' && c <= '9'

The in operator (backed by ranges) turns clunky x >= lo && x <= hi comparisons into readable x in lo..hi - a small but constant improvement in intent-revealing code.

while and do-while (unchanged)

Not everything is different. while and do-while work exactly as in Java, for the cases where you genuinely need a condition-driven loop rather than iteration:

while (queue.isNotEmpty()) { process(queue.poll()) }

Kotlin keeps these as-is because they're already fine - the redesign is targeted at the error-prone C-style for, not iteration in general. (Kotlin also has break and continue, plus labels like outer@ for breaking out of nested loops, if you need them - rare, but available.)