Scala for Backend Engineering & Functional Programming · Aula

Agrupamento e ordenação

groupBy e sortBy.

Agrupamento e ordenação é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Organizando dados

Dados do mundo real frequentemente precisam ser agrupados por uma propriedade ou ordenados por uma chave. As coleções do Scala oferecem groupBy, sortBy, sortWith e recursos semelhantes para fazer isso de forma declarativa.

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

sorted: ordem natural

sorted ordena os elementos em sua ordem natural (crescente para números e alfabética para cadeias de caracteres). Ele precisa de uma ordenação, que existe para tipos comuns.

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

sortBy: ordenar por uma chave

sortBy ordena por um valor derivado de cada elemento. Forneça uma função que extraia a chave de ordenação.

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

Ordenando em ordem decrescente

Para ordenar em ordem decrescente, negue uma chave numérica ou use sorted(Ordering.Int.reverse). Para chaves derivadas, usar sortBy com um sinal de menos é uma forma concisa.

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 recebe uma função que retorna true quando o primeiro argumento deve vir antes do segundo, dando a você controle total sobre a ordenação.

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)
  }
}

Ordenando por várias chaves

sortBy pode retornar uma tupla para ordenar por várias chaves de uma só vez: ele compara o primeiro elemento e depois o segundo para desempatar.

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: particionando em um Map

groupBy retorna um Map em que cada chave é o resultado da sua função e cada valor é a lista de elementos que compartilham essa chave.

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)
  }
}

Agrupando por uma chave calculada

A chave de agrupamento pode ser qualquer coisa: uma primeira letra, um comprimento ou uma categoria. Cada chave distinta se torna um 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") }
  }
}

Transformando grupos

Depois de agrupar, frequentemente você deseja resumir cada grupo. Use view.mapValues (ou map) para transformar os valores, por exemplo, contando os 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 em uma única etapa

groupMapReduce agrupa, transforma cada elemento e reduz os valores de cada grupo, tudo em uma única passagem. É uma forma concisa de criar resumos, como somas por categoria.

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)
  }
}

Combinando agrupamento e ordenação

Um padrão frequente: agrupar os dados, resumir cada grupo e depois ordenar o resumo. Aqui, contamos as palavras por primeira letra e ordenamos pela contagem.

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)
  }
}

Verificação rápida

O que List(1,2,3,4).groupBy(_ % 2 == 0) retorna?

Recapitulação

Você aprendeu sobre agrupamento e ordenação:

sorted — ordem natural
sortBy — ordenação por uma chave derivada (tupla para várias chaves)
sortWith — comparador personalizado
groupBy — particiona em um Map de grupos
groupMapReduce — agrupa, transforma e reduz em uma única passagem

Perguntas Frequentes

A aula “Agrupamento e ordenação” é grátis?

Sim — o texto completo de “Agrupamento e ordenação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Agrupamento e ordenação”?

groupBy e sortBy. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Agrupamento e ordenação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming