scala 中的集合操作

集合操作

zipWithIndex

zipWithIndex为集合中的元素添加了索引号。

    val arg = List(2,4)
    val t = arg.zipWithIndex
    for( i <- arg){
        println(i)
    }
    for (i <- t) {
        println(i)
    }

2
4
(2,0)
(4,1)

map

map对集合中的每个元素使用匿名函数处理，并将返回值组会成一个新的集合

    val set = Set(1,2,3)
    val set2 = set.map(b => b * 2)
    val output = set.mkString(", ")
    println(output)
    val output2 = set2.mkString(", ")
    println(output2)

1, 2, 3
2, 4, 6

foldLeft foldRight

对集合中的元素分别从左到右（右到左）折叠计算

    val a = List(1,2,4,8)
    val b = List("h1","h2","h3","h4")
    val c = a.foldRight(0)((m,n) => (m + n))
    val d = b.foldRight("init:")((m,n) => (m + n))
    val c1 = a.foldLeft(0)((m, n) => (m + n))
    val d1 = b.foldLeft("init:")((m, n) => (m + n))
    println(a.mkString(", "))
    println(b.mkString(", "))
    println(c)
    println(d)
    println(c1)
    println(d1)

1, 2, 4, 8
h1, h2, h3, h4
15
h1h2h3h4init:
15
init:h1h2h3h4

zip unzip

将一个可迭代的集合与另一个可迭代的集合组合成一对一对应的元素，并返回一个新的可迭代的集合。如果两个集合中其中一个比另一个长，那么多出来的元素会被忽略。
参数：
that - 提供结果中第二部分的可迭代集合
类型参数：
B - 返回的一对中的第二部分的类型
返回：
包含由该可迭代集合和that的对应元素组成的一对的新的可迭代集合。返回的集合的长度是该可迭代集合和that长度的最小值。

unzip于zip相反

  def apply[T <: Data](sel: Seq[Bool], in: Seq[T]): T =
    apply(sel.zip(in))

    val a = List(1,2,4,8)
    val b = List("h1","h2","h3","h4")
    val d = a.zip(b)
    println(a.mkString(", "))
    println(b.mkString(", "))
    println(d.mkString(", "))

1, 2, 4, 8
h1, h2, h3, h4
(1,h1), (2,h2), (4,h3), (8,h4)

yield

for ((s, i) <- inputs) yield Mux(s, i.asUInt, 0.U)

yield 是用于在 Scala 中生成集合的关键字。在 for 循环中，yield 可以将循环中每个元素转换为集合中的一个元素，并返回一个新的、包含这些元素的集合。

    val res = for(i <- 0 to 10) yield i * 2
    println(res.mkString(", "))

0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20

forall

  def forall(p: A => Boolean): Boolean = {
    var res = true
    val it = iterator
    while (res && it.hasNext) res = p(it.next())
    res
  }

判断集合中的所有元素是否都满足一个条件

    val res = for(i <- 0 to 10) yield i * 2
    println(res.mkString(", "))
    println(res.forall(p => (p % 2 == 0)))
    println(res.forall(p => (p % 2 == 1)))
    val updatedSeq = res :+ 11
    println(updatedSeq.forall(p => (p % 2 == 2)))

0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20
true
false
false

reduceLeft reduceRight

对一个集合分别从左到右应用二元运算符。

foreach

对每个元素都应用f，于map的区别是，不返回新的集合。
def foreach[U](f: A => U): Unit = {
val it = iterator
while(it.hasNext) f(it.next())
}