Qual è il modo migliore per invertire l'ordinamento in scala?

Qual è il modo migliore per fare un ordinamento inverso in scala? Immagino che il seguente sia un po 'lento.

list.sortBy(_.size).reverse

Esiste un modo conveniente di usare sortBy ma ottenere un ordinamento inverso? Preferirei non aver bisogno di usare sortWith.

Potrebbe esserci il modo ovvio di cambiare il segno, se si ordina in base a un valore numerico

list.sortBy(- _.size)

Più in generale, l'ordinamento può essere eseguito con il metodo ordinato con un ordinamento implicito, che è possibile rendere esplicito, e l'ordinamento ha un rovescio (non l'elenco rovesciato di seguito).

list.sorted(theOrdering.reverse)

Se l'ordinamento che si desidera invertire è l'ordinamento implicito, è possibile ottenerlo implicitamente [Ordine [A]] (A il tipo su cui si sta ordinando) o Ordine migliore [A]. Sarebbe

list.sorted(Ordering[TheType].reverse)

sortBy è come usare Ordering.by, quindi puoi farlo

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

Forse non è il più breve da scrivere (rispetto al meno) ma l'intento è chiaro

Aggiornare

L'ultima riga non funziona. Per accettare _in Ordering.by(_.size), il compilatore deve sapere su quale tipo stiamo ordinando, in modo che possa digitare _. Potrebbe sembrare che sarebbe il tipo di elemento dell'elenco, ma non è così, come lo è la firma di ordinati def sorted[B >: A](ordering: Ordering[B]). L'ordinamento può essere attivo A, ma anche su qualsiasi antenato di A(è possibile utilizzare byHashCode : Ordering[Any] = Ordering.by(_.hashCode)). E infatti, il fatto che l'elenco sia covariante forza questa firma. Uno può fare

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

ma questo è molto meno piacevole.

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

forse per accorciarlo un po 'di più:

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

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

Facile peasy (almeno in caso di 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)

sortByha un parametro implicito ordche fornisce l'ordinamento

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

quindi, possiamo definire il proprio Orderingoggetto

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)

Entrambi sortWithe sortByhanno una sintassi compatta:

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

Trovo quello con sortWithpiù facile da capire.

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)

Un'altra possibilità nei casi in cui si passa una funzione che potrebbe non essere possibile modificare direttamente in un array Array tramite sortWith ad esempio:

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

questo è il mio codice;)

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

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