Scala for Backend Engineering & Functional Programming · Leçon

Regroupement et tri

groupBy et sortBy

Regroupement et tri est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Organiser les données

Les données du monde réel doivent souvent être regroupées selon une propriété ou triées selon une clé. Les collections Scala proposent groupBy, sortBy, sortWith et d’autres méthodes similaires pour effectuer cela de manière déclarative.

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

sorted : ordre naturel

sorted trie les éléments selon leur ordre naturel (ordre croissant pour les nombres, ordre alphabétique pour les chaînes). Une relation d’ordre est nécessaire ; elle existe pour les types courants.

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

sortBy : trier selon une clé

sortBy trie selon une valeur dérivée de chaque élément. Fournissez une fonction qui extrait la clé de tri.

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

Trier par ordre décroissant

Pour trier par ordre décroissant, inversez une clé numérique ou utilisez sorted(Ordering.Int.reverse). Pour les clés dérivées, sortBy avec un signe moins est une solution concise.

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 : comparateur personnalisé

sortWith prend une fonction qui renvoie true lorsque le premier argument doit apparaître avant le second, ce qui vous donne un contrôle total sur l’ordre.

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

Trier selon plusieurs clés

sortBy peut renvoyer un tuple pour trier selon plusieurs clés à la fois : il compare le premier élément, puis le deuxième pour départager les égalités.

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 : partitionner dans une Map

groupBy renvoie une Map où chaque clé est le résultat de votre fonction et chaque valeur est la liste des éléments qui partagent cette clé.

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

Regrouper selon une clé calculée

La clé de regroupement peut être quelconque : une première lettre, une longueur, une catégorie. Chaque clé distincte devient un compartiment.

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

Transformer les groupes

Après un regroupement, vous souhaitez souvent résumer chaque compartiment. Utilisez view.mapValues (ou map) pour transformer les valeurs, par exemple en comptant les éléments de chaque groupe.

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 une seule étape

groupMapReduce regroupe, transforme chaque élément et réduit les valeurs de chaque groupe, le tout en un seul parcours. C’est une manière concise de créer des résumés, comme les sommes par catégorie.

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

Combiner regroupement et tri

Un schéma fréquent consiste à regrouper les données, à résumer chaque groupe, puis à trier le résumé. Ici, nous comptons les mots pour chaque première lettre et nous les trions selon leur nombre.

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

Vérification rapide

Que renvoie List(1,2,3,4).groupBy(_ % 2 == 0) ?

Récapitulatif

Vous avez appris à regrouper et à trier :

sorted — ordre naturel
sortBy — trier selon une clé dérivée (tuple pour plusieurs clés)
sortWith — comparateur personnalisé
groupBy — partitionner en une Map de compartiments
groupMapReduce — regrouper, transformer et réduire en un seul parcours

Questions Fréquemment Posées

La leçon « Regroupement et tri » est-elle gratuite ?

Oui — le texte complet de « Regroupement et tri » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Regroupement et tri » ?

groupBy et sortBy Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Regroupement et tri » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Scala for Backend Engineering & Functional Programming