Scala 集合库实战：不可变集合、性能选择与常用操作速查

val list = List(1, 2, 3)          // 不可变
val map  = Map("a" -> 1)          // 不可变

// 需要可变时显式导入
import scala.collection.mutable
val buf = mutable.ArrayBuffer(1, 2)
buf += 3                          // 可变操作

val list = List(1, 2, 3)
val vec  = Vector(1, 2, 3)
val set  = Set(1, 2, 3)
val map  = Map("a" -> 1, "b" -> 2)
val range = 1 to 10 by 2          // Range(1,3,5,7,9)

List(1,2,3).map(_ * 2)               // List(2,4,6)
List(1,2,3,4).filter(_ % 2 == 0)     // List(2,4)
List(1,2,3).flatMap(x => List(x, x)) // List(1,1,2,2,3,3)
List(1,2,3).collect { case x if x > 1 => x * 10 }  // List(20,30)

List(1,2,3,4).foldLeft(0)(_ + _)     // 10
List(1,2,3,4).reduceLeft(_ + _)      // 10（非空）
List(1,2,3).sum                      // 6
List(1,2,3).max                      // 3
List(1,2,3).mkString(",")            // "1,2,3"

List(1,2,3,4).take(2)                // List(1,2)
List(1,2,3,4).drop(2)                // List(3,4)
List(1,2,3,4).headOption             // Some(1)
List().headOption                    // None
List(1,2,3,4).tail                   // List(2,3,4)

List(3,1,2).sorted                   // List(1,2,3)
List(3,1,2).sortBy(-_)               // List(3,2,1)
List(1,1,2,3).distinct                // List(1,2,3)

case class User(name: String, age: Int)
val users = List(User("a", 20), User("b", 30), User("c", 20))

val byAge = users.groupBy(_.age)
// Map(20 -> List(User(a,20), User(c,20)), 30 -> List(User(b,30)))

List(1,2,3,4,5).sliding(3).toList
// List(List(1,2,3), List(2,3,4), List(3,4,5))  ← 重叠窗口

List(1,2,3,4,5).grouped(2).toList
// List(List(1,2), List(3,4), List(5))  ← 不重叠分块

val (even, odd) = List(1,2,3,4).partition(_ % 2 == 0)
// even=List(2,4), odd=List(1,3)

val (pre, post) = List(1,2,3,4).span(_ < 3)
// pre=List(1,2), post=List(3,4)   ← 直到条件不成立

// ❌ 急切求值：全部计算出来，再取前 3
(1 to 10000000).map(_ * 2).take(3).toList   // 浪费：算了 1000 万次

// ✅ 惰性求值：只算需要的部分
LazyList.range(1, 10000000).map(_ * 2).take(3).toList

val fibs: LazyList[BigInt] =
  BigInt(0) #:: BigInt(1) #::
    fibs.zip(fibs.tail).map { case (a, b) => a + b }

fibs.take(10).toList   // 只算前 10 个斐波那契

val big = Vector.range(1, 10000000)
val result = big.view.filter(_ % 3 == 0).map(_ * 2).take(5).toList
// view 让 filter/map 惰性，避免中间集合

import scala.collection.parallel.immutable.ParVector

val data = ParVector(1 to 10000)
val sum = data.map(_ * 2).sum    // 自动并行

import scala.jdk.CollectionConverters.*

val javaList: java.util.List[Int] = List(1,2,3).asJava
val scalaList: List[Int] = javaList.asScala.toList

val javaMap = Map("a" -> 1).asJava
val backScala = javaMap.asScala

// Scala 集合 → Java Stream
val stream = List(1,2,3).asJava.stream()
// Java Stream → Scala
val fromStream = stream.toArray().toSeq