Scala for Backend Engineering & Functional Programming · Lección

Agrupación y ordenamiento

groupBy y sortBy

Agrupación y ordenamiento es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

Organizar datos

Los datos del mundo real a menudo deben agruparse por una propiedad o ordenarse por una clave. Las colecciones de Scala ofrecen groupBy, sortBy, sortWith y otros métodos para hacerlo de forma declarativa.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(5, 3, 8, 1, 9, 2)
    println(nums.sorted)
  }
}

sorted: orden natural

sorted ordena los elementos según su orden natural (ascendente para los números y alfabético para las cadenas). Necesita un criterio de ordenación, disponible para los tipos habituales.

object Main {
  def main(args: Array[String]): Unit = {
    println(List(3, 1, 2).sorted)
    println(List("pear", "apple", "fig").sorted)
  }
}

sortBy: ordenar por una clave

sortBy ordena según un valor derivado de cada elemento. Proporcione una función que extraiga la clave de ordenación.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("banana", "fig", "apple")
    val byLength = words.sortBy(_.length)
    println(byLength)
  }
}

Orden descendente

Para ordenar de forma descendente, niegue una clave numérica o use sorted(Ordering.Int.reverse). Para claves derivadas, sortBy con un signo menos resulta conciso.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(5, 3, 8, 1)
    println(nums.sortBy(-_))
    println(nums.sorted(Ordering.Int.reverse))
  }
}

sortWith: comparador personalizado

sortWith recibe una función que devuelve true cuando el primer argumento debe ir antes que el segundo, lo que le proporciona un control total sobre el orden.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(5, 3, 8, 1)
    val descending = nums.sortWith((a, b) => a > b)
    println(descending)
  }
}

Ordenar por varias claves

sortBy puede devolver una tupla para ordenar por varias claves a la vez: compara el primer elemento y después el segundo para resolver los empates.

object Main {
  def main(args: Array[String]): Unit = {
    val people = List(("Ann", 30), ("Bob", 25), ("Ann", 22))
    val sorted = people.sortBy { case (name, age) => (name, age) }
    println(sorted)
  }
}

groupBy: dividir en un Map

groupBy devuelve un Map en el que cada clave es el resultado de su función y cada valor es la lista de elementos que comparten esa clave.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4, 5, 6)
    val byParity = nums.groupBy(_ % 2 == 0)
    println(byParity)
  }
}

Agrupar por una clave calculada

La clave de agrupación puede ser cualquier cosa: una letra inicial, una longitud o una categoría. Cada clave distinta se convierte en un grupo.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "avocado", "banana", "cherry", "cranberry")
    val byFirstLetter = words.groupBy(_.head)
    byFirstLetter.foreach { case (letter, ws) => println(s"$letter -> $ws") }
  }
}

Transformar grupos

Después de agrupar, normalmente querrá resumir cada grupo. Use view.mapValues (o map) para transformar los valores, por ejemplo, contando los elementos de cada grupo.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("cat", "car", "dog", "deer", "cow")
    val counts = words.groupBy(_.head).view.mapValues(_.size).toMap
    println(counts)
  }
}

groupMapReduce en un solo paso

groupMapReduce agrupa, transforma cada elemento y reduce los valores de cada grupo, todo en una sola pasada. Es una forma concisa de crear resúmenes, como sumas por categoría.

object Main {
  def main(args: Array[String]): Unit = {
    val sales = List(("books", 10), ("toys", 5), ("books", 7), ("toys", 3))
    val totals = sales.groupMapReduce(_._1)(_._2)(_ + _)
    println(totals)
  }
}

Combinar agrupación y ordenación

Un patrón frecuente es agrupar los datos, resumir cada grupo y después ordenar el resumen. Aquí contamos las palabras por letra inicial y las ordenamos por cantidad.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "avocado", "banana", "cherry", "cranberry", "apricot")
    val ranked = words
      .groupBy(_.head)
      .view.mapValues(_.size).toList
      .sortBy(-_._2)
    println(ranked)
  }
}

Comprobación rápida

¿Qué devuelve List(1,2,3,4).groupBy(_ % 2 == 0)?

Repaso

Ha aprendido a agrupar y ordenar:

sorted — orden natural
sortBy — ordenar por una clave derivada (tupla para varias claves)
sortWith — comparador personalizado
groupBy — dividir en un Map de grupos
groupMapReduce — agrupar, transformar y reducir en una sola pasada

Preguntas frecuentes

¿La lección «Agrupación y ordenamiento» es gratis?

Sí — el texto completo de «Agrupación y ordenamiento» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Agrupación y ordenamiento»?

groupBy y sortBy Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Agrupación y ordenamiento»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Scala for Backend Engineering & Functional Programming