Map映射 #

val map1 = Map("a" -> 1, "b" -> 2, "c" -> 3)
val map2 = Map(("a", 1), ("b", 2), ("c", 3))
val map3 = Map.empty[String, Int]
val map4 = Map.fill(3)("key" -> 0)

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

map("a")
map.apply("a")
map.get("a")
map.get("d")
map.getOrElse("d", 0)
map.keySet
map.values
map.toList

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

val map1 = map + ("c" -> 3)
val map2 = map + ("c" -> 3, "d" -> 4)
val map3 = map ++ Map("c" -> 3, "d" -> 4)
val map4 = map.updated("c", 3)

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

val map1 = map - "a"
val map2 = map - ("a", "b")
val map3 = map -- List("a", "b")
val map4 = map.removed("a")

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

val map1 = map.updated("a", 10)
val map2 = map + ("a" -> 10)

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

map.get("a")
map.get("d")
map.getOrElse("d", 0)
map.getOrElseUpdate("d", 4)
map.find(_._2 > 1)
map.filter(_._2 > 1)
map.filterKeys(_ == "a")

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

map.isEmpty
map.nonEmpty
map.contains("a")
map.keySet
map.values
map.keys

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

map.map { case (k, v) => (k.toUpperCase, v * 2) }
map.mapValues(_ * 2)
map.transform((k, v) => s"$k: $v")
map.toList
map.toSeq
map.toSet

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

map.size
map.values.sum
map.values.product
map.values.max
map.values.min
map.foldLeft(0) { case (acc, (_, v)) => acc + v }

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

val grouped = list.groupBy(_ % 2)
val partitioned = list.partition(_ % 2 == 0)

import scala.collection.mutable

val map = mutable.Map("a" -> 1, "b" -> 2)
val empty = mutable.Map.empty[String, Int]

import scala.collection.mutable

val map = mutable.Map("a" -> 1)

map += ("b" -> 2)
map += ("c" -> 3, "d" -> 4)
map ++= Map("e" -> 5, "f" -> 6)
map.put("g", 7)
map("h") = 8

import scala.collection.mutable

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

map -= "a"
map -= ("b", "c")
map --= List("d", "e")
map.remove("f")
map.clear()

import scala.collection.mutable

val map = mutable.Map("a" -> 1, "b" -> 2)

map("a") = 10
map.update("b", 20)

import scala.collection.mutable

val map = mutable.Map("a" -> 1)

val value = map.getOrElseUpdate("b", 2)
println(value)
println(map)

val hashMap = scala.collection.immutable.HashMap("a" -> 1, "b" -> 2)

import scala.collection.immutable.TreeMap

val treeMap = TreeMap("c" -> 3, "a" -> 1, "b" -> 2)
println(treeMap)

import scala.collection.mutable.LinkedHashMap

val linkedMap = LinkedHashMap("c" -> 3, "a" -> 1, "b" -> 2)
println(linkedMap)

import scala.collection.immutable.ListMap

val listMap = ListMap("c" -> 3, "a" -> 1, "b" -> 2)

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

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

case class Person(name: String, department: String, salary: Double)

val people = List(
  Person("Alice", "Engineering", 100000),
  Person("Bob", "Engineering", 90000),
  Person("Charlie", "Marketing", 80000),
  Person("David", "Marketing", 85000)
)

val byDepartment = people.groupBy(_.department)
val avgSalary = byDepartment.map { case (dept, employees) =>
  dept -> employees.map(_.salary).sum / employees.length
}

import scala.collection.mutable

class Cache[K, V]:
  private val store = mutable.Map.empty[K, V]
  
  def get(key: K): Option[V] = store.get(key)
  
  def put(key: K, value: V): Unit = store.put(key, value)
  
  def getOrCompute(key: K)(compute: => V): V =
    store.getOrElseUpdate(key, compute)
  
  def remove(key: K): Option[V] = store.remove(key)
  
  def clear(): Unit = store.clear()

val cache = Cache[String, String]()
cache.put("key1", "value1")
println(cache.get("key1"))
println(cache.getOrCompute("key2") { "computed" })

import scala.collection.mutable

class MultiMap[K, V]:
  private val store = mutable.Map.empty[K, mutable.Set[V]]
  
  def add(key: K, value: V): Unit =
    store.getOrElseUpdate(key, mutable.Set.empty) += value
  
  def remove(key: K, value: V): Unit =
    store.get(key).foreach(_ -= value)
  
  def get(key: K): Set[V] =
    store.get(key).map(_.toSet).getOrElse(Set.empty)
  
  def removeKey(key: K): Unit =
    store.remove(key)

val multiMap = MultiMap[String, String]()
multiMap.add("fruit", "apple")
multiMap.add("fruit", "banana")
multiMap.add("fruit", "cherry")
println(multiMap.get("fruit"))