El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Listas y Arreglos

Siguiente ►
►

En este tema, exploraremos dos de las estructuras de datos más fundamentales en Scala: las listas y los arreglos. Aprenderemos cómo se definen, cómo se utilizan y las diferencias clave entre ellas. También veremos ejemplos prácticos y ejercicios para reforzar los conceptos.

Contenidos

  1. Introducción a las Listas
  2. Operaciones Básicas con Listas
  3. Introducción a los Arreglos
  4. Operaciones Básicas con Arreglos
  5. Comparación entre Listas y Arreglos
  6. Ejercicios Prácticos

  1. Introducción a las Listas

Las listas en Scala son colecciones inmutables que pueden contener elementos de cualquier tipo. Se definen utilizando la clase List.

Definición de Listas

val listaVacia: List[Int] = List()
val listaNumeros: List[Int] = List(1, 2, 3, 4, 5)
val listaStrings: List[String] = List("Scala", "es", "genial")

Características de las Listas

  • Inmutables: Una vez creadas, no se pueden modificar.
  • Homogéneas: Todos los elementos deben ser del mismo tipo.
  • Eficientes: Operaciones como agregar un elemento al inicio (::) son rápidas.

Operaciones Comunes

  • Acceso a Elementos: Utilizando índices.
  • Concatenación: Utilizando el operador ::: o el método ++.
  • Mapeo y Filtrado: Utilizando métodos como map y filter.

Ejemplo de Operaciones

val lista = List(1, 2, 3, 4, 5)

// Acceso a elementos
val primerElemento = lista.head
val restoElementos = lista.tail

// Concatenación
val otraLista = List(6, 7, 8)
val listaConcatenada = lista ::: otraLista

// Mapeo y Filtrado
val listaDoblada = lista.map(_ * 2)
val listaFiltrada = lista.filter(_ % 2 == 0)

  1. Operaciones Básicas con Listas

Acceso a Elementos

val lista = List(10, 20, 30, 40, 50)
val primerElemento = lista(0) // 10
val segundoElemento = lista(1) // 20

Concatenación de Listas

val lista1 = List(1, 2, 3)
val lista2 = List(4, 5, 6)
val listaConcatenada = lista1 ::: lista2 // List(1, 2, 3, 4, 5, 6)

Mapeo y Filtrado

val lista = List(1, 2, 3, 4, 5)
val listaDoblada = lista.map(_ * 2) // List(2, 4, 6, 8, 10)
val listaFiltrada = lista.filter(_ % 2 == 0) // List(2, 4)

  1. Introducción a los Arreglos

Los arreglos en Scala son colecciones mutables que pueden contener elementos de cualquier tipo. Se definen utilizando la clase Array.

Definición de Arreglos

val arregloVacio: Array[Int] = Array()
val arregloNumeros: Array[Int] = Array(1, 2, 3, 4, 5)
val arregloStrings: Array[String] = Array("Scala", "es", "genial")

Características de los Arreglos

  • Mutables: Los elementos pueden ser modificados después de la creación.
  • Homogéneos: Todos los elementos deben ser del mismo tipo.
  • Eficientes: Acceso y modificación de elementos son operaciones rápidas.

Operaciones Comunes

  • Acceso a Elementos: Utilizando índices.
  • Modificación de Elementos: Asignando nuevos valores a índices específicos.
  • Mapeo y Filtrado: Utilizando métodos como map y filter.

Ejemplo de Operaciones

val arreglo = Array(1, 2, 3, 4, 5)

// Acceso a elementos
val primerElemento = arreglo(0)
val segundoElemento = arreglo(1)

// Modificación de elementos
arreglo(0) = 10
arreglo(1) = 20

// Mapeo y Filtrado
val arregloDoblado = arreglo.map(_ * 2)
val arregloFiltrado = arreglo.filter(_ % 2 == 0)

  1. Operaciones Básicas con Arreglos

Acceso a Elementos

val arreglo = Array(10, 20, 30, 40, 50)
val primerElemento = arreglo(0) // 10
val segundoElemento = arreglo(1) // 20

Modificación de Elementos

val arreglo = Array(1, 2, 3, 4, 5)
arreglo(0) = 10
arreglo(1) = 20
// arreglo ahora es Array(10, 20, 3, 4, 5)

Mapeo y Filtrado

val arreglo = Array(1, 2, 3, 4, 5)
val arregloDoblado = arreglo.map(_ * 2) // Array(2, 4, 6, 8, 10)
val arregloFiltrado = arreglo.filter(_ % 2 == 0) // Array(2, 4)

  1. Comparación entre Listas y Arreglos

Característica Listas Arreglos
Mutabilidad Inmutables Mutables
Acceso a Elementos Lento (O(n)) Rápido (O(1))
Modificación No permitido Permitido
Tamaño Dinámico Fijo
Uso Común Operaciones funcionales Operaciones de alto rendimiento

  1. Ejercicios Prácticos

Ejercicio 1: Crear y Manipular Listas

Instrucciones:

  1. Crea una lista de números del 1 al 10.
  2. Accede al tercer elemento de la lista.
  3. Filtra los números pares de la lista.
  4. Dobla cada número de la lista.

Solución:

val lista = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val tercerElemento = lista(2)
val numerosPares = lista.filter(_ % 2 == 0)
val listaDoblada = lista.map(_ * 2)

Ejercicio 2: Crear y Manipular Arreglos

Instrucciones:

  1. Crea un arreglo de números del 1 al 10.
  2. Accede al quinto elemento del arreglo.
  3. Modifica el primer elemento del arreglo para que sea 100.
  4. Filtra los números impares del arreglo.

Solución:

val arreglo = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val quintoElemento = arreglo(4)
arreglo(0) = 100
val numerosImpares = arreglo.filter(_ % 2 != 0)

Conclusión

En esta sección, hemos aprendido sobre las listas y los arreglos en Scala, dos estructuras de datos fundamentales. Hemos visto cómo se definen, sus características, y cómo realizar operaciones básicas con ellas. También hemos comparado sus diferencias clave y realizado ejercicios prácticos para reforzar los conceptos. Con este conocimiento, estamos preparados para explorar otras colecciones y estructuras de datos en Scala.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados