Scala för backendutveckling och funktionell programmering · Lektion

Gruppering och sortering

groupBy och sortBy.

Lektion 4 av 413 steg

Gruppering och sortering är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Organisera data

Data från verkligheten behöver ofta grupperas efter en egenskap eller sorteras efter en nyckel. Scala-samlingar erbjuder groupBy, sortBy, sortWith och liknande för att göra detta deklarativt.

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

sorted: naturlig ordning

sorted sorterar element i deras naturliga ordning (stigande för tal, alfabetiskt för strängar). Den behöver en sorteringsordning, som finns för vanliga typer.

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

sortBy: sortera efter en nyckel

sortBy sorterar efter ett värde som härleds från varje element. Ange en funktion som hämtar sorteringsnyckeln.

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

Sortera i fallande ordning

För att sortera fallande kan du negera en numerisk nyckel eller använda sorted(Ordering.Int.reverse). För härledda nycklar är sortBy med ett minustecken koncist.

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: anpassad jämförare

sortWith tar en funktion som returnerar true när det första argumentet ska komma före det andra, vilket ger dig full kontroll över ordningen.

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

Sortera efter flera nycklar

sortBy kan returnera en tuple för att sortera efter flera nycklar samtidigt: först jämförs det första elementet, sedan det andra för att avgöra lika fall.

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: dela upp i en Map

groupBy returnerar en Map där varje nyckel är resultatet av din funktion och varje värde är listan med element som delar den nyckeln.

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

Gruppera efter en beräknad nyckel

Grupperingsnyckeln kan vara vad som helst: en första bokstav, en längd eller en kategori. Varje unik nyckel blir en grupp.

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

Transformera grupper

Efter gruppering vill du ofta sammanfatta varje grupp. Använd view.mapValues (eller map) för att transformera värdena, till exempel genom att räkna elementen i varje grupp.

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 i ett steg

groupMapReduce grupperar, mappar varje element och reducerar varje grupps värden, allt i en enda genomgång. Det är ett koncist sätt att skapa sammanfattningar, till exempel summor per kategori.

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

Kombinera gruppering och sortering

Ett vanligt mönster är att gruppera data, sammanfatta varje grupp och sedan sortera sammanfattningen. Här räknar vi ord per första bokstav och sorterar efter antal.

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

Snabb kontroll

Vad returnerar List(1,2,3,4).groupBy(_ % 2 == 0)?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig gruppering och sortering:

sorted — naturlig ordning
sortBy — sortera efter en härledd nyckel (tuple för flera nycklar)
sortWith — anpassad jämförare
groupBy — dela upp i en Map med grupper
groupMapReduce — gruppera, mappa och reducera i en enda genomgång

Gratis att börja

Lär dig Scala med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 143

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Gruppering och sortering” gratis?

Ja – hela texten till ”Gruppering och sortering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad lär jag mig i ”Gruppering och sortering”?

groupBy och sortBy. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?

Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Gruppering och sortering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?

Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Scala för backendutveckling och funktionell programmering