list - एक वर्ग और स्कैला में एक सूची के बीच अंतर




scala collections seq (5)

जावा शब्दों में, स्कैला की Seq जावा की List , और स्कैला की List जावा की LinkedList

ध्यान दें कि Seq एक trait , जो जावा के interface के बराबर है, लेकिन आने वाले और आने वाले डिफेंडर विधियों के बराबर है। स्कैला की List एक अमूर्त वर्ग है जिसे Nil और :: द्वारा बढ़ाया गया है, जो List के ठोस कार्यान्वयन हैं।

इसलिए, जहां जावा की List एक interface , स्कैला की List एक कार्यान्वयन है।

इसके अलावा, स्कैला की List अपरिवर्तनीय है, जो LinkedList का मामला नहीं है। असल में, जावा के पास अपरिवर्तनीय संग्रह के बराबर नहीं है (केवल पढ़ने की बात केवल गारंटी देता है कि नई वस्तु को बदला नहीं जा सकता है, लेकिन आप अभी भी पुराने को बदल सकते हैं, और इसलिए, "केवल पढ़ने" एक)।

स्कैला की List संकलक और पुस्तकालयों द्वारा अत्यधिक अनुकूलित है, और यह कार्यात्मक प्रोग्रामिंग में एक मौलिक डेटा प्रकार है। हालांकि, इसमें सीमाएं हैं और यह समानांतर प्रोग्रामिंग के लिए अपर्याप्त है। इन दिनों, Vector List तुलना में बेहतर विकल्प है, लेकिन आदत तोड़ना मुश्किल है।

Seq अनुक्रमों के लिए एक अच्छा सामान्यीकरण है, इसलिए यदि आप इंटरफेस करने के लिए प्रोग्राम करते हैं, तो आपको इसका उपयोग करना चाहिए। ध्यान दें कि वास्तव में उनमें से तीन हैं: collection.Seq , collection.mutable.Seq और collection.immutable.Seq , और यह बाद वाला है जो दायरे में आयात किया गया "डिफ़ॉल्ट" है।

GenSeq और ParSeq भी है। बाद की विधियां समानांतर में चलती हैं, जहां पूर्व Seq और ParSeq दोनों के माता-पिता हैं, एक कोड के समांतरता के लिए उपयुक्त सामान्यीकरण होने पर कोई फर्क नहीं पड़ता। वे दोनों अपेक्षाकृत नए पेश किए गए हैं, इसलिए लोग अभी तक उनका अधिक उपयोग नहीं करते हैं।

मैंने कई उदाहरणों में देखा है कि कभी-कभी एक सेक का उपयोग किया जा रहा है, जबकि दूसरी बार सूची है ...

क्या कोई स्केल प्रकार और जावा से आने वाली सूची के अलावा कोई अंतर है?


Seq एक विशेषता है जो List लागू करता है।

यदि आप अपने कंटेनर को Seq रूप में परिभाषित करते हैं, तो आप किसी भी कंटेनर का उपयोग कर सकते हैं जो Seq विशेषता लागू करता है।

scala> def sumUp(s: Seq[Int]): Int = { s.sum }
sumUp: (s: Seq[Int])Int

scala> sumUp(List(1,2,3))
res41: Int = 6

scala> sumUp(Vector(1,2,3))
res42: Int = 6

scala> sumUp(Seq(1,2,3))
res44: Int = 6

ध्यान दें कि

scala> val a = Seq(1,2,3)
a: Seq[Int] = List(1, 2, 3)

सिर्फ इसके लिए एक छोटा सा हाथ है:

scala> val a: Seq[Int] = List(1,2,3)
a: Seq[Int] = List(1, 2, 3)

यदि कंटेनर प्रकार निर्दिष्ट नहीं है, अंतर्निहित डेटा संरचना List डिफ़ॉल्ट है।


स्कैला में, एक सूची सेक से विरासत में प्राप्त होती है, लेकिन Product लागू करती है; List की उचित परिभाषा यहां दी गई है:

sealed abstract class List[+A] extends AbstractSeq[A] with Product with ...

[नोट: स्केल के बहुत शक्तिशाली संग्रह ढांचे के साथ फिट करने और उपयोग करने के लिए वास्तविक परिभाषा एक और अधिक जटिल है।]


एक Seq एक इटरबल है जिसमें तत्वों का एक निर्धारित क्रम है। अनुक्रम अनुक्रम की लंबाई से 0 तक लेकर अनुक्रमण के लिए एक विधि apply() प्रदान करते हैं। सेक में क्यूई, रेंज, लिस्ट, स्टैक और लिंक्डलिस्ट सहित कई उप-वर्ग हैं।

एक List एक सेक है जिसे एक अपरिवर्तनीय लिंक्ड सूची के रूप में लागू किया जाता है। आखिरी-इन-आउट-आउट (एलआईएफओ) एक्सेस पैटर्न वाले मामलों में इसका सबसे अच्छा उपयोग किया जाता है।

स्कैला एफएक्यू से पूर्ण संग्रह वर्ग पदानुक्रम यहां दिया गया है:


Scala has a lot of crazy features (particularly where implicit parameters are concerned) that look very complicated and academic, but are designed to make things easy to use. The most useful ones get syntactic sugar (like [A <% B] which means that an object of type A has an implicit conversion to an object of type B) and a well-documented explanation of what they do. But most of the time, as a client of these libraries you can ignore the implicit parameters and trust them to do the right thing.







list scala collections seq