集合操作 #

val list = List(1, 2, 3, 4, 5)

list.map(_ * 2)
list.map(x => x * x)
list.map(_.toString)

val map = Map("a" -> 1, "b" -> 2)
map.map { case (k, v) => (k.toUpperCase, v * 2) }

val map = Map("a" -> 1, "b" -> 2, "c" -> 3)

map.mapValues(_ * 2)

val list = List(1, 2, 3)

list.flatMap(n => List(n, n * 2))

val words = List("Hello", "World")
words.flatMap(_.toList)

val nested = List(List(1, 2), List(3, 4), List(5, 6))
nested.flatMap(identity)

val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

list.collect {
  case x if x % 2 == 0 => x * x
}

val mixed: List[Any] = List(1, "hello", 2, "world", 3.14)
mixed.collect { case i: Int => i }

val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

list.filter(_ > 5)
list.filter(_ % 2 == 0)
list.filter(_.toString.length > 1)

val list = List(1, 2, 3, 4, 5)

list.filterNot(_ > 3)

val list = List(1, 2, 3, 4, 5, 1, 2, 3)

list.takeWhile(_ < 4)
list.dropWhile(_ < 4)

val list = List(1, 2, 3, 4, 5, 6)

val (evens, odds) = list.partition(_ % 2 == 0)

val list = List(1, 2, 3, 4, 5, 1, 2)

val (first, rest) = list.span(_ < 4)

val list = List(1, 2, 3, 4, 5)

list.reduce(_ + _)
list.reduce(_ * _)
list.reduce(_ max _)
list.reduce(_ min _)

val list = List(1, 2, 3, 4, 5)

list.reduceLeft(_ - _)
list.reduceRight(_ - _)

val list = List(1, 2, 3, 4, 5)

list.fold(0)(_ + _)
list.fold(1)(_ * _)
list.fold("")(_ + _)

val list = List(1, 2, 3, 4, 5)

list.foldLeft(0)(_ - _)
list.foldRight(0)(_ - _)

list.foldLeft(List.empty[Int])((acc, x) => x :: acc)

val list = List(1, 2, 3, 4, 5)

list.aggregate(0)(_ + _, _ + _)

val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

list.groupBy(_ % 2)
list.groupBy(_ % 3)

case class Person(name: String, age: Int)
val people = List(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 25))
people.groupBy(_.age)

val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

list.grouped(3).toList
list.grouped(4).toList

val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

list.sliding(3).toList
list.sliding(3, 2).toList

val list = List("apple", "banana", "cherry", "date", "elderberry")

list.groupMapReduce(_.head)(_.length)(_ + _)

val list = List(3, 1, 4, 1, 5, 9, 2, 6)

list.sorted
list.sorted(Ordering[Int].reverse)

val strings = List("banana", "apple", "cherry")
strings.sorted

case class Person(name: String, age: Int)

val people = List(
  Person("Alice", 25),
  Person("Bob", 30),
  Person("Charlie", 20)
)

people.sortBy(_.age)
people.sortBy(_.name)
people.sortBy(p => (p.age, p.name))

val list = List(3, 1, 4, 1, 5, 9, 2, 6)

list.sortWith(_ < _)
list.sortWith(_ > _)

case class Person(name: String, age: Int)
val people = List(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 20))

people.sortWith((a, b) => a.age < b.age)
people.sortWith((a, b) => a.name < b.name)

val list = List(1, 2, 3, 4, 5)

list.find(_ > 3)
list.find(_ > 10)

val list = List(1, 2, 3, 4, 5)

list.exists(_ > 3)
list.exists(_ > 10)
list.forall(_ > 0)
list.forall(_ > 3)

val list = List(1, 2, 3, 4, 5)

list.contains(3)
list.contains(10)

val list = List(1, 2, 3, 2, 1)

list.indexOf(2)
list.indexOf(2, 2)
list.lastIndexOf(2)

val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

list.count(_ > 5)
list.count(_ % 2 == 0)

val list1 = List(1, 2, 3)
val list2 = List("a", "b", "c")

list1.zip(list2)

val list3 = List(1, 2, 3, 4, 5)
val list4 = List("a", "b", "c")
list3.zip(list4)

val list1 = List(1, 2, 3)
val list2 = List("a", "b")

list1.zipAll(list2, 0, "x")
list2.zipAll(list1, "x", 0)

val list = List("a", "b", "c", "d", "e")

list.zipWithIndex
list.zipWithIndex.map { case (value, index) => s"$index: $value" }

val pairs = List((1, "a"), (2, "b"), (3, "c"))

val (numbers, letters) = pairs.unzip

val list = List(1, 1, 2, 2, 3, 3, 4, 4, 5)

list.distinct

val list1 = List(1, 2, 3, 4, 5)
val list2 = List(3, 4, 5, 6, 7)

list1.diff(list2)
list1.intersect(list2)
list1.union(list2)

val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

list.slice(2, 5)
list.slice(0, 3)

val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

val (first, second) = list.splitAt(5)

val list = List(1, 2, 3, 4, 5)

list.mkString
list.mkString(", ")
list.mkString("[", ", ", "]")

case class Sale(product: String, amount: Double, date: String)

val sales = List(
  Sale("A", 100, "2024-01"),
  Sale("B", 200, "2024-01"),
  Sale("A", 150, "2024-02"),
  Sale("B", 250, "2024-02")
)

val byProduct = sales
  .groupBy(_.product)
  .map { case (product, sales) =>
    product -> sales.map(_.amount).sum
  }

val byMonth = sales
  .groupBy(_.date)
  .map { case (month, sales) =>
    month -> sales.map(_.amount).sum
  }

def wordCount(text: String): Map[String, Int] =
  text.toLowerCase
    .split("\\W+")
    .filter(_.nonEmpty)
    .groupBy(identity)
    .map { case (word, occurrences) => word -> occurrences.length }

val text = "Hello world hello Scala world Scala scala"
println(wordCount(text))

case class User(name: String, age: Int, email: String)

val users = List(
  User("Alice", 25, "alice@example.com"),
  User("Bob", -5, "bob@example.com"),
  User("Charlie", 30, "invalid-email"),
  User("David", 200, "david@example.com")
)

val validUsers = users.filter { user =>
  user.age > 0 && user.age < 150 && user.email.contains("@")
}

val errors = users.map { user =>
  val errors = List(
    if user.age <= 0 then Some("Age must be positive") else None,
    if user.age >= 150 then Some("Age must be less than 150") else None,
    if !user.email.contains("@") then Some("Invalid email") else None
  ).flatten
  user.name -> errors
}.filter(_._2.nonEmpty)