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.
- 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
- 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
( m
1
<
-name )
{
println(m
1
)
}
}
}
Producción:
After updation array elements are: gfg employee GeeksQuize geeksforgeeks
- 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
( m
1
<
-name )
{
println(m
1
)
}
}
}
Producción:
After adding array elements : gfg geeks GeeksQuize geeksforgeeks
- 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
arr
1
=
Array(
1
,
2
,
3
,
4
)
var
arr
2
=
Array(
5
,
6
,
7
,
8
)
var
arr
3
=
concat( arr
1
, arr
2
)
// Print all the array elements
for
( x
<
- arr
3
)
{
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:
Método | Función | Ejemplo |
---|---|---|
:+ | agregar 1 elemento | array_antigua :+ e |
++ | agregar N elemento | array_antigua ++ array_nueva |
+: | anteponer 1 elemento | e +: array_antigua |
++: | anteponer N elementos | array_nueva ++: array_antigua |
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
Publicación traducida automáticamente
Artículo escrito por shiwanisinha y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA