Scala for Backend Engineering & Functional Programming · Pelajaran

Pengelompokan dan Pengurutan

groupBy dan sortBy.

Pengelompokan dan Pengurutan adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Mengatur data

Data dunia nyata sering perlu dikelompokkan berdasarkan suatu properti atau diurutkan berdasarkan kunci. Koleksi Scala menyediakan groupBy, sortBy, sortWith, dan lainnya untuk melakukannya secara deklaratif.

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

sorted: urutan alami

sorted mengurutkan elemen berdasarkan urutan alami (menaik untuk angka, dan berdasarkan abjad untuk string). Fungsi ini memerlukan aturan pengurutan, yang tersedia untuk tipe-tipe umum.

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

sortBy: mengurutkan berdasarkan kunci

sortBy mengurutkan berdasarkan nilai yang diturunkan dari setiap elemen. Berikan fungsi yang mengambil kunci pengurutan.

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

Mengurutkan dalam urutan menurun

Untuk mengurutkan secara menurun, negasikan kunci numerik atau gunakan sorted(Ordering.Int.reverse). Untuk kunci turunan, sortBy dengan tanda minus merupakan cara yang ringkas.

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: pembanding khusus

sortWith menerima fungsi yang mengembalikan true jika argumen pertama harus berada sebelum argumen kedua, sehingga Anda memiliki kendali penuh atas pengurutan.

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

Mengurutkan berdasarkan beberapa kunci

sortBy dapat mengembalikan sebuah tupel untuk mengurutkan berdasarkan beberapa kunci sekaligus: fungsi ini membandingkan elemen pertama, lalu elemen kedua untuk menyelesaikan hasil yang sama.

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: mempartisi menjadi Map

groupBy mengembalikan sebuah Map yang setiap kuncinya merupakan hasil fungsi Anda, sedangkan setiap nilainya adalah daftar elemen yang memiliki kunci tersebut.

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

Mengelompokkan berdasarkan kunci yang dihitung

Kunci pengelompokan dapat berupa apa saja: huruf pertama, panjang, atau kategori. Setiap kunci yang berbeda menjadi satu kelompok.

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

Mengubah kelompok

Setelah mengelompokkan data, Anda biasanya ingin meringkas setiap kelompok. Gunakan view.mapValues (atau map) untuk mengubah nilainya, misalnya menghitung elemen dalam setiap kelompok.

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 dalam satu langkah

groupMapReduce mengelompokkan, memetakan setiap elemen, dan mereduksi nilai setiap kelompok, semuanya dalam satu kali lintasan. Ini adalah cara ringkas untuk membuat ringkasan seperti jumlah 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)
  }
}

Menggabungkan pengelompokan dan pengurutan

Pola yang sering digunakan: kelompokkan data, ringkas setiap kelompok, lalu urutkan ringkasannya. Di sini, kita menghitung kata berdasarkan huruf pertama dan mengurutkannya berdasarkan jumlah.

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

Pemeriksaan Singkat

Apa yang dikembalikan oleh List(1,2,3,4).groupBy(_ % 2 == 0)?

Ringkasan

Anda telah mempelajari pengelompokan dan pengurutan:

sorted — urutan alami
sortBy — mengurutkan berdasarkan kunci turunan (tupel untuk beberapa kunci)
sortWith — pembanding khusus
groupBy — mempartisi menjadi Map yang berisi kelompok-kelompok
groupMapReduce — mengelompokkan, memetakan, dan mereduksi dalam satu kali lintasan

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengelompokan dan Pengurutan” gratis?

Ya — teks lengkap “Pengelompokan dan Pengurutan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pengelompokan dan Pengurutan”?

groupBy dan sortBy. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pengelompokan dan Pengurutan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming