Escala | arreglos

Array es un tipo especial de colección en scala. es una estructura de datos de tamaño fijo que almacena elementos del mismo tipo de datos. El índice del primer elemento de una array es cero y el último elemento es el número total de elementos menos uno. Es una colección de valores mutables. Corresponde a arrays (en términos de sintaxis) en Java pero al mismo tiempo es diferente (en términos de funcionalidades) de Java.

Algunos puntos importantes:

• Las arrays de Scala pueden ser genéricas. lo que significa que podemos tener un Array[T], donde T es un parámetro de tipo o tipo abstracto.
• Los arreglos de Scala son compatibles con las secuencias de Scala; podemos pasar un Array[T] donde se requiere un Seq[T].
• Los arreglos Scala también admiten todas las operaciones de secuencia.

La siguiente figura muestra cómo los valores se pueden almacenar en una array secuencialmente:

Scala es compatible con arrays de una y varias dimensiones. Una array de una sola dimensión es aquella que tiene solo una fila y n columnas, mientras que una array de dos dimensiones es en realidad una array de dimensión (n * m).

En esta array contiene solo una fila para almacenar los valores. Todos los valores de esta array se almacenan de forma contigua desde 0 hasta el tamaño de la array.
Sintaxis:

var arrayname = new Array[datatype](size)

Aquí, el tipo de datos especifica el tipo de datos que se asignan, el tamaño especifica la cantidad de elementos en la array y var es el nombre de la variable de la array que está vinculada a la array.
Ejemplo:

// Scala program to creating an array 
// of the string as week days, store  
// day values in the weekdays, 
// and prints each value. 
object GFG
{
    // Main method
    def main(args: Array[String]) 
    {
        // allocating memory of 1D Array of string. 
        var days = Array("Sunday", "Monday", "Tuesday", 
                    "Wednesday", "Thursday", "Friday",
                    "Saturday" )
      
        println("Array elements are : ")
        for ( m1 <-days )
        {
            println(m1 )
        }
          
    }
}

Array elements are : 
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

Aquí, estamos creando una array para almacenar los días de la semana e imprimir todos los días.

1. Acceder a los elementos de la array:
   Ejemplo:

   // Scala program to accessing an array  // of the string as name. object GFG {     // Main method     def main(args: Array[String])      {         // allocating memory of 1D Array of string.          var name = Array("gfg", "geeks", "GeeksQuize",                      "geeksforgeeks" )                println("second element of an array is: ")                    // Accessing an array element         println(name(1) )     } }

   Producción:

   second element of an array is: 
   geeks

2. Actualización de un elemento en la array:
   Ejemplo:

   // Scala program to updating an array  // of the string as name. object GFG {     // Main method     def main(args: Array[String])      {         // allocating memory of 1D Array of string.          var name = Array("gfg", "geeks", "GeeksQuize",                      "geeksforgeeks" )                                // Updating anelement in an array                      name(1)="employee"         println("After updation array elements are: ")                    for ( m1 <-name )         {             println(m1 )         }     } }

   Producción:

   After updation array elements are: 
   gfg
   employee
   GeeksQuize
   geeksforgeeks

3. Agregar elementos en una array:
   Ejemplo:

   // Scala program to adding elements in an array  // of the string as name. object GFG {     // Main method     def main(args: Array[String])      {         var name = new Array[String](4)                    // Adding element in an array          name(0)="gfg"         name(1)="geeks"         name(2)="GeeksQuize"         name(3)="geeksforgeeks"         println("After adding array elements : ")                    for ( m1 <-name )         {             println(m1 )         }            } }

   Producción:

   After adding array elements : 
   gfg
   geeks
   GeeksQuize
   geeksforgeeks

4. Concatenar Arreglos:
   Podemos concatenar dos arreglos usando el método concat(). En el método concat() podemos pasar más de una array como argumentos.
   Ejemplo:

   // Scala program to concatenate two array  // by using concat() method import Array._    // Creating object object GFG {            // Main method def main(args: Array[String]) {     var arr1 = Array(1, 2, 3, 4)     var arr2 = Array(5, 6, 7, 8)        var arr3 = concat( arr1, arr2)            // Print all the array elements     for ( x <- arr3 )      {         println( x )     } } }

   Producción:

   1
   2
   3
   4
   5
   6
   7
   8

   Aquí, arr1 es una array de cuatro elementos y arr2 es otra array de cuatro elementos. Ahora concatenamos estas dos arrays en arr3 usando el método concat().

Las arrays multidimensionales contienen más de una fila para almacenar los valores. Scala tiene un método Array.ofDim para crear arrays multidimensionales en Scala . En estructuras como arrays y tablas, se pueden utilizar arreglos multidimensionales.
Sintaxis:

var array_name = Array.ofDim[ArrayType](N, M)
 or  
var array_name = Array(Array(elements), Array(elements)

Esta es una array de dos dimensiones. Aquí N es no. de filas y M es no. de Columnas.

Ejemplo:

// Scala program to creating a 
// multidimension array of the 
// string as names, store  
// values in the names, 
// and prints each value. 
object GFG
{
    // Main method
    def main(args:Array[String]) 
    {
        val rows = 2
        val cols = 3
          
        // Declaring Multidimension array
        val names = Array.ofDim[String](rows, cols)
          
        // Allocating values
        names(0)(0) = "gfg"
        names(0)(1) = "Geeks"
        names(0)(2) = "GeeksQuize"
        names(1)(0) = "GeeksForGeeks"
        names(1)(1) = "Employee"
        names(1)(2) = "Author"
        for
        {
            i <- 0 until rows
            j <- 0 until cols
        }
          
        // Printing values
        println(s"($i)($j) = ${names(i)(j)}")
    }
}

(0)(0) = gfg
(0)(1) = Geeks
(0)(2) = GeeksQuize
(1)(0) = GeeksForGeeks
(1)(1) = Employee
(1)(2) = Author

Use estos operadores (métodos) para agregar y anteponer elementos a una array mientras asigna el resultado a una nueva variable:

Ejemplos para mostrar cómo usar los métodos anteriores para agregar y anteponer elementos a una array:

object GFG
{
     
  // Main method
  def main(args: Array[String])
  {
      
    // Declaring an array
    val a = Array(45, 52, 61) 
    println("Array a ")
    for ( x <- a ) 
    {
      println( x )
    }
  
    // Appending 1 item
    val b = a :+ 27 
    println("Array b ")
    for ( x <- b ) 
    {
      println( x )
    }
  
    // Appending 2 item
    val c = b ++ Array(1, 2)
    println("Array c ")
    for ( x <- c ) 
    {
       println( x )
    }
  
    // Prepending 1 item
    val d = 3 +: c 
    println("Array d ")
    for ( x <- d ) 
    {
      println( x )
    }
  
    // Prepending 2 item
    println("Array e ")
    val e = Array(10, 25) ++: d
    for ( x <- e ) 
    {
      println( x )
    }
  }
}

Producción :

Array a 
45
52
61
Array b 
45
52
61
27
Array c 
45
52
61
27
1
2
Array d 
3
45
52
61
27
1
2
Array e 
10
25
3
45
52
61
27
1
2