स्काला में समूहबाई सूची सूची के ऑर्डर को क्यों बदलता है?

Question

इस कोड को एक स्काला वर्कशीट से है:

case class E(a: Int, b: String) 

val l = List(
    E(1, "One"), 
    E(1, "Another One"), 
    E(2, "Two"), 
    E(2, "Another Two"), 
    E(3, "Three") 
) 

l.groupBy(x => x.a)        
// res11: scala.collection.immutable.Map[Int,List[com.dci.ScratchPatch.E]] = 
// Map(
//  2 -> List(E(2,Two), E(2,Another Two)), 
//  1 -> List(E(1,One), E(1,Another One)), 
//  3 -> List(E(3,Three)) 
// ) 

आपको लगता है कि GroupBy मानचित्र दिखाए, लेकिन तत्वों के आदेश अब जिस तरह से वे पहले थे करने के लिए अलग-अलग हैं कि नोटिस जाएगा। ऐसा कोई विचार क्यों होता है, और इससे बचने का सबसे अच्छा तरीका क्या है?

Answer 1

जब तक आप विशेष रूप से सॉर्टेड मैप के उप प्रकार का उपयोग नहीं करते हैं, तो एक नक्शा (एक सेट की तरह) हमेशा एक अनिर्दिष्ट क्रम में होता है। चूंकि "groupBy" सॉर्ट किए गए मैप को वापस नहीं करता है, लेकिन केवल एक सामान्य अपरिवर्तनीय है। मैप और CanBuildFrom तंत्र का भी उपयोग नहीं करता है, मुझे लगता है कि आप यहां कुछ भी नहीं कर सकते हैं।

आप इसी विषय के उत्तर में इस विषय पर और अधिक पा सकते हैं, उदा। here।

संपादित करें:

आप एक SortedMap (अपने कुंजी द्वारा आदेश दिया) के लिए नक्शे afterwarts परिवर्तित करना चाहते हैं, तो आप SortedMap(l.groupBy(_.a).toSeq:_*) (import scala.collection.immutable.SortedMap के साथ) कर सकते हैं। ...toSeq.sortWith(...).toMap मत करें क्योंकि यह परिणामस्वरूप मानचित्र में ऑर्डरिंग की गारंटी नहीं देगा।

Answer 2

डेटाबेस रिकॉर्ड से निपटने के दौरान मैं हर समय इसमें दौड़ता हूं। डेटाबेस उन्हें कुछ कुंजी द्वारा टाइप करता है लेकिन फिर समूह द्वारा इसे अनदेखा करता है!

class PimpedSeq[A](s: Seq[A]) { 

    /** 
    * Group elements of the sequence that have consecutive keys that are equal. 
    * 
    * Use case: 
    *  val lst = SQL("SELECT * FROM a LEFT JOIN b ORDER BY a.key") 
    *  val grp = lst.groupConsecutiveKeys(a.getKey) 
    */ 
    def groupConsecutiveKeys[K](f: (A) => K): Seq[(K, List[A])] = { 
    this.s.foldRight(List[(K, List[A])]())((item: A, res: List[(K, List[A])]) => 
     res match { 
     case Nil => List((f(item), List(item))) 
     case (k, kLst) :: tail if k == f(item) => (k, item :: kLst) :: tail 
     case _ => (f(item), List(item)) :: res 
     }) 
    } 
} 

object PimpedSeq { 
    implicit def seq2PimpedSeq[A](s: Seq[A]) = new PimpedSeq(s) 
} 

इसका इस्तेमाल करने के लिए::

import util.PimpedSeq._ // implicit conversion  
val dbRecords = db.getTheRecordsOrderedBy 
val groups = dbRecords.groupConsecutiveKeys(r => r.getKey)