समय जटिलता

Question

स्काला संस्करण 2.9 एक आसान कनवर्टर java.util.List और स्काला के डेटा संरचनाओं के लिए अन्य संग्रह से कन्वर्ट करने के लिए कुछ इस तरह लिख कर वहां मौजूद के साथ शुरू क्योंकि यह मौजूदा जावा कोड के साथ बातचीत करते समय स्कैला के फायदे का फायदा उठाने की अनुमति देता है।

हालांकि, मैं इसमें शामिल समय और स्थान जटिलता के बारे में अनिश्चित हूँ और आधिकारिक दस्तावेज में कुछ भी नहीं मिला, इसलिए, निम्नलिखित प्रश्न:

मैं कहां से जटिलता के बारे में जानकारी प्राप्त कर सकते हैं (समय और स्थान) की JavaConverters?

Answer 1

विभिन्न JavaConverters कक्षाएं मूल जावा संग्रह (underlying) को लपेटने और स्कैला इंटरफ़ेस प्रदान करने के लिए Adapter पैटर्न का उपयोग कर रही हैं। इस प्रकार कनवर्ट किए गए संग्रहों को परिवर्तित और एक्सेस करने में समय (O(1)) केवल मामूली ओवरहेड पेश करता है।

case class JListWrapper[A](val underlying : java.util.List[A]) extends mutable.Buffer[A] { 
    def length = underlying.size 
    override def isEmpty = underlying.isEmpty 
    override def iterator : Iterator[A] = underlying.iterator 
    def apply(i : Int) = underlying.get(i) 
    def update(i : Int, elem : A) = underlying.set(i, elem) 
    def +=:(elem : A) = { underlying.subList(0, 0).add(elem) ; this } 
    def +=(elem : A): this.type = { underlying.add(elem); this } 
    def insertAll(i : Int, elems : Traversable[A]) = { val ins = underlying.subList(0, i) ; elems.seq.foreach(ins.add(_)) } 
    def remove(i : Int) = underlying.remove(i) 
    def clear = underlying.clear 
    def result = this 
} 

भी ध्यान रखें कि जावा के लिए स्काला के जावा संग्रह परिवर्तित करने और फिर वापस पैदावार मूल संग्रह, नहीं डबल आवरण:

उदाहरण के लिए इस JListWrapper के पूर्ण स्रोत कोड है।