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

Question

在scala中进行反向排序的最佳方法是什么？我想以下有点慢.

list.sortBy(_.size).reverse

有没有一种方便的方式使用sortBy但得到反向排序？我宁愿不需要使用sortWith.

Answer 1

如果按某个数值排序,可能会有明显的方法来更改符号

list.sortBy(- _.size)

更一般地说,排序可以通过使用隐式排序进行排序的方法来完成,您可以将其显式化,并且排序具有反向(不是下面的列表反向)您可以执行

list.sorted(theOrdering.reverse)

如果你要反转的顺序是隐式排序,你可以通过隐式[Ordering [A]](你要订购的类型)或更好的订购[A]来获得它.那就是

list.sorted(Ordering[TheType].reverse)

sortBy就像使用Ordering.by,所以你可以这样做

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

也许不是最短的写(与减去相比)但意图很清楚

更新

最后一行不起作用.要接受_in Ordering.by(_.size),编译器需要知道我们要订购哪种类型,以便它可以键入_.看起来这可能是列表元素的类型,但事实并非如此,因为sort的签名是 def sorted[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

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 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

双方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更容易理解.