Scala Arrays

Los arrays proporcionados en el lenguaje Scala se utilizan para almacenar elementos del mismo tipo de tamaño fijo. Los arrays son una de las estructuras de datos importantes para todos los lenguajes de programación.

Declarar una variable de array no es declarar variables individuales como number0, number1, ..., number99, sino declarar una variable como numbers, y luego usar numbers

El índice del primer elemento de un array es 0, y el índice del último elemento es el número total de elementos menos 1.


Declarar arrays

La siguiente es la sintaxis para declarar arrays en Scala:

var z:Array[String] = new Array[String](3)

或

var z = new Array[String](3)

En la sintaxis anterior, z declara un array de tipo String, con longitud 3, que puede almacenar 3 elementos. Podemos asignar un valor a cada elemento y acceder a cada elemento mediante el índice, como se muestra a continuación:

z(0) = "Ejemplo"; z(1) = "Baidu"; z(4/2) = "Google"

El índice del último elemento usa la expresión4/2como índice, similar az(2) = "Google"。

También podemos definir un array de la siguiente manera:

var z = Array("Ejemplo", "Baidu", "Google")

La siguiente figura muestra un array myList de longitud 10, con valores de índice de 0 a 9:


Procesar arrays

Los tipos de elementos del array y el tamaño del array son fijos, por lo que al procesar los elementos de un array, normalmente usamos un bucle for básico.

El siguiente ejemplo demuestra el proceso de creación e inicialización de arrays:

Ejemplo

object Test {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
     
      // Imprimir todos los elementos del array
      for ( x <- myList ) {
         println( x )
      }

      // Calcular la suma de todos los elementos del array
      var total = 0.0;
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("La suma es " + total);

      // Encontrar el elemento más grande del array
      var max = myList(0);
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      println("El valor máximo es " + max);
   
   }
}

Al ejecutar el código anterior, el resultado es:

$ scalac Test.scala
$ scala Test
1.9
2.9
3.4
3.5
总和为 11.7
最大值为 3.5

Arrays multidimensionales

En un array multidimensional, los valores de un array pueden ser otro array, y los valores de otro array también pueden ser un array. Las matrices y tablas son arrays bidimensionales comunes.

El anterior es un ejemplo que define un array bidimensional:

val myMatrix = Array.ofDim[Int](3, 3)

En el ejemplo, el array contiene tres elementos de array, y cada elemento de array contiene a su vez tres valores.

A continuación, veamos un ejemplo completo de procesamiento de un array bidimensional:

Ejemplo

import Array._

object Test {
   def main(args: Array[String]) {
      val myMatrix = Array.ofDim[Int](3, 3)
     
      // Crear una matriz
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
     
      // Imprimir la matriz bidimensional
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   
   }
}

Al ejecutar el código anterior, el resultado es:

$ scalac Test.scala
$ scala Test
0 1 2
0 1 2
0 1 2

Combinar arrays

En el siguiente ejemplo, usamos el método concat() para combinar dos arrays. El método concat() acepta múltiples parámetros de array:

Ejemplo

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = Array(1.9, 2.9, 3.4, 3.5)
      var myList2 = Array(8.9, 7.9, 0.4, 1.5)

      var myList3 =  concat( myList1, myList2)
     
      // Imprimir todos los elementos del array
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

Al ejecutar el código anterior, el resultado es:

$ scalac Test.scala
$ scala Test
1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

Crear arrays de rango

En el siguiente ejemplo, usamos el método range() para generar un array dentro de un rango. El último parámetro del método range() es el paso, cuyo valor predeterminado es 1:

Ejemplo

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)

      // Imprimir todos los elementos del array
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

Al ejecutar el código anterior, el resultado es:

$ scalac Test.scala
$ scala Test
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

Métodos de arrays en Scala

La siguiente tabla muestra los métodos importantes para manejar arrays en Scala. Antes de usarlos, necesitamos usarimport Array._para importar el paquete.

N.º Método y descripción
1

def apply( x: T, xs: T* ): Array[T]

Crea un array de un objeto T especificado; el valor de T puede ser Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean.

2

def concat[T]( xss: Array[T]* ): Array[T]

Combinar arrays

3

def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit

Copia un array a otro. Equivale a System.arraycopy(src, srcPos, dest, destPos, length) de Java.

4

def empty[T]: Array[T]

Devuelve un array de longitud 0

5

def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]

Devuelve un array de la longitud especificada, donde cada elemento es el valor de retorno de una función especificada.

En el ejemplo anterior, el array tiene un valor inicial de 0, una longitud de 3, y la función de cálculo esa=>a+1:

scala> Array.iterate(0,3)(a=>a+1)
res1: Array[Int] = Array(0, 1, 2)
6

def fill[T]( n: Int )(elem: => T): Array[T]

Devuelve un array, cuya longitud es especificada por el primer parámetro, y cada elemento se rellena con el segundo parámetro.

7

def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]

Devuelve un array bidimensional, cuya longitud es especificada por el primer parámetro, y cada elemento se rellena con el segundo parámetro.

8

def ofDim[T]( n1: Int ): Array[T]

Crea un array de la longitud especificada

9

def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]

Crea un array bidimensional

10

def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]

Crea un array tridimensional

11

def range( start: Int, end: Int, step: Int ): Array[Int]

Crea un array dentro del rango especificado, step es el paso entre cada elemento.

12

def range( start: Int, end: Int ): Array[Int]

Crea un array dentro del rango especificado

13

def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]

Devuelve un array de la longitud especificada, donde cada elemento es el valor de retorno de una función especificada, comenzando desde 0 por defecto.

El ejemplo anterior devuelve 3 elementos:

scala> Array.tabulate(3)(a => a + 5)
res0: Array[Int] = Array(5, 6, 7)
14

def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]

Devuelve un array bidimensional de la longitud especificada, donde cada elemento es el valor de retorno de una función especificada, comenzando desde 0 por defecto.

Otras extensiones