scala 中逆向排序的最佳方法是什么？

Question

在 scala 中进行逆排序的最佳方法是什么？我想下面的速度有点慢。

list.sortBy(_.size).reverse

有没有一种方便的方法使用 sortBy 但进行反向排序？我宁愿不需要使用sortWith。

Answer 1

如果您按某个数值排序，则可能有一种明显的方法可以更改符号。

list.sortBy(- _.size)

更一般地，排序可以通过使用隐式 Ordering 排序的方法来完成，您可以将其显式化，并且 排序有一个反向（不是下面的列表反向）
如果您要反转的顺序是隐式顺序，您可以

list.sorted(theOrdering.reverse)

通过implicitly[Ordering[A]]（A您要订购的类型) 或更好的Ordering[A]。这就是

list.sorted(Ordering[TheType].reverse)

sortBy 就像使用 Ordering.by 一样，所以你可以做

list.sorted(Ordering.by(_.size).reverse)

也许不是最短的写法（与减号相比），但意图很明确

更新

最后一行不起作用。要接受 Ordering.by(_.size) 中的 _，编译器需要知道我们要对哪种类型进行排序，以便它可以键入 _。看起来这可能是列表元素的类型，但事实并非如此，因为排序的签名是
defsorted[B>:A](ordering:Ordering[B])。排序可能在 A 上，但也可能在 A 的任何祖先上（您可以使用 byHashCode ： Ordering[Any] = Ordering.by(_.hashCode) ）。事实上，列表是协变的这一事实迫使这个签名。
人们可以这样做

list.sorted(Ordering.by((_: TheType).size).reverse)

，但这并不令人愉快。

Answer 2

list.sortBy(_.size)(Ordering[Int].reverse)

Answer 3

也许可以再缩短一点：

def Desc[T : Ordering] = implicitly[Ordering[T]].reverse

List("1","22","4444","333").sortBy( _.size )(Desc)

Answer 4

简单（至少在 size 的情况下）：

scala> val list = List("abc","a","abcde")
list: List[java.lang.String] = List(abc, a, abcde)

scala> list.sortBy(-_.size)
res0: List[java.lang.String] = List(abcde, abc, a)

scala> list.sortBy(_.size)
res1: List[java.lang.String] = List(a, abc, abcde)

Answer 5

sortWith 和 sortBy 都有一种紧凑的语法：

case class Foo(time:Long, str:String)

val l = List(Foo(1, "hi"), Foo(2, "a"), Foo(3, "X"))

l.sortWith(_.time > _.time)  // List(Foo(3,X), Foo(2,a), Foo(1,hi))

l.sortBy(- _.time)           // List(Foo(3,X), Foo(2,a), Foo(1,hi))

l.sortBy(_.time)             // List(Foo(1,hi), Foo(2,a), Foo(3,X))

我发现 sortWith 更容易理解。

Answer 6

val list = List(2, 5, 3, 1)
list.sortWith(_>_) -> res14: List[Int] = List(5, 3, 2, 1)
list.sortWith(_<_) -> res14: List[Int] = List(1, 2, 3, 5)

Answer 7

sortBy 有隐式参数 ord 提供排序，

def sortBy [B] (f: (A) ⇒ B)(implicit ord: Ordering[B]): List[A]

因此，我们可以定义自己的 Ordering 对象

scala> implicit object Comp extends Ordering[Int] {
 | override def compare (x: Int, y: Int): Int = y - x
 | }
defined module Comp

List(3,2,5,1,6).sortBy(x => x)
res5: List[Int] = List(6, 5, 3, 2, 1)

Answer 8

如果你想要一个通用方法，你可以在 Scala 3 中使用它；

extension [T, A: Ordering](a: List[T])
  def sortByDesc(f: T => A) = a.sortBy(f)(Ordering[A].reverse)

Answer 9

另一种可能性是，您传递一个可能无法通过 sortWith 直接修改到 Arraybuffer 的函数，例如：

val buf = collection.mutable.ArrayBuffer[Int]()
buf += 3
buf += 9
buf += 1

// the sort function (may be passed through from elsewhere)
def sortFn = (A:Int, B:Int) => { A < B }

// the two ways to sort below
buf.sortWith(sortFn)                        // 1, 3, 9
buf.sortWith((A,B) => { ! sortFn(A,B) })    // 9, 3, 1

Answer 10

这是我的代码；）

val wordCounts = logData.flatMap(line => line.split(" "))
                        .map(word => (word, 1))
                        .reduceByKey((a, b) => a + b)

wordCounts.sortBy(- _._2).collect()

Answer 11

val listOfIntegers = List(5, 1, 2, 4, 3)

listOfIntegers.sortBy(i=>i).reverse