Scala Trait 可遍历

介绍

在Scala中，Trait是一种特殊的抽象类，可以被多个类继承或混入。Scala提供了许多内置的Trait供我们使用，其中就包括可遍历的Trait。可遍历的Trait主要是用来处理集合类数据的，提供了许多遍历集合的方法，包括foreach、map、filter等。使用可遍历的Trait可以让我们更方便地处理集合类数据。

Scala中的可遍历Trait

Scala中提供了两个可遍历Trait，分别为Iterable和Iterator。

Iterable

Iterable是一个可迭代的Trait，它提供了许多遍历集合的方法。Iterable的源代码如下：

trait Iterable[+A] extends AnyRef {
  def iterator: Iterator[A]
  def foreach[U](f: A => U): Unit
  def map[B](f: A => B): Iterable[B]
  def flatMap[B](f: A => Iterable[B]): Iterable[B]
  def filter(p: A => Boolean): Iterable[A]
  def withFilter(p: A => Boolean): Iterable[A]
  def partition(p: A => Boolean): (Iterable[A], Iterable[A])
  def groupBy[K](f: A => K): immutable.Map[K, Iterable[A]]
  ...
}

Iterable的方法非常丰富，下面我们简单介绍几个常用的方法：

• foreach: 对集合中的每个元素执行指定操作。

val xs = List(1, 2, 3, 4, 5)
xs.foreach(x => println(x)) // 输出 1 2 3 4 5

• map: 对集合中的每个元素进行指定操作，并返回操作结果集合。

val xs = List(1, 2, 3, 4, 5)
val ys = xs.map(x => x * 2) // ys: List(2, 4, 6, 8, 10)

• filter: 对集合中的每个元素进行指定条件的筛选。

val xs = List(1, 2, 3, 4, 5)
val ys = xs.filter(x => x % 2 == 0) // ys: List(2, 4)

• foldLeft: 迭代集合中的元素，执行指定操作，并返回最终结果。

val xs = List(1, 2, 3, 4, 5)
val sum = xs.foldLeft(0)((x, y) => x + y) // sum: Int = 15

Iterator

Iterator是一个迭代器Trait，它提供了许多遍历集合的方法。Iterator的源代码如下：

trait Iterator[+A] extends AnyRef {
  def hasNext: Boolean
  def next(): A
  def foldLeft[B](z: B)(op: (B, A) => B): B
  def foreach[U](f: A => U): Unit
  def map[B](f: A => B): Iterator[B]
  def flatMap[B](f: A => Iterator[B]): Iterator[B]
  def filter(p: A => Boolean): Iterator[A]
  ...
}

与Iterable相比，Iterator的方法相对较少，但也包括了常用的遍历方法。下面我们简单介绍几个常用的方法：

• hasNext: 判断是否还有下一个元素。

val iterator = List(1, 2, 3, 4, 5).iterator
while (iterator.hasNext) {
  println(iterator.next()) // 输出 1 2 3 4 5
}

• next: 返回下一个元素。

val iterator = List(1, 2, 3, 4, 5).iterator
val xs = ListBuffer[Int]()
while (iterator.hasNext) {
  xs += iterator.next()
}
println(xs) // 输出 List(1, 2, 3, 4, 5)

• foldLeft: 迭代集合中的元素，执行指定操作，并返回最终结果。

val iterator = List(1, 2, 3, 4, 5).iterator
val sum = iterator.foldLeft(0)((x, y) => x + y) // sum: Int = 15

示例

// 使用Iterable进行遍历
val xs1 = List(1, 2, 3, 4, 5)
xs1.foreach(x => println(x)) // 输出 1 2 3 4 5

val xs2 = List(1, 2, 3, 4, 5)
val ys2 = xs2.map(x => x * 2) // ys2: List[Int] = List(2, 4, 6, 8, 10)

val xs3 = List(1, 2, 3, 4, 5)
val ys3 = xs3.filter(x => x % 2 == 0) // ys3: List[Int] = List(2, 4)

val xs4 = List(1, 2, 3, 4, 5)
val sum4 = xs4.foldLeft(0)((x, y) => x + y) // sum4: Int = 15

// 使用Iterator进行遍历
val iterator1 = List(1, 2, 3, 4, 5).iterator
while (iterator1.hasNext) {
  println(iterator1.next()) // 输出 1 2 3 4 5
}

val iterator2 = List(1, 2, 3, 4, 5).iterator
val xs2 = ListBuffer[Int]()
while (iterator2.hasNext) {
  xs2 += iterator2.next()
}
println(xs2) // 输出 List(1, 2, 3, 4, 5)

val iterator3 = List(1, 2, 3, 4, 5).iterator
val sum3 = iterator3.foldLeft(0)((x, y) => x + y) // sum3: Int = 15

总结

使用Scala的可遍历Trait可以让我们更方便地处理集合类数据。在使用时，我们可以根据需求选择使用Iterable或Iterator，它们都提供了常用的遍历集合的方法。需要注意的是，Scala中的可遍历Trait和Java中的迭代器和Iterable有一些区别，所以在使用时需要注意。