Wie kann ich List [Int] Objekte in Scala sortieren?

Question

Was ich tun möchte, ist List Objekte in scala zu sortieren, nicht die Elemente in der Liste zu sortieren. Zum Beispiel Wenn ich zwei Listen von Ints:

val l1 = List(1, 2, 3, 7) 
val l2 = List(1, 2, 3, 4, 10) 

ich sie in der Lage sein, um in dem l1 zu setzen> l2.

Ich habe eine Fall-Klasse erstellt, die tut, was ich brauche, aber das Problem ist, dass, wenn ich es benutze keine meiner anderen Methoden arbeiten. Muss ich alle anderen Methoden in der Klasse implementieren, d. H. Flatten, sortieren, etc?

Meine Klasse Code sieht wie folgt aus:

class ItemSet(itemSet: List[Int]) extends Ordered[ItemSet] { 

    val iSet: List[Int] = itemSet 

    def compare(that: ItemSet) = { 

    val thisSize = this.iSet.size 
    val thatSize = that.iSet.size 
    val hint = List(thisSize, thatSize).min 
    var result = 0 
    var loop = 0 

    val ths = this.iSet.toArray 
    val tht = that.iSet.toArray 

    while (loop < hint && result == 0) { 
     result = ths(loop).compare(tht(loop)) 
     loop += 1 
    } 
    if (loop == hint && result == 0 && thisSize != thatSize) { 
     thisSize.compare(thatSize) 
    } else 
     result 
    } 

} 

Nun, wenn ich ein Array von itemsets erstellen Ich kann es sortieren:

val is1 = new ItemSet(List(1, 2, 5, 8)) 
val is2 = new ItemSet(List(1, 2, 5, 6)) 
val is3 = new ItemSet(List(1, 2, 3, 7, 10)) 

Array(is1, is2, is3).sorted.foreach(i => println(i.iSet)) 

scala> List(1, 2, 3, 7, 10) 
List(1, 2, 5, 6) 
List(1, 2, 5, 8) 

Die beiden Methoden, die mir Probleme geben, sind:

def itemFrequencies(transDB: Array[ItemSet]): Map[Int, Int] = transDB.flatten.groupBy(x => x).mapValues(_.size) 

die Fehler, die ich bekommen ist:

Expression von Typ-Map [Nothing, Int] entspricht nicht erwarteten Typ Map [Int, Int]

und für diese ein:

def sortListAscFreq(transDB: Array[ItemSet], itemFreq: Map[Int, Int]): Array[List[Int]] = { 
    for (l <- transDB) yield 
    l.sortWith(itemFreq(_) < itemFreq(_)) 
} 

ich:

nicht Symbol auflösen kann sortWith.

Kann ich List [Int] einfach so erweitern, dass ich eine Sammlung von Listen sortieren kann, ohne die Funktionalität anderer Methoden zu verlieren?

Answer 1

Die Standardbibliothek bietet a lexicographic ordering für Sammlungen von geordneten Dingen. Sie können es in Rahmen setzen und fertig:

scala> import scala.math.Ordering.Implicits._ 
import scala.math.Ordering.Implicits._ 

scala> val is1 = List(1, 2, 5, 8) 
is1: List[Int] = List(1, 2, 5, 8) 

scala> val is2 = List(1, 2, 5, 6) 
is2: List[Int] = List(1, 2, 5, 6) 

scala> val is3 = List(1, 2, 3, 7, 10) 
is3: List[Int] = List(1, 2, 3, 7, 10) 

scala> Array(is1, is2, is3).sorted foreach println 
List(1, 2, 3, 7, 10) 
List(1, 2, 5, 6) 
List(1, 2, 5, 8) 

Die Ordering type class ist oft bequemer als Ordered in Scala-it können Sie festlegen, wie einige bestehende Typ sollte, ohne bestellt werden, um seinen Code zu ändern oder erstellen Eine Proxy-Klasse, die Ordered[Whatever] erweitert, die, wie Sie gesehen haben, kann sehr schnell chaotisch werden.