scala - 扩展 Scala 集合的简单示例

Question

我正在寻找一个非常简单的子类化 Scala 集合的示例。我对完整解释它是如何以及为什么会起作用的不是很感兴趣。其中有很多可用here和 elsewhere在互联网上。我想知道简单的方法。

下面的类可能是一个尽可能简单的例子。这个想法是，创建 Set[Int] 的子类它有一种额外的方法:

class SlightlyCustomizedSet extends Set[Int] {
  def findOdd: Option[Int] = find(_ % 2 == 1)
}

显然这是错误的。一个问题是没有构造函数可以将东西放入 Set。 .一个 CanBuildFrom必须构建对象，最好通过调用一些已经存在的知道如何构建它的库代码。我已经看到在伴生对象中实现了几个附加方法的示例，但它们展示了它是如何工作的或者如何做一些更复杂的事情。我想看看如何利用库中已有的内容通过几行代码来解决这个问题。实现这一点的最小、最简单的方法是什么？

Answer 1

如果您只想向一个类添加一个方法，那么子类化可能不是可行的方法。 Scala 的集合库有点复杂，叶类并不总是适合子类化(可以从子类化 HashSet 开始，但这会让你踏上一个深陷兔子洞的旅程)。

也许实现目标的更简单方法是:

implicit class SetPimper(val s: Set[Int]) extends AnyVal {
  def findOdd: Option[Int] = s.find(_ % 2 == 1)
}

这实际上并不是 Set 的子类，而是创建了一个隐式转换，允许您执行以下操作:

Set(1,2,3).findOdd // Some(1)

掉进兔子洞

如果您有 Java 背景，那么扩展标准集合如此困难可能会令人惊讶——毕竟 Java 标准库中充斥着 j.u.ArrayList。子类，几乎所有可以包含其他东西的东西。然而，Scala 有一个关键区别:它的首选集合都是不可变的。

这意味着他们没有 add就地修改它们的方法。相反，他们有 +构造一个新实例的方法，其中包含所有原始项目以及新项目。如果他们天真地实现了这一点，那将是非常低效的，因此他们使用各种特定于类的技巧来允许新实例与原始实例共享数据。 +方法甚至可能返回与原始对象不同类型的对象——一些集合类对小集合或空集合使用不同的表示。

但是，这也意味着，如果您想子类化不可变集合之一，那么您需要了解要子类化的类的内容，以确保您的子类实例的构造方式与基类相同.

顺便说一句，如果您想对可变集合进行子类化，这些都不适用于您。他们在 scala 世界中被视为二等公民，但他们确实拥有 add方法，并且很少需要构造新实例。以下代码:

class ListOfUsers(users: Int*) extends scala.collection.mutable.HashSet[Int] {
  this ++= users

  def findOdd: Option[Int] = find(_ % 2 == 1)
}

在大多数情况下，可能会或多或少地做你所期望的( map 并且 friend 可能不会完全按照你的期望去做，因为我将在一分钟内得到 CanBuildFrom 的东西，但请耐心等待)。

核选项

如果继承失败了，我们总是有一个核选项可以依靠:组合。我们可以创建自己的 Set将其职责委托(delegate)给委托(delegate)的子类，如下所示:

import scala.collection.SetLike
import scala.collection.mutable.Builder
import scala.collection.generic.CanBuildFrom

class UserSet(delegate: Set[Int]) extends Set[Int] with SetLike[Int, UserSet] {
    override def contains(key: Int) = delegate.contains(key)
    override def iterator = delegate.iterator
    override def +(elem: Int) = new UserSet(delegate + elem)
    override def -(elem: Int) = new UserSet(delegate - elem)
    override def empty = new UserSet(Set.empty)
    override def newBuilder = UserSet.newBuilder
    override def foreach[U](f: Int => U) = delegate.foreach(f) // Optional
    override def size = delegate.size // Optional
}

object UserSet {
    def apply(users: Int*) = (newBuilder ++= users).result()
    def newBuilder = new Builder[Int, UserSet] {
        private var delegateBuilder = Set.newBuilder[Int]
        override def +=(elem: Int) = {
            delegateBuilder += elem
            this
        }
        override def clear() = delegateBuilder.clear()
        override def result() = new UserSet(delegateBuilder.result())
    }

    implicit object UserSetCanBuildFrom extends CanBuildFrom[UserSet, Int, UserSet] {
        override def apply() = newBuilder
        override def apply(from: UserSet) = newBuilder
    }
}

这可以说是既过于复杂又过于简单。它的代码行数比我们打算编写的要多得多，但是，它仍然很幼稚。

它可以在没有伴随类的情况下工作，但没有 CanBuildFrom , map将返回一个普通的 Set ，这可能不是你所期望的。我们还覆盖了 Set 文档中的可选方法。建议我们实现。

如果我们是彻底的，我们会创建一个 CanBuildFrom ，并实现了 empty对于我们的可变类，因为这确保了少数创建新实例的方法将按照我们的预期工作。

但这听起来像是很多工作......

如果这听起来工作量太大，请考虑以下内容:

case class UserSet(users: Set[Int])

当然，您必须输入更多的字母才能获得一组用户，但我认为它比子类化更好地分离关注点。