如何在scala中获取变换数组的索引

我想转换一个数组。这可以通过以下方式实现：

var cal = Array.ofDim[Double](300, 10000);   
cal.foreach(x => x.transform(y => some_value))

问题是如何访问转换单元的索引。例如：

cal.foreach(x => x.transform(y => x(y.index - 1) + 7))

import scala.collection.mutable._

object Extensions {
  implicit class ExtMutSeq[T](val seq: Seq[T]) extends AnyVal {
    def transform_indexed(f: (T, Int) => T) {
      for (i <- 0 until seq.length) {
        seq(i) = f(seq(i), i)
      }
    }
  }
}

object Program extends App {
  import Extensions._
  val a = ArraySeq(1,2,3,4)
  a.transform_indexed((item, pos) => if (pos % 2 == 0) 0 else item)
  println(a)
}

我尝试使用zipWithIndex：

cal.foreach(x => x.zipWithIndex.transform(y => (x(y._2) + 7, y._2)));

但这并没有改变“cal”值

---

谢谢。

后一个选项不起作用，因为您正在调用

x.zipWithIndex

，它返回一个新的元组集合，然后转换该集合。这不会对基础数组产生任何影响

我想不出任何东西可以让你在仍然可以访问索引的情况下修改数组。但是，如果您可以采用更实用的方式返回新集合，则可以执行以下操作：

val cal = Array.ofDim[Double](300, 10000) map { x =>
    x.zipWithIndex map (y => x(y._2) + 7)
};

---

事实上，因为在您的示例中，

cal

是可变的，所以您可以通过重新分配来做同样的事情。如果可以避免的话，我不会鼓励可变变量。

后一个选项不起作用，因为您正在调用

x.zipWithIndex

，它返回一个新的元组集合，然后转换该集合。这不会对基础数组产生任何影响

我想不出任何东西可以让你在仍然可以访问索引的情况下修改数组。但是，如果您可以采用更实用的方式返回新集合，则可以执行以下操作：

val cal = Array.ofDim[Double](300, 10000) map { x =>
    x.zipWithIndex map (y => x(y._2) + 7)
};

---

事实上，因为在您的示例中，

cal

是可变的，所以您可以通过重新分配来做同样的事情。并不是说如果可以避免的话，我会鼓励可变变量。

要就地进行更新，您可以用类似java的方式进行：

for( y <- 0 until cal.length; 
     row <- cal( y );
     x <- 0 until row.length ) 
{
  row( x ) = some value // here you can get the indexes through (x, y)
}

// or

for( (row, y) <- cal.zipWithIndex; 
     x <- 0 until row.length ) 
{
  row( x ) = some value // here you can get the indexes through (x, y)
}

---

对于（y要就地执行更新，可以使用java-ish的方式执行，如下所示：

for( y <- 0 until cal.length; 
     row <- cal( y );
     x <- 0 until row.length ) 
{
  row( x ) = some value // here you can get the indexes through (x, y)
}

// or

for( (row, y) <- cal.zipWithIndex; 
     x <- 0 until row.length ) 
{
  row( x ) = some value // here you can get the indexes through (x, y)
}

for（y如果在标准库中找不到函数，最简单的解决方案是编写自己的函数，特别是如果它是一个简单的函数。Scala中函数作为参数并没有什么神奇之处可以阻止您自己这么做

隐式类甚至允许您模拟正常的调用约定。例如：

cal.foreach(x => x.transform(y => x(y.index - 1) + 7))

import scala.collection.mutable._

object Extensions {
  implicit class ExtMutSeq[T](val seq: Seq[T]) extends AnyVal {
    def transform_indexed(f: (T, Int) => T) {
      for (i <- 0 until seq.length) {
        seq(i) = f(seq(i), i)
      }
    }
  }
}

object Program extends App {
  import Extensions._
  val a = ArraySeq(1,2,3,4)
  a.transform_indexed((item, pos) => if (pos % 2 == 0) 0 else item)
  println(a)
}

导入scala.collection.mutable_
对象扩展{
隐式类ExtMutSeq[T]（val-seq:seq[T]）扩展了AnyVal{
def transform_索引（f:（T，Int）=>T）{
对于（i如果（位置%2==0）0其他项目）
println（a）
}

（根据行的实际类型，您可能需要调整上面的
seq
类型。）

您可以获得抽象和重用的双重好处。抽象是因为它允许您在一个地方用索引封装转换的概念，重用是因为您只需编写一次。而且因为它的代码很短，所以实际上不必依赖标准库。如果您不能，这是最简单的解决方案在标准库中找到一个函数就是编写自己的函数，特别是如果它是一个简单的函数的话。在Scala中，函数作为参数并没有什么神奇的地方可以阻止你自己这样做

隐式类甚至允许您模拟正常的调用约定。例如：

cal.foreach(x => x.transform(y => x(y.index - 1) + 7))

import scala.collection.mutable._

object Extensions {
  implicit class ExtMutSeq[T](val seq: Seq[T]) extends AnyVal {
    def transform_indexed(f: (T, Int) => T) {
      for (i <- 0 until seq.length) {
        seq(i) = f(seq(i), i)
      }
    }
  }
}

object Program extends App {
  import Extensions._
  val a = ArraySeq(1,2,3,4)
  a.transform_indexed((item, pos) => if (pos % 2 == 0) 0 else item)
  println(a)
}

导入scala.collection.mutable_
对象扩展{
隐式类ExtMutSeq[T]（val-seq:seq[T]）扩展了AnyVal{
def transform_索引（f:（T，Int）=>T）{
对于（i如果（位置%2==0）0其他项目）
println（a）
}

（根据行的实际类型，您可能需要调整上面的
seq
类型。）

您可以获得抽象和重用的双重好处。抽象是因为它允许您在一个地方用索引封装转换的概念，重用是因为您只需编写一次。而且因为它的代码很短，所以不需要依赖标准库