Scala2.13新特性及集合库介绍

### Scala 2.13 新特性及集合库介绍 Scala 2.13 已经迎来了其发布五周年的里程碑，并且即将推出首个候选版本。此时，其功能特性基本稳定，我们可以深入了解一下这个版本的新特性。 #### 1. Scala 2.13 简介 Scala 2.13 是 Scala 编程语言的最新小版本更新。尽管版本号看起来只是一个小的提升，但这个版本的重要性远超表面。其主要亮点在于重新设计的集合库，该库将取代 Scala 2.8 版本引入、2.9 版本略有调整的当前版本。新的集合框架将在 Scala 2 中持续使用，还会成为 Scala 3 的一部分。 与之前的版本相比，由于这主要是一个库的更新，语言本身的变化并不大。除了集合库的更新，新版本在以下三个方面有所改进： - 最小化核心库 - 加快编译器速度 - 提高用户友好性 此外，还增加了字面量和单例类型，以及对标准库的一些小改动。 #### 2. Scala 2.13 新特性 ##### 2.1 字符串字面量的可选解析 在 Scala 2.13 中，`StringOps` 扩展了一些方法，用于字符串字面量解析并返回 `Option` 类型。支持的类型包括所有数字类型和布尔类型。这些新方法可以大大简化用户提供数据的处理，无需使用异常处理来包装调用。示例如下： ```scala scala> "10".toIntOption res3: Option[Int] = Some(10) scala> "TrUe".toBooleanOption res4: Option[Boolean] = Some(true) scala> val bool = "Not True" bool: String = Not True scala> bool.toBooleanOption res5: Option[Boolean] = None ``` 可选的布尔解析与抛出异常的 `toBoolean` 方法一样，会忽略参数的大小写。 ##### 2.2 产品可以报告其元素的名称 这个特性对于 case 类特别有用，因为它使得在不使用反射或宏的情况下进行一些通用编程成为可能。下面的示例展示了如何使用新的 `productElementName(idx)` 方法为简单的 case 类构建一个简单的 JSON 序列化器： ```scala case class User(name: String, surname: String, email: String) def naiveToJsonString(p: Product): String = (for { i <- 0 until p.productArity } yield s""""${p.productElementName(i)}": "${p.productElement(i)}"""") .mkString("{ ", ", ", " }") scala> val user = User("John", "Doe", "[email protected]") user: User = User(John,Doe,[email protected]) scala> naiveToJsonString(user) res1: String = { "name": "John", "surname": "Doe", "email": "[email protected]" } ``` 不过，如果索引无效，该方法会抛出异常： ```scala scala> user.productElementName(3) java.lang.IndexOutOfBoundsException: 3 at User.productElementName(<console>:1) ... 38 elided ``` ##### 2.3 新增链式操作方法 通过导入 `scala.util.chaining._`，现在可以为任何类型的实例添加 `tap` 和 `pipe` 方法。这些功能由隐式转换为 `ChainingOps` 提供。 `pipe` 方法将给定的函数应用于值并返回结果，有助于将嵌套的函数调用转换为类似流畅接口的代码。例如，对于一个虚构的用户数据库： ```scala object UserDb { def getById(id: Long): User = ??? def update(u: User): User = ??? def save(u: User): Boolean = ??? } import UserDb._ val userId = 1L // 嵌套调用 save(update(getById(userId))) // 使用 pipe 方法 getById(userId).pipe(update).pipe(save) ``` 也可以通过组合函数来实现相同的效果： ```scala val doEverything = (getById _).andThen(update).andThen(save) doEverything(userId) ``` `tap` 方法将给定的函数仅用于产生副作用，并返回原始值，可用于日志记录和简单的性能测量。示例如下： ```scala scala> import scala.util.chaining._ import scala.util.chaining._ scala> val lastTick = new java.util.concurrent.atomic.AtomicLong(0) lastTick: java.util.concurrent.atomic.AtomicLong = 0 scala> def measure[A](a: A): Unit = { | val now = System.currentTimeMillis() | val before = lastTick.getAndSet(now) | println(s"$a: ${now-before} ms elapsed") | } measure: [A](a: A)Unit scala> def start(): Unit = lastTick.set(System.currentTimeMillis()) start: ()Unit scala> start() scala> val result = scala.io.StdIn.readLine().pipe(_.toIntOption).tap(measure) None: 291 ms elapsed result: Option[Int] = None scala> val anotherResult = scala.io.StdIn.readLine().pipe(_.toIntOption).tap(measure) Some(3456): 11356 ms elapsed anotherResult: Option[Int] = Some(3456) ``` ##### 2.4 自动资源管理 Scala 2.13 增加了一种实用的自动管理资源的方法。`scala.util.Using` 允许我们以熟悉的副作用方式进行资源管理。所有对资源的操作都包装在 `Try` 中。 以下是一个实际应用的示例： ```scala scala> import scala.util.{Try, Using} import scala.util.{Try, Using} scala> final case class Resource(name: String) extends AutoCloseable { | override def close(): Unit = println(s"Closing $name") | def lines = List(s"$name line 1", s"$name line 2") | } defined class Resource scala> val List(r1, r2, r3) = List("first", "2", "3").map(Resource) r1: Resource = Resource(first) r2: Resource = Resource(2) r3: Resource = Resource(3) scala> val lines: Try[Seq[String]] = for { | u1 <- Using(r1) | u2 <- Using(r2) | u3 <- Using(r3) | } yield { | u1.lines ++ u2.lines ++ u3.lines | } Closing 3 Closing 2 Closing first lines: scala.util.Try[Seq[String]] = Success(List(first line 1, first line 2, 2 line 1, 2 line 2, 3 line 1, 3 line 2)) ``` 控制台输出表明，结果包含了所有资源的行，并且资源会以相反的顺序自动关闭。 #### 3. Scala 2.13 集合库 Scala 2.13 推出了新的集合库，由于历史原因，也被称为 “collection - strawman”。该库的重构主要有以下几个目标： - 修复上一版本的常见问题 - 简化实现和内部结构，以及使用和向后兼容性 - 更好地与惰性集合和 Java 流集成 - 更清晰地分离可变和不可变集合的 API - 提高性能 - 最小化从 Scala 2.12 集合迁移的工作量 新的集合库与上一版本基本源代码兼容，许多旧方法和类型（如 `Traversable`、`TraversableOnce` 和 `Stream`）已被弃用，并且内部层次结构更简单。 ##### 3.1 集合库的顶层层次结构 集合库的顶层层次结构由以下几个特质描述： - `IterableOnce`：只能迭代一次的集合。 - `Iterable`：可以多次迭代的集合。 - `Seq`：元素有顺序的集合。 - `Set`：元素唯一的集合。 - `Map`：集合类型从单个元素 `A` 变为键 `K` 和值 `V` 的对。 操作定义在带有 `Ops` 后缀的辅助特质中，这些特质形成了与上述类似的层次结构。 ##### 3.2 IterableOnceOps `IterableOnceOps` 是可以遍历一次或多次的集合的蓝图。它定义了一些抽象方法和许多具体方法，具体方法根据 `IterableOnce` 提供的迭代器实现，提供默认的（如果可能）惰性实现，可分为以下几类： | 类别 | 方法 | | ---- | ---- | | 大小操作 | `isEmpty`, `nonEmpty`, `size`, `knownSize`, `isTraversableAgain` | | 元素测试 | `forall`, `exists`, `count` | | 字符串操作 | `mkString`, `addString` | | 转换为其他集合 | `copyToArray`, `toList`, `toMap`, `to`, `toSet`, `toSeq`, `toIndexedSeq`, `toBuffer`, `toArray` | | 折叠和归约 | `foldLeft`, `foldRight`, `reduce`, `reduceLeft`, `reduceRight`, `reduceOption`, `reduceLeftOption`, `reduceRightOption` | | 数值组合 | `sum`, `product` | | 排序组合 | `min`, `minOption`, `max`, `maxOption`, `maxBy`, `maxByOption`, `minBy`, `minByOption` | | 元素检索 | `collectFirst`, `find` | | 相等性 | `corresponds` | 抽象方法可分为以下几类： - 子集合检索：`filter`, `filterNot`, `take`, `takeWhile`, `drop`, `dropWhile`, `slice`, `span` - 映射：`map`, `flatMap`, `collect`, `scanLeft` - 拉链：`zipWithIndex` ##### 3.3 IterableOps `IterableOps` 扩展了 `IterableOnceOps`，包含了一些必须能够多次迭代集合才能实现的方法，可分为以下几类： | 类别 | 方法 | | ---- | ---- | | 元素检索 | `head`, `headOption`, `last`, `lastOption` | | 大小 | `sizeCompare` | | 子集合检索 | `partition`, `partitionWith`, `splitAt`, `takeRight`, `dropRight`, `grouped`, `sliding`, `tail`, `init`, `groupBy`, `groupMap`, `groupMapReduce`, `tails`, `inits` | | 映射 | `scanRight` | | 添加 | `concat`, `++` | | 拉链 | `zip`, `zipAll`, `unzip`, `unzip3` | | 转换 | `transpose` | `IterableOnceOps` 中定义的一些抽象方法在 `IterableOps` 中有了具体的默认实现，`isTraversableAgain` 被重写为返回 `true`。 需要注意的是，`Iterable` 和 `IterableOnce` 不支持通用的相等操作，该操作在特定的集合子类型中定义。 ##### 3.4 三个特殊方法 `IterableOps` 中有三个特殊方法值得关注： - `withFilter(p: A => Boolean): collection.WithFilter[A, CC]`：用于专门化映射和过滤操作。 - `iterableFactory: IterableFactory[CC]`：是特定集合伴生对象的基础特质，提供了从无到有构建集合的方法，如下表所示： | 方法 | 描述 | | ---- | ---- | | `from[A](source: IterableOnce[A])` | 从现有的 `IterableOnce` 创建目标集合。 | | `empty[A]: CC[A]` | 一个空集合，通常定义为一个对象。 | | `apply[A](elems: A*): CC[A]` | 从可变参数创建集合。 | | `iterate[A](start: A, len: Int)(f: A => A): CC[A]` | 用 `f` 应用于 `start` 及其后续结果填充集合，共 `len` 次。 | | `range[A : Integral](start: A, end: A, step: A): CC[A]` | 包含递增整数 `[start, end - 1]`，步长为 `step` 的集合。 | | `fill[A](n: Int)(elem: => A): CC[A]` | 用 `n` 次评估 `elem` 填充集合。 | | `tabulate[A](n: Int)(f: Int => A): CC[A]` | 与 `fill` 类似，但使用索引作为评估参数。 | | `concat[A](xss: Iterable[A]*): CC[A]` | 将所有参数集合连接成一个集合。 | | `unfold[A, S](init: S)(f: S => Option[(A, S)]): CC[A]` | 从 `init` 状态开始，调用 `f` 生成集合元素并修改内部状态。 | - `view: View[A]`：`View` 在新版本的库中重新实现，代表具体化的迭代器操作。评估在视图转换为严格集合类型或遍历（如使用 `foreach` 方法）时进行。视图不记录源集合的类型。 以下是一个比较惰性和严格集合行为的示例： ```scala def transform[C <: Iterable[Char]](i: C): Iterable[Char] = i .map { c => print(s"-$c-"); c.toUpper } .take { println("\ntake"); 6 } val str = "Scala 2.13" val view: StringView = StringView(str) val transformed = transform(view) // A val strict = transform(str.toList) // B print("Lazy view constructed: ") transformed.foreach(print) // C print("\nLazy view forced: ") println(transformed.to(List)) // D println(s"Strict: $strict") // E ``` 该代码片段在 REPL 中产生以下输出： ``` take -S--c--a--l--a-- --2--.--1--3- take Lazy view constructed: -S-S-c-C-a-A-l-L-a-A- - Lazy view forced: -S--c--a--l--a-- -List(S, C, A, L, A, ) Strict: List(S, C, A, L, A, ) ``` 从输出可以看出，`take` 方法总是严格评估，视图会在每次强制时进行评估，并且 `map` 只应用于 `take` 方法的结果。 ### Scala 2.13 新特性及集合库介绍 #### 4. 新特性总结与应用场景 Scala 2.13 的这些新特性在不同的场景下都有其独特的应用价值，下面我们来总结一下这些新特性以及它们适用的场景。 ##### 4.1 字符串字面量可选解析 - **特性总结**：`StringOps` 扩展了用于字符串字面量解析并返回 `Option` 类型的方法，支持所有数字类型和布尔类型，避免了异常处理。 - **应用场景**：在处理用户输入数据时非常有用，例如在 Web 应用中接收用户输入的表单数据，使用这些方法可以更安全地处理可能无效的输入，而无需担心异常的抛出。 ##### 4.2 产品元素名称报告 - **特性总结**：`productElementName(idx)` 方法使 case 类在不使用反射或宏的情况下进行通用编程成为可能，可用于构建简单的 JSON 序列化器。 - **应用场景**：在需要将对象序列化为 JSON 格式的场景中，如前后端数据交互时，将 Scala 对象转换为 JSON 字符串发送给前端。 ##### 4.3 链式操作方法 - **特性总结**：通过导入 `scala.util.chaining._` 可以为任何类型的实例添加 `tap` 和 `pipe` 方法，`pipe` 用于转换嵌套函数调用，`tap` 用于产生副作用。 - **应用场景**： - `pipe` 方法在处理复杂的数据处理流程时，可以使代码更具可读性，例如在数据库操作中，将多个操作链式调用。 - `tap` 方法在日志记录和性能测量方面非常有用，例如在调试代码时，记录每个操作的执行时间。 ##### 4.4 自动资源管理 - **特性总结**：`scala.util.Using` 提供了一种实用的自动管理资源的方法，所有资源操作都包装在 `Try` 中。 - **应用场景**：在处理文件操作、数据库连接等需要手动关闭资源的场景中，使用 `Using` 可以确保资源在使用完毕后自动关闭，避免资源泄漏。 #### 5. 集合库的使用建议 新的 Scala 2.13 集合库虽然带来了很多改进，但在使用时也有一些需要注意的地方。 ##### 5.1 迁移注意事项 由于许多旧方法和类型已被弃用，从 Scala 2.12 迁移到 Scala 2.13 时，需要检查代码中是否使用了这些弃用的方法和类型，并进行相应的替换。例如，避免使用 `Traversable`、`TraversableOnce` 和 `Stream` 等类型。 ##### 5.2 性能优化 新集合库在性能上有一定的提升，但在处理大规模数据时，仍然需要注意选择合适的集合类型和操作方法。例如，对于需要频繁随机访问元素的场景，选择 `IndexedSeq` 类型的集合；对于需要去重的场景，选择 `Set` 类型的集合。 ##### 5.3 惰性集合的使用 惰性集合（如 `View`）在处理大规模数据时可以节省内存和提高性能，但需要注意其评估时机。在使用 `View` 时，要确保在需要结果时才进行强制评估，避免不必要的计算。 #### 6. 总结与展望 Scala 2.13 的发布为开发者带来了许多新的特性和改进，尤其是新的集合库，使得代码的编写更加简洁、高效和安全。新特性中的字符串解析、链式操作和自动资源管理等功能，都为开发者提供了更多的便利。 未来，随着 Scala 语言的不断发展，我们可以期待更多的优化和新特性的加入。例如，集合库可能会进一步优化性能，提供更多的操作方法；语言层面可能会引入更多的语法糖，提高开发效率。 同时，开发者在使用 Scala 2.13 时，应该充分利用这些新特性，根据具体的应用场景选择合适的方法和工具，以提高代码的质量和可维护性。 ### 附录：操作流程图 ```mermaid graph TD; A[接收用户输入] --> B{输入是否为有效数字}; B -- 是 --> C[使用 toIntOption 转换为 Option[Int]]; B -- 否 --> D[返回 None]; C --> E{是否需要进一步处理}; E -- 是 --> F[使用 pipe 方法进行链式操作]; E -- 否 --> G[直接使用结果]; F --> H[使用 tap 方法进行日志记录或性能测量]; H --> I[继续后续操作]; ``` ### 附录：新特性应用步骤 | 新特性 | 操作步骤 | | ---- | ---- | | 字符串字面量可选解析 | 1. 定义字符串变量；2. 调用 `toIntOption`、`toBooleanOption` 等方法进行解析；3. 根据返回的 `Option` 类型进行相应处理。 | | 产品元素名称报告 | 1. 定义 case 类；2. 实现 `productElementName(idx)` 方法；3. 使用该方法构建 JSON 序列化器。 | | 链式操作方法 | 1. 导入 `scala.util.chaining._`；2. 使用 `pipe` 方法进行函数调用链式操作；3. 使用 `tap` 方法进行副作用操作。 | | 自动资源管理 | 1. 导入 `scala.util.{Try, Using}`；2. 定义实现 `AutoCloseable` 接口的资源类；3. 使用 `Using` 进行资源管理，在 `for` 表达式中使用资源。 |