म्यूटेबल और अपरिवर्तनीय ListMaps के पास स्कैला में अलग-अलग ऑर्डर क्यों हैं?

Question

सूची मैप स्टोर का अपरिवर्तनीय संस्करण आरोही क्रम में क्यों है, जबकि उत्परिवर्तनीय संस्करण अवरोही क्रम में संग्रहीत करता है?

यहाँ एक परीक्षण है कि आप उपयोग कर सकते हैं अगर आप मिल गया है scalatest-1.6.1.jar और JUnit-4.9.jar

@Test def StackoverflowQuestion() 
    { 
    val map = Map("A" -> 5, "B" -> 12, "C" -> 2, "D" -> 9, "E" -> 18) 
    val sortedIMMUTABLEMap = collection.immutable.ListMap[String, Int](map.toList.sortBy[Int](_._2): _*) 
    println("head : " + sortedIMMUTABLEMap.head._2) 
    println("last : " + sortedIMMUTABLEMap.last._2) 
    sortedIMMUTABLEMap.foreach(X => println(X)) 
    assert(sortedIMMUTABLEMap.head._2 < sortedIMMUTABLEMap.last._2) 

    val sortedMUTABLEMap = collection.mutable.ListMap[String, Int](map.toList.sortBy[Int](_._2): _*) 
    println("head : " + sortedMUTABLEMap.head._2) 
    println("last : " + sortedMUTABLEMap.last._2) 
    sortedMUTABLEMap.foreach(X => println(X)) 
    assert(sortedMUTABLEMap.head._2 > sortedMUTABLEMap.last._2) 
    } 

यहाँ पासिंग परीक्षण के उत्पादन:

head : 2 
last : 18 
(C,2) 
(A,5) 
(D,9) 
(B,12) 
(E,18) 
head : 18 
last : 2 
(E,18) 
(B,12) 
(D,9) 
(A,5) 
(C,2) 

Answer 1

लक्षणों के सरल किया जा सकता:

scala> collection.mutable.ListMap(1 -> "one", 2 -> "two").foreach(println) 
(2,two) 
(1,one) 

scala> collection.immutable.ListMap(1 -> "one", 2 -> "two").foreach(println) 
(1,one) 
(2,two) 

"छँटाई" अपने कोड में इस मुद्दे के कोर,करने के लिए अपने कॉल नहीं हैListMap.apply सहयोगी ऑब्जेक्ट से कॉल का उपयोग कर रहा है जो एक परिवर्तनीय या अपरिवर्तनीय सूची द्वारा समर्थित एक सूची मानचित्र बनाता है। नियम यह है कि सम्मिलन आदेश संरक्षित किया जाएगा।

अंतर यह प्रतीत होता है कि उत्परिवर्तनीय सूची अपरिवर्तनीय सूची द्वारा समर्थित है और सामने डालें। इसलिए यही कारण है कि आप LIFO व्यवहार प्राप्त करते हैं। मैं अभी भी अपरिवर्तनीय व्यक्ति को देख रहा हूं लेकिन मुझे लगता है कि आवेषण प्रभावी रूप से पीछे हैं। संपादित करें, मैं अपना दिमाग बदल रहा हूं: डालने शायद संभवतः सामने हैं, लेकिन ऐसा लगता है कि immutable.ListMap.iterator विधि लौटाए गए पुनरावर्तक पर toList.reverseIterator के साथ परिणाम को उलट करने का निर्णय लेती है। मुझे लगता है कि इसे मेलिंग सूची में लाने लायक है।

क्या प्रलेखन बेहतर हो सकता है? निश्चित रूप से। क्या दर्द है? वास्तव में नहीं, मैं इसे होने नहीं देता। यदि प्रलेखन अपूर्ण है, तो व्यवहार का परीक्षण करना या किसी अन्य बनाम संरचना चुनने से पहले स्रोत पर देखना बुद्धिमानी है।

असल में, दर्द हो सकता है यदि स्कैला टीम बाद में व्यवहार को बदलने का फैसला करती है और महसूस करती है कि वे व्यवहार प्रभावी ढंग से अनियंत्रित हैं और कोई अनुबंध नहीं है।

---

आपके उपयोग के मामले के समाधान के लिए टिप्पणी में बताया गया है, कहते हैं कि तुम एक नक्शे में स्ट्रिंग आवृत्ति गिनती एकत्र किया है (परिवर्तनशील या अपरिवर्तनीय):

val map = Map("A" -> 5, "B" -> 12, "C" -> 2, "D" -> 9, "E" -> 18, "B" -> 5) 

के बाद से आप केवल एक बार सॉर्ट करने के लिए की जरूरत है अंत में, आप एक seq और फिर प्रकार के नक्शे से tuples परिवर्तित कर सकते हैं:

map.toSeq.sortBy(_._2) 
// Seq[(java.lang.String, Int)] = ArrayBuffer((C,2), (A,5), (B,5), (D,9), (E,18)) 

Answer 2

मैं यह न तो ListMap दावे देखने के रूप में एक क्रमबद्ध नक्शा, सिर्फ एक नक्शा होना करने के लिए एक सूची के साथ लागू किया गया। असल में मैं उनके अनुबंध में कुछ भी नहीं देखता जो सम्मिलन आदेश को संरक्षित करने के बारे में कुछ भी कहता है।

स्कैला में प्रोग्रामिंग बताती है कि शुरुआती तत्वों तक पहुंचने की अधिक संभावना होने पर ListMap का उपयोग किया जा सकता है, लेकिन अन्यथा इसका मानचित्र पर थोड़ा लाभ नहीं होता है।

Answer 3

आदेश पर कोई उम्मीद नहीं बनाएं, इसे घोषित नहीं किया गया है और यह स्कैला संस्करणों के बीच अलग-अलग होगा।

उदाहरण के लिए:

import scala.collection.mutable.{ListMap => MutableListMap} 

MutableListMap("A" -> 5, "B" -> 12, "C" -> 2, "D" -> 9, "E" -> 18).foreach(println) 

2,9 पर।1 देता है: (ई, 18) (डी, 9) (सी, 2) (बी, 12) (ए, 5)

लेकिन 2.11.6 पर देता है: (ई, 18) (सी, 2) (ए, 5) (बी, 12) (डी, 9)