it-swarm-id.com

Apa cara terbaik untuk membalikkan sortir dalam scala?

Apa cara terbaik untuk melakukan invers sort in scala? Saya membayangkan yang berikut ini agak lambat.

list.sortBy(_.size).reverse

Apakah ada cara mudah menggunakan sortBy tetapi mendapatkan sortir terbalik? Saya lebih suka tidak perlu menggunakan sortWith.

126
schmmd

Mungkin ada cara yang jelas untuk mengubah tanda, jika Anda mengurutkan berdasarkan beberapa nilai numerik

list.sortBy(- _.size)

Secara lebih umum, pengurutan dapat dilakukan dengan metode yang diurutkan dengan Pemesanan implisit, yang dapat Anda buat secara eksplisit, dan Pemesanan memiliki kebalikan (bukan daftar terbalik di bawah) Anda dapat melakukan

list.sorted(theOrdering.reverse)

Jika pemesanan yang ingin Anda balikkan adalah pemesanan tersirat, Anda bisa mendapatkannya dengan [Memesan [A]] secara tersirat (tipe yang Anda pesan) atau Memesan [A] yang lebih baik. Itu akan menjadi

list.sorted(Ordering[TheType].reverse)

sortBy seperti menggunakan Ordering.by, jadi Anda bisa melakukannya

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

Mungkin bukan yang terpendek untuk menulis (dibandingkan dengan minus) tetapi niat jelas

Perbarui

Baris terakhir tidak berfungsi. Untuk menerima _ dalam Ordering.by(_.size), kompiler perlu mengetahui jenis yang kami pesan, sehingga ia dapat mengetik _ _. Tampaknya itu adalah tipe elemen dari daftar, tetapi tidak demikian, karena tanda tangan yang diurutkan adalah def sorted[B >: A](ordering: Ordering[B]). Urutan mungkin pada A, tetapi juga pada leluhur A (Anda dapat menggunakan byHashCode : Ordering[Any] = Ordering.by(_.hashCode)). Dan memang, fakta bahwa daftar itu kovarian memaksa tanda tangan ini. Seseorang bisa melakukannya

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

tapi ini jauh lebih tidak menyenangkan.

225
Didier Dupont
list.sortBy(_.size)(Ordering[Int].reverse)
103
incrop

mungkin untuk mempersingkat lebih sedikit:

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

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

Peasy mudah (setidaknya dalam kasus 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)
19
om-nom-nom

sortBy memiliki parameter implisit ord yang menyediakan pemesanan

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

jadi, kita dapat mendefinisikan objek Ordering sendiri

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)
9
4e6
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)
8
Tomek Kozlowski

Baik sortWith dan sortBy memiliki sintaks yang kompak:

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

Saya menemukan yang dengan sortWith lebih mudah dimengerti.

7
Jus12

Kemungkinan lain dalam kasus di mana Anda melewatkan fungsi yang mungkin tidak dapat Anda modifikasi secara langsung ke Arraybuffer via sortWith misalnya:

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

ini kode saya;)

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

wordCounts.sortBy(- _._2).collect()
0
Anxo P