मैं स्केल में सूची [Int] ऑब्जेक्ट्स को कैसे क्रमबद्ध कर सकता हूं?

Question

मैं जो करना चाहता हूं वह स्केल में सूची वस्तुओं को सॉर्ट करना है, सूची में तत्वों को सॉर्ट नहीं करना है। उदाहरण के लिए यदि मेरे पास इन्ट्स की दो सूचियां हैं:

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

मैं उन्हें l1> l2 कहां रखने में सक्षम होना चाहता हूं।

मैंने एक केस क्लास बनाया है जो मुझे इसकी आवश्यकता है लेकिन समस्या यह है कि जब मैं इसका उपयोग करता हूं तो मेरी कोई अन्य विधि काम नहीं करती है। क्या मुझे कक्षा में सभी अन्य तरीकों को लागू करने की ज़रूरत है, जैसे कि flatten, sortWith आदि?

मेरी कक्षा कोड इस तरह दिखता है:

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 
    } 

} 

अब अगर मैं itemsets का एक सरणी बनाने मैं इसे सॉर्ट कर सकते हैं:

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) 

दो तरीकों कि मुझे समस्याओं दे रहे हैं:

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

त्रुटि मैं मिलता है:

+०१२३५१६४१०६

प्रकार मानचित्र की अभिव्यक्ति [कुछ भी नहीं है, इंट] उम्मीद प्रकार मानचित्र के अनुरूप नहीं है [इंट इंट]

और यह एक के लिए:

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

मैं:

प्रतीक को हल नहीं कर सकते sortWith।

क्या कोई तरीका है कि मैं केवल सूची [Int] का विस्तार कर सकता हूं ताकि मैं अन्य विधियों की कार्यक्षमता को खोए बिना सूचियों का संग्रह सॉर्ट कर सकूं?

Answer 1

मानक पुस्तकालय आदेशित वस्तुओं के संग्रह के लिए a lexicographic ordering प्रदान करता है। आप इसे दायरे में रख सकते हैं और आपका काम हो:

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) 

Ordering type class अक्सर में Ordered से अधिक सुविधाजनक है स्काला यह आप अपने कोड बदलने के लिए या बनाए बिना निर्दिष्ट करने का तरीका कुछ मौजूदा प्रकार का आदेश दिया जाना चाहिए की अनुमति देता है एक प्रॉक्सी क्लास जो Ordered[Whatever] तक फैली हुई है, जैसा कि आपने देखा है, बहुत जल्दी गन्दा हो सकता है।