scala - 在 Scala 中初始化二维（多维）数组

Question

在 Java 中很容易初始化一个二维数组（或者，事实上，任何多维数组），通过这样的方式：

int[][] x = new int[][] {
        { 3, 5, 7, },
        { 0, 4, 9, },
        { 1, 8, 6, },
};

它易于阅读，类似于 2D 矩阵等。

但是我如何在 Scala 中做到这一点？

我能想到的最好的外观，好吧，简洁得多：

val x = Array(
    Array(3, 5, 7),
    Array(0, 4, 9),
    Array(1, 8, 6)
)

我在这里看到的问题：

• 它一遍又一遍地重复“数组”（就像除了 之外可能还有其他东西Array）
• 它需要,在每个 Array 调用中省略尾随

• 如果我搞砸了并Array()在数组中间插入了一些东西，编译器就可以了，但是 type ofx会默默地Array[Any]变成Array[Array[Int]]：

  val x = Array(
      Array(3, 5, 7),
      Array(0, 4), 9, // <= OK with compiler, silently ruins x
      Array(1, 8, 6)
  )
  

  有一个防范措施，直接指定类型，但它看起来比在 Java 中更加矫枉过正：

  val x: Array[Array[Int]] = Array(
      Array(3, 5, 7),
      Array(0, 4), 9, // <= this one would trigger a compiler error
      Array(1, 8, 6)
  )
  

  最后一个例子需要Array的甚至比我int[][]在 Java 中所说的还要多 3 倍。

有什么明确的方法可以解决这个问题吗？

Answer 1

为了清楚起见，我个人会把它吸起来并输入（或剪切和粘贴）“数组”几次。当然，为了安全起见，请包含类型注释。但是如果你真的用完了电子墨水，一个快速简单的破解方法就是简单地为 提供一个别名Array，例如：

val > = Array

val x: Array[Array[Int]] = >(
  >(3, 5, 7),
  >(0, 4, 9),
  >(1, 8, 6)
)

Array如果要缩短注释，还可以提供类型别名：

type >[T] = Array[T]

val x: >[>[Int]] = ...

Answer 2

我建议使用 Scala 2.10 和宏：

object MatrixMacro {

  import language.experimental.macros

  import scala.reflect.macros.Context
  import scala.util.Try

  implicit class MatrixContext(sc: StringContext) {
    def matrix(): Array[Array[Int]] = macro matrixImpl
  }

  def matrixImpl(c: Context)(): c.Expr[Array[Array[Int]]] = {
    import c.universe.{ Try => _, _ }

    val matrix = Try {
      c.prefix.tree match {
        case Apply(_, List(Apply(_, List(Literal(Constant(raw: String)))))) =>

          def toArrayAST(c: List[TermTree]) =
            Apply(Select(Select(Ident("scala"), newTermName("Array")), newTermName("apply")), c)

          val matrix = raw split "\n" map (_.trim) filter (_.nonEmpty) map {
            _ split "," map (_.trim.toInt)
          }
          if (matrix.map(_.length).distinct.size != 1)
            c.abort(c.enclosingPosition, "rows of matrix do not have the same length")

          val matrixAST = matrix map (_ map (i => Literal(Constant(i)))) map (i => toArrayAST(i.toList))

          toArrayAST(matrixAST.toList)
      }
    }

    c.Expr(matrix getOrElse c.abort(c.enclosingPosition, "not a matrix of Int"))
  }

}

用法与：

scala> import MatrixMacro._
import MatrixMacro._

scala> matrix"1"
res86: Array[Array[Int]] = Array(Array(1))

scala> matrix"1,2,3"
res87: Array[Array[Int]] = Array(Array(1, 2, 3))

scala> matrix"""
     |   1, 2, 3
     |   4, 5, 6
     |   7, 8, 9
     | """
res88: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9))

scala> matrix"""
     |   1, 2
     |   1
     | """
<console>:57: error: rows of matrix do not have the same length
matrix"""
^

scala> matrix"a"
<console>:57: error: not a matrix of Int
              matrix"a"
              ^

我不认为你会缩短它。;)

Answer 3

如果仅使用Listof List（它本身不能保证每个子列表的大小相同）对您来说不是问题，并且您只关心简单的语法并在创建时避免错误，那么 scala 有很多创建方法不错的语法结构。

一种这样的可能性是一个简单的助手：

object Matrix {
  def apply[X]( elements: Tuple3[X, X, X]* ): List[List[X]] = {
    elements.toList.map(_.productIterator.toList.asInstanceOf[List[X]] )
  }
  // Here you might add other overloads for Tuple4, Tuple5 etc if you need "matrixes" of those sizes
}

val x = Matrix(
  (3, 5, 7),
  (0, 4, 9),
  (1, 8, 6)
)

关于您的顾虑：

它一遍又一遍地重复“列表”（就像除了列表之外可能还有其他东西）

不是这里的情况。

它需要在每个 List 调用中省略 trailing

不幸的是，这里仍然如此，鉴于 scala 的句法规则，您无能为力。

如果我搞砸并在数组中间插入除 List() 之外的其他内容，编译器会正常运行，但 x 的类型会默默地变为 List[Any] 而不是 List[List[Int]]：

val x = List(
  List(3, 5, 7),
  List(0, 4), 9, // <= OK with compiler, silently ruins x
  List(1, 8, 6)
)

等效代码现在无法编译：

scala> val x = Matrix(
     |   (3, 5, 7),
     |   (0, 4), 9,
     |   (1, 8, 6)
     | )
<console>:10: error: type mismatch;
 found   : (Int, Int)
 required: (?, ?, ?)
         (0, 4), 9,

最后，如果你想明确指定元素的类型（比如你想防止无意中混合Ints 和Doubles 的可能性），你只需要指定Matrix[Int]而不是丑陋的List[List[Int]]：

val x = Matrix[Int](
  (3, 5, 7),
  (0, 4, 9),
  (1, 8, 6)
)

编辑：我看到你在你的问题中替换List为。Array要使用数组，您只需在上面的代码中替换List为Array和。toListtoArray

Answer 4

由于我也对这个尾随逗号问题感到厌恶（即，我不能简单地将最后一行与任何其他行交换）我有时使用流畅的 API 或构造函数语法技巧来获得我喜欢的语法。使用构造函数语法的示例是：

trait Matrix {
  // ... and the beast
  private val buffer = ArrayBuffer[Array[Int]]()
  def >(vals: Int*) = buffer += vals.toArray
  def build: Array[Array[Int]] = buffer.toArray
}

这使得：

// beauty ... 
val m = new Matrix {
  >(1, 2, 3)
  >(4, 5, 6)
  >(7, 8, 9)
} build

不幸的是，这依赖于可变数据，尽管它只是在构建过程中临时使用。在我想要构造语法的最大美感的情况下，我更喜欢这个解决方案。

如果build太长/冗长，您可能希望用空的应用函数替换它。

Answer 5

我不知道这是否是简单的方法，但我在下面包含了一些代码，用于将嵌套元组转换为“2D”数组。

首先，您需要一些样板来获取元组的大小以及将元组转换为[Array[Array[Double]]. 我使用的一系列步骤是：

1. 找出元组中的行数和列数
2. 将嵌套元组变成单行数组
3. 根据原始元组的大小重塑数组。

代码是：

object Matrix {

    /**
     * Returns the size of a series of nested tuples. 
     */
    def productSize(t: Product): (Int, Int) = {
        val a = t.productArity
        val one = t.productElement(0)
        if (one.isInstanceOf[Product]) {
            val b = one.asInstanceOf[Product].productArity
            (a,  b)
        }
        else {
            (1, a)
        }
    }

    /**
     * Flattens out a nested tuple and returns the contents as an iterator. 
     */
    def flattenProduct(t: Product): Iterator[Any] = t.productIterator.flatMap {
        case p: Product => flattenProduct(p)
        case x => Iterator(x)
    }

    /**
     * Convert a nested tuple to a flattened row-oriented array.
     * Usage is:
     * {{{
     *  val t = ((1, 2, 3), (4, 5, 6))
     *  val a = Matrix.toArray(t)
     *  // a: Array[Double] = Array(1, 2, 3, 4, 5, 6)
     * }}}
     *
     * @param t The tuple to convert to an array
     */
    def toArray(t: Product): Array[Double] = flattenProduct(t).map(v =>
        v match {
            case c: Char => c.toDouble
            case b: Byte => b.toDouble
            case sh: Short => sh.toDouble
            case i: Int => i.toDouble
            case l: Long => l.toDouble
            case f: Float => f.toDouble
            case d: Double => d
            case s: String => s.toDouble
            case _ => Double.NaN
        }

    ).toArray[Double]

    def rowArrayTo2DArray[@specialized(Int, Long, Float, Double) A: Numeric](m: Int, n: Int,
            rowArray: Array[A]) = {
        require(rowArray.size == m * n)
        val numeric = implicitly[Numeric[A]]
        val newArray = Array.ofDim[Double](m, n)
        for (i <- 0 until m; j <- 0 until n) {
            val idx = i * n + j
            newArray(i)(j) = numeric.toDouble(rowArray(idx))
        }
        newArray
    }

    /**
     * Factory method for turning tuples into 2D arrays
     */
    def apply(data: Product): Array[Array[Double]] = {
        def size = productSize(data)
        def array = toArray(data)
        rowArrayTo2DArray(size._1, size._2, array)
    }

}

现在要使用它，您可以执行以下操作：

val a  = Matrix((1, 2, 3))
// a: Array[Array[Double]] = Array(Array(1.0, 2.0, 3.0))

val b = Matrix(((1, 2, 3), (4, 5, 6), (7, 8, 9)))
// b: Array[Array[Double]] = Array(Array(1.0, 2.0, 3.0), 
//                                 Array(4.0, 5.0, 6.0), 
//                                 Array(7.0, 8.0, 9.0))

val c = Matrix((1L, 2F, "3"))    // Correctly handles mixed types
// c: Array[Array[Double]] = Array(Array(1.0, 2.0, 3.0))

val d = Matrix((1L, 2F, new java.util.Date())) // Non-numeric types convert to NaN
// d: Array[Array[Double]] = Array(Array(1.0, 2.0, NaN))

或者，如果您可以直接使用所需数组的大小和一维值数组调用 rowArrayTo2DArray：

val e = Matrix.rowArrayTo2DArray(1, 3, Array(1, 2, 3))
// e: Array[Array[Double]] = Array(Array(1.0, 2.0, 3.0))

val f = Matrix.rowArrayTo2DArray(3, 1, Array(1, 2, 3))
// f: Array[Array[Double]] = Array(Array(1.0), Array(2.0), Array(3.0))

val g = Matrix.rowArrayTo2DArray(3, 3, Array(1, 2, 3, 4, 5, 6, 7, 8, 9))
// g: Array[Array[Double]] = Array(Array(1.0, 2.0, 3.0), 
//                                 Array(4.0, 5.0, 6.0), 
//                                 Array(7.0, 8.0, 9.0))

Answer 6

浏览答案，我没有找到对我来说似乎最明显和最简单的方法。而不是Array，您可以使用元组。
看起来像这样：

scala> val x = {(
     | (3,5,7),
     | (0,4,9),
     | (1,8,6)
     | )}

x: ((Int, Int, Int), (Int, Int, Int), (Int, Int, Int)) = ((3,5,7),(0,4,9),(1,8,6))

看起来干净优雅？
我认同 ：）