删除列表中的重复项指定相等函数

Question

我有一个List[A]，在给定相等函数(a:A, b:A) => Boolean 的情况下，删除重复项的惯用方法是什么？我一般不能覆盖equalsfor A

我现在能想到的方法是创建一个包装 class AExt 并覆盖 equals，然后

list.map(new AExt(_)).distinct

但我想知道是否有更清洁的方法。

Answer 1

有一种简单（更简单）的方法可以做到这一点：

list.groupBy(_.key).mapValues(_.head)

如果您愿意，可以通过将_.head 替换为如下功能块来立即使用生成的地图：

sameElements => { val observedItem = sameElements.head
                  new A (var1 = observedItem.firstAttr,
                         var2 = "SomethingElse") }

为每个不同的元素返回一个新的A。

只有一个小问题。上面的代码 (list.groupBy(_.key).mapValues(_.head)) 没有很好地解释删除重复项的意图。出于这个原因，拥有像 distinctIn[A](attr: A => B) 或 distinctBy[A](eq: (A, A) -> Boolean) 这样的函数会很棒。

Answer 2

使用 misingFaktor 的回答中的 Foo 和 customEquals：

  case class Foo(a: Int, b: Int)
  val (a, b, c, d) = (Foo(3, 4), Foo(3, 1), Foo(2, 5), Foo(2, 5))
  def customEquals(x: Foo, y: Foo) = x.a == y.a

  (Seq(a, b, c, d).foldLeft(Seq[Foo]()) {
    (unique, curr) => {
      if (!unique.exists(customEquals(curr, _)))
        curr +: unique
      else
        unique
    }
  }).reverse

如果结果排序很重要，但要删除的重复项不重要，那么 foldRight 更可取

  Seq(a, b, c, d).foldRight(Seq[Foo]()) {
    (curr, unique) => {
      if (!unique.exists(customEquals(curr, _)))
        curr +: unique
      else
        unique
    }
  }

Answer 3

我必须说我想我会通过一个中间集合，它是一个 Set，如果你预计你的 Lists 可能会很长，因为 测试存在（通过 @987654323 @ 或 find) 在 Seq 上当然是 O(n)：

而不是写一个自定义的equals；决定元素相等的属性。所以而不是：

def myCustomEqual(a1: A, a2: A) = a1.foo == a2.foo && a1.bar == a2.bar

制作一个钥匙。像这样：

type Key = (Foo, Bar)
def key(a: A) = (a.foo, a.bar)

然后您可以将密钥添加到Set 以查看您以前是否遇到过它们。

var keys = Set.empty[Key]
((List.empty[A] /: as) { (l, a) => 
  val k = key(a)
  if (keys(k)) l else { keys += k; a +: l  }
}).reverse

当然，在非常短的列表的情况下，此解决方案具有更差的空间复杂性和可能更差的性能（因为您正在创建额外的对象 - 键）。如果您不喜欢折叠中的 var，您可能想看看如何使用 scalaz 7

中的 State 和 Traverse 实现此目的

Answer 4

scala> case class Foo(a: Int, b: Int)
defined class Foo

scala> val (a, b, c, d) = (Foo(3, 4), Foo(3, 1), Foo(2, 5), Foo(2, 5))
a: Foo = Foo(3,4)
b: Foo = Foo(3,1)
c: Foo = Foo(2,5)
d: Foo = Foo(2,5)

scala> def customEquals(x: Foo, y: Foo) = x.a == y.a
customEquals: (x: Foo, y: Foo)Boolean

scala> Seq(a, b, c, d) filter {
     |   var seq = Seq.empty[Foo]
     |   x => {
     |    if(seq.exists(customEquals(x, _))) {
     |      false 
     |    } else { 
     |      seq :+= x
     |      true 
     |    }
     | }
res13: Seq[Foo] = List(Foo(3,4), Foo(2,5))

Answer 5

从Scala 2.13 开始，我们可以使用新的distinctBy 方法，该方法在应用转换函数f 后返回忽略由== 确定的重复项的序列元素：

def distinctBy[B](f: (A) => B): List[A]

例如：

// case class A(a: Int, b: String, c: Double)
// val list = List(A(1, "hello", 3.14), A(2, "world", 3.14), A(1, "hello", 12.3))
list.distinctBy(x => (x.a, x.b)) // List(A(1, "hello", 3.14), A(2, "world", 3.14))
list.distinctBy(_.c)             // List(A(1, "hello", 3.14), A(1, "hello", 12.3))

Answer 6

case class Foo (a: Int, b: Int)

val x = List(Foo(3,4), Foo(3,1), Foo(2,5), Foo(2,5))
def customEquals(x : Foo, y: Foo) = (x.a == y.a && x.b == y.b)

x.foldLeft(Nil : List[Foo]) {(list, item) => 
   val exists = list.find(x => customEquals(item, x))
   if (exists.isEmpty) item :: list
   else list
 }.reverse

res0: List[Foo] = List(Foo(3,4), Foo(3,1), Foo(2,5))