由于Scala没有旧的Java风格的带索引的for循环，
// does not work
val xs = Array("first", "second", "third")
for (i=0; i<xs.length; i++) {
println("String #" + i + " is " + xs(i))
}
我们如何高效地迭代，而且不使用var？
你可以这样做
val xs = Array("first", "second", "third")
val indexed = xs zipWithIndex
for (x <- indexed) println("String #" + x._2 + " is " + x._1)
但是这个列表被遍历了两次——并不是很高效。
遍历两次比这个糟糕得多，它会创建一个中间的键值对数组。
你可以使用 view。当你执行 collection.view时，你可以将后续的调用看作是在迭代期间进行的惰性操作。如果你想要获得一个完全实现的集合，你可以在最后调用 force。但在这里，这样做是无用且昂贵的。所以请修改你的代码为：
for((x,i) <- xs.view.zipWithIndex) println("String #" + i + " is " + x)
List，Scala中最常用的集合）上表现非常糟糕 - 不仅仅是在链表上。请查看这里的apply操作。在类似于链表的集合中，每次通过索引访问元素都会导致对列表的遍历。 - Nikita Volkov有人提到Scala确实有for循环的语法：
for (i <- 0 until xs.length) ...
或者简单地说
for (i <- xs.indices) ...
然而，你也提到了效率。实际上，Scala的for语法是高阶方法（如map、foreach等）的语法糖。因此，在某些情况下，这些循环可能效率低下，例如：如何优化Scala中的for-comprehensions和loops？
好消息是，Scala团队正在努力改进这一点。以下是bug跟踪器中的问题链接：https://issues.scala-lang.org/browse/SI-4633）
为了达到最高效率，可以使用while循环或者，如果你坚持要删除对var的使用，可以使用尾递归：
import scala.annotation.tailrec
@tailrec def printArray(i: Int, xs: Array[String]) {
if (i < xs.length) {
println("String #" + i + " is " + xs(i))
printArray(i+1, xs)
}
}
printArray(0, Array("first", "second", "third"))
请注意，可选的 @tailrec 注解对于确保方法实际上是尾递归很有用。Scala编译器将尾递归调用转换为while循环的字节码等价形式。
xs是任何类型的链表（例如广泛使用的List），像xs(i)这样通过索引访问它的元素将是线性的，因此for (i <- xs.indices) println(i + " : " + xs(i)) 的性能甚至比for((x, i) <- xs.zipWithIndex) println(i + " : " + x)还要差，因为它会在底层导致多次遍历。因此，建议使用视图的答案@didierd应该被接受为最通用和最符合惯用法的答案，在我看来。 - Nikita Volkov还有一种方式：
scala> val xs = Array("first", "second", "third")
xs: Array[java.lang.String] = Array(first, second, third)
scala> for (i <- xs.indices)
| println(i + ": " + xs(i))
0: first
1: second
2: third
实际上，Scala拥有带索引的旧式Java循环：
scala> val xs = Array("first","second","third")
xs: Array[java.lang.String] = Array(first, second, third)
scala> for (i <- 0 until xs.length)
| println("String # " + i + " is "+ xs(i))
String # 0 is first
String # 1 is second
String # 2 is third
0 until xs.length或0.until(xs.length)是一个返回Range适用于循环的RichInt方法。
此外，您还可以尝试使用to进行循环：
scala> for (i <- 0 to xs.length-1)
| println("String # " + i + " is "+ xs(i))
String # 0 is first
String # 1 is second
String # 2 is third
xs(i)会使复杂度变为O(n^2)。 - Vadzimval a = Array("One", "Two", "Three")
a.foldLeft(0) ((i, x) => {println(i + ": " + x); i + 1;} )
输出：
0: One
1: Two
2: Three
val myArray = new Array[String](3)
myArray(0)="0";
myArray(1)="1";
myArray(2)="2";
循环的类型：
for(data <- myArray)println(data)
for (i <- 0 until myArray.size)
println(i + ": " + myArray(i))
object HelloV2 {
def main(args: Array[String]) {
//Efficient iteration with index in Scala
//Approach #1
var msg = "";
for (i <- args.indices)
{
msg+=(args(i));
}
var msg1="";
//Approach #2
for (i <- 0 until args.length)
{
msg1 += (args(i));
}
//Approach #3
var msg3=""
args.foreach{
arg =>
msg3 += (arg)
}
println("msg= " + msg);
println("msg1= " + msg1);
println("msg3= " + msg3);
}
}
在集合上调用 zipWithIndex 方法会遍历集合并创建一个新的包含索引对的集合。为了避免这种情况，可以直接在集合的迭代器上调用 zipWithIndex 方法。这将返回一个新的迭代器，它会在迭代时跟踪索引，而不会创建额外的集合或进行额外的遍历。
下面是 2.10.3 版本中 scala.collection.Iterator.zipWithIndex 的实现方式：
def zipWithIndex: Iterator[(A, Int)] = new AbstractIterator[(A, Int)] {
var idx = 0
def hasNext = self.hasNext
def next = {
val ret = (self.next, idx)
idx += 1
ret
}
}
标准库中没有现成的方法可以帮你避免创建元组垃圾，但自己实现并不难。可惜我从未花时间去弄清楚如何进行适当的CanBuildFrom隐式操作，以便使这种方法对应用于的集合类型具有通用性。不过如果可能的话，我相信会有人让我们茅塞顿开。
def foreachWithIndex[A](as: Traversable[A])(f: (Int,A) => Unit) {
var i = 0
for (a <- as) {
f(i, a)
i += 1
}
}
def mapWithIndex[A,B](in: List[A])(f: (Int,A) => B): List[B] = {
def mapWithIndex0(in: List[A], gotSoFar: List[B], i: Int): List[B] = {
in match {
case Nil => gotSoFar.reverse
case one :: more => mapWithIndex0(more, f(i, one) :: gotSoFar, i+1)
}
}
mapWithIndex0(in, Nil, 0)
}
// Tests....
@Test
def testForeachWithIndex() {
var out = List[Int]()
ScalaUtils.foreachWithIndex(List(1,2,3,4)) { (i, num) =>
out :+= i * num
}
assertEquals(List(0,2,6,12),out)
}
@Test
def testMapWithIndex() {
val out = ScalaUtils.mapWithIndex(List(4,3,2,1)) { (i, num) =>
i * num
}
assertEquals(List(0,3,4,3),out)
}
更多的迭代方式：
scala> xs.foreach (println)
first
second
third
foreach等类似函数，以及map函数会返回某些东西（函数的结果，对于println函数来说是Unit类型，因此返回一个Unit列表）。
scala> val lens = for (x <- xs) yield (x.length)
lens: Array[Int] = Array(5, 6, 5)
scala> ("" /: xs) (_ + _)
res21: java.lang.String = firstsecondthird
折叠
for(int i=0, j=0; i+j<100; i+=j*2, j+=i+2) {...}can be done with recursion:
def ijIter (i: Int = 0, j: Int = 0, carry: Int = 0) : Int =
if (i + j >= 100) carry else
ijIter (i+2*j, j+i+2, carry / 3 + 2 * i - 4 * j + 10)
carry-part只是一些示例，用于处理i和j。它不必是Int。
对于更简单的东西，更接近于通常的for循环：
scala> (1 until 4)
res43: scala.collection.immutable.Range with scala.collection.immutable.Range.ByOne = Range(1, 2, 3)
scala> (0 to 8 by 2)
res44: scala.collection.immutable.Range = Range(0, 2, 4, 6, 8)
scala> (26 to 13 by -3)
res45: scala.collection.immutable.Range = Range(26, 23, 20, 17, 14)
或者无序的：
List (1, 3, 2, 5, 9, 7).foreach (print)
while循环。据我回忆，几年前曾经有一个争论，是否应该让Scala继承Java的for(;;)循环，而当时决定不采用这种方式是因为其增加的复杂性没有带来足够的好处。 - Kipton Barros