Scala - Multidimensional Arrays

Quiz

There are many situations where you would need to define and use multi-dimensional arrays (i.e., arrays whose elements are arrays). For example, matrices and tables are examples of structures that can be realized as two-dimensional arrays.

The following is the example of defining a two-dimensional array −

var myMatrix = ofDim[Int](3,3)

This is an array that has three elements each being an array of integers that has three elements.

Example of Multidimensional Arrays

Try the following example program to process a multi-dimensional array −

import Array._
object Demo {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      // build a matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      // Print two dimensional array
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

0 1 2
0 1 2
0 1 2

Another Way to Create Multi-Dimensional Array

In Scala, the usual method to create an array and work with its elements is by using the apply and update methods. For example, you can define a One-dimensional array, like this:

val intArray: Array[Int] = Array(7, 14, 21)
println(intArray(1))
intArray(1) = 28
println(intArray(1))

Multidimensional Array Using Array.ofDim(), Array.fill(), and Array.tabulate()

A multi-dimensional array is an array of arrays. In Scala, you can create multi-dimensional arrays using methods like Array.ofDim(), Array.fill(), and Array.tabulate().

ofDim() creates an array with the specified dimensions but does not initialize its elements.
fill() creates an array and initializes all elements with a given value.
tabulate() generates an array where each element is computed based on its indices.

// Creating a 2D array with 2 rows and 3 columns 
// (elements initialized to 0 by default)
val matrix = Array.ofDim[Int](2, 3)

// Creating a 3D array (2x3x4), 
// initializing all elements to 1
val cubeFill = Array.fill(2, 3, 4)(1)

// Creating a 3D array (2x3x5) 
// where each element is computed using the indices
val cubeTabulate = Array.tabulate(2, 3, 5) { case (x, y, z) => x * y * z }

Here,

The first array, matrix, is a 2D array with 2 rows and 3 columns, where each element is initialized to 0 (the default value for Int).
The second array, cubeFill, is a 3D array with 2 layers, 3 rows, and 4 columns, where each element is initialized to 1. The last argument of Array.fill specifies the default value.
The third array, cubeTabulate, is also a 3D array but initialized dynamically using a function. Each element is calculated based on its indices using x * y * z.

Multidimensional Array by Using Array of Array

You can create multidimensional array by using an array of arrays. For example, Scala Program of Multidimensional array using Array of Array.

Example

Try the following example program −

object Demo {
  def main(args: Array[String]): Unit = {
    // Creating and assigning values to the array
    var customArr = Array(Array(10, 20, 30, 40, 50),
                          Array(15, 25, 35, 45, 55)) 

    for (rowIndex <- 0 to 1) {
      for (colIndex <- 0 to 4) {
        // Accessing the values
        print(" " + customArr(rowIndex)(colIndex)) 
      }
      println()
    }
  }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

 10 20 30 40 50
 15 25 35 45 55

Example

Another example for printing elements with row and column. Scala Program of Multidimensional array using Array of Array −

object Demo {
  def main(args: Array[String]): Unit = {
    // Creating and assigning values to the array
    var customArray = Array(Array(10, 20, 30, 40, 50), 
                            Array(15, 25, 35, 45, 55)) 

    for (rowIndex <- 0 to 1; colIndex <- 0 until 5) {
      print(s"$rowIndex, $colIndex")

      // Accessing the elements
      println(s" = ${customArray(rowIndex)(colIndex)}")
    }
  }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

0, 0 = 10
0, 1 = 20
0, 2 = 30
0, 3 = 40
0, 4 = 50
1, 0 = 15
1, 1 = 25
1, 2 = 35
1, 3 = 45
1, 4 = 55

Printing Multidimensional Arrays

It is a tough task to print multi-dimensional arrays. It depends on the number of dimensions in the given array.

For example, this is function to print a multidimensional array:

def printMultidimensionalArray[T](array: Array[Array[T]]): Unit =
  array.foreach(row => println(row.mkString(" ")))

// Example usage:
printMultidimensionalArray(matrixFill)
println("--")
printMultidimensionalArray(matrixTabulate)

This will work based on the array dimension. Above code will take two-dimensional array. It will iterate over each element of the array and convert elements of arrays into strings separated by spaces. Then it will print each string on newlines. Since this function is generic, it can work with two different two-dimensional arrays, i.e., matrixFill and matrixTabulate.

Suppose these arrays are as:

val matrixFill: Array[Array[Int]] = Array(
  Array(1, 2, 3),
  Array(4, 5, 6),
  Array(7, 8, 9)
)

val matrixTabulate: Array[Array[Int]] = Array(
  Array(10, 20, 30),
  Array(40, 50, 60),
  Array(70, 80, 90)
)

So, output of the code will be,

Multi-dimensional arrays store elements in matrix format. You need multidimensional arrays for matrices and tables.

Print Page