Código:
// Declaración e inicialización de un array mutable
val arrayNumeros = Array(1, 2, 3, 4, 5)
// Acceso y modificación de elementos en un array
arrayNumeros(2) = 10 // Modifica el tercer elemento a 10
Explicación del Código: Los arrays en Scala se declaran con Array(...) seguido de los elementos entre paréntesis. Puedes acceder a los elementos utilizando índices (por ejemplo, arrayNumeros(2) accede al tercer elemento del array) y modificar los elementos directamente (como en arrayNumeros(2) = 10).
Explicación Breve: Las listas en Scala son colecciones inmutables de elementos del mismo tipo. A diferencia de los arrays, las listas no pueden ser modificadas después de su creación. Sin embargo, soportan operaciones eficientes como la concatenación para crear nuevas listas.
Código:
// Declaración e inicialización de una lista inmutable
val listaColores = List("Rojo", "Verde", "Azul")
// Concatenación de listas para crear una nueva lista
val listaNueva = listaColores ++ List("Blanco", "Negro")
Explicación del Código: Las listas en Scala se crean utilizando List(...). Son inmutables, lo que significa que una vez creadas, no se pueden modificar sus elementos. Puedes concatenar listas utilizando el operador ++, como se muestra en listaColores ++ List("Blanco", "Negro"), que crea una nueva lista listaNueva combinando los elementos de listaColores con los elementos de la lista proporcionada.
En Scala, los sets y mapas son estructuras de datos que permiten almacenar colecciones de elementos únicos y asociaciones de pares clave-valor, respectivamente.
// Sets y Mapas en Scala
// Declaración e inicialización de un set mutable
val setNumeros = scala.collection.mutable.Set(1, 2, 3, 4, 5)
// Añadir un elemento al set
setNumeros += 6
// Verificar si un elemento está presente en el set
val contieneTres = setNumeros.contains(3)
// Declaración e inicialización de un mapa mutable
val mapaColores = scala.collection.mutable.Map(
"rojo" -> "#FF0000",
"verde" -> "#00FF00",
"azul" -> "#0000FF"
)
// Acceder y modificar un valor en el mapa
mapaColores("rojo") = "#FF4500"
// Añadir un nuevo par clave-valor al mapa
mapaColores += ("blanco" -> "#FFFFFF")
Sets en Scala:
scala.collection.mutable.Set crea un set mutable. Puedes añadir elementos usando += y verificar la presencia de elementos con contains.Mapas en Scala:
scala.collection.mutable.Map inicializa un mapa mutable. Accede y modifica valores usando la sintaxis de índice (mapaColores("rojo")) y añade nuevos pares clave-valor con +=.En Scala, las tuplas son estructuras de datos que permiten agrupar elementos heterogéneos en una única entidad, mientras que las opciones son utilizadas para representar valores opcionales que pueden estar presentes (Some) o ausentes (None).
// Tuplas y Opciones en Scala
// Ejemplo de tupla
val persona = ("Juan", 30, "España")
// Acceso a elementos de una tupla
val nombre = persona._1
val edad = persona._2
val pais = persona._3
// Ejemplo de opción
val resultado: Option[Int] = Some(10)
// Acceder al valor de una opción usando pattern matching
resultado match {
case Some(valor) => println(s"El resultado es: $valor")
case None => println("No se encontró ningún resultado")
}
Tuplas en Scala:
(valor1, valor2, ...)). En el ejemplo, persona es una tupla que contiene un nombre (String), una edad (Int) y un país (String). Puedes acceder a los elementos de la tupla utilizando _1, _2, _3, etc.Opciones en Scala:
Option) son utilizadas para representar valores opcionales que pueden estar presentes (Some(valor)) o ausentes (None). En el ejemplo, resultado es una opción que contiene el valor Some(10), que representa que el valor 10 está presente.Pattern Matching:
resultado es Some(valor) o None y se imprime el resultado correspondiente.En Scala, las colecciones pueden ser mutables o inmutables, lo que afecta cómo se pueden modificar después de su creación. Las colecciones inmutables no permiten cambios después de la creación, mientras que las mutables permiten añadir, eliminar y actualizar elementos.
import scala.collection.mutable // Importar el paquete mutable
// Colecciones Inmutables
// Declaración e inicialización de una lista inmutable
val listaInmutable = List(1, 2, 3)
// Intento de añadir un elemento a una lista inmutable (generará un error)
// listaInmutable += 4 // Esto dará un error porque las listas inmutables no se pueden modificar
// Colecciones Mutables
// Declaración e inicialización de una lista mutable
val listaMutable = mutable.ListBuffer(1, 2, 3)
// Añadir un elemento a la lista mutable
listaMutable += 4
// Eliminar un elemento de la lista mutable
listaMutable -= 2
// Imprimir la lista mutable actualizada
println(s"Lista mutable después de la modificación: $listaMutable")
Colecciones Inmutables:
List, Set, y Map, no permiten cambios después de su creación. Cualquier intento de modificarlas generará un error en tiempo de compilación.Colecciones Mutables:
ListBuffer, ArrayBuffer, y HashMap, permiten cambios después de su creación. Puedes añadir, eliminar y actualizar elementos sin restricciones.Importación del Paquete Mutable:
scala.collection.mutable.