scala - स्कैला में सूची में आइटम प्राप्त करें?




(4)

कोष्ठक का प्रयोग करें:

data(2)

लेकिन आप वास्तव में सूचियों के साथ ऐसा नहीं करना चाहते हैं, क्योंकि लिंक्ड सूचियों को समय के लिए समय लगता है। यदि आप किसी संग्रह में अनुक्रमित करना चाहते हैं, तो Vector (अपरिवर्तनीय) या ArrayBuffer ( ArrayBuffer ) या संभवतः Array (जो केवल जावा सरणी है, का उपयोग करें, इसके अलावा आप इसे (i) बजाय (i) में इंडेक्स करते हैं।

दुनिया में कैसे आपको सूचकांक में स्केल में सूची से केवल एक तत्व मिलता है?

मैंने कोशिश की get(i) , और [i] - कुछ भी काम नहीं करता है। Googling केवल सूची में एक तत्व "खोजने" कैसे देता है। लेकिन मैं पहले से ही तत्व की अनुक्रमणिका पता है!

यहां वह कोड है जो संकलित नहीं करता है:

def buildTree(data: List[Data2D]):Node ={
  if(data.length == 1){
      var point:Data2D = data[0]  //Nope - does not work

  }
  return null
}

सूची एपीआई को देखकर मदद नहीं मिलती है, क्योंकि मेरी आंखें बस पार हो जाती हैं।


ब्रांड्स क्यों?

स्कैला में प्रोग्रामिंग प्रोग्राम से उद्धरण यहां दिया गया है।

इस उदाहरण से सचित्र एक और महत्वपूर्ण विचार आपको अंतर्दृष्टि देगा कि स्केल में ब्रांड्स के साथ सरणी का उपयोग क्यों किया जाता है। जावा के मुकाबले स्कैला में कम विशेष मामले हैं। Arrays स्काला में किसी भी अन्य वर्ग की तरह कक्षाओं के उदाहरण हैं। जब आप एक चर के लिए एक या अधिक मानों के आसपास कोष्ठक लागू करते हैं, तो स्कैला कोड को उस चर पर लागू नाम की विधि के आविष्कार में बदल देगा। तो नमस्कार (i) अभिवादन में बदल जाता है Strings.apply (i)। इस प्रकार स्कैला में एक सरणी के तत्व को एक्सेस करना किसी अन्य की तरह एक विधि कॉल है। यह सिद्धांत सरणी तक सीमित नहीं है: किसी ऑब्जेक्ट का किसी भी अनुप्रयोग को ब्रांड्स में कुछ तर्कों के लिए लागू विधि कॉल में बदल दिया जाएगा। बेशक यह केवल तभी संकलित होगा यदि उस प्रकार की वस्तु वास्तव में एक लागू विधि को परिभाषित करती है। तो यह एक विशेष मामला नहीं है; यह एक सामान्य नियम है।

कार्यात्मक प्रोग्रामिंग शैली का उपयोग करके कुछ उदाहरण यहां कुछ तत्व (इस मामले में पहला elem) खींचने के लिए कुछ उदाहरण दिए गए हैं।

  // Create a multdimension Array 
  scala> val a = Array.ofDim[String](2, 3)
  a: Array[Array[String]] = Array(Array(null, null, null), Array(null, null, null))
  scala> a(0) = Array("1","2","3")
  scala> a(1) = Array("4", "5", "6")
  scala> a
  Array[Array[String]] = Array(Array(1, 2, 3), Array(4, 5, 6))
  // 1. paratheses
  scala> a.map(_(0))
  Array[String] = Array(1, 4)
  // 2. apply
  scala> a.map(_.apply(0))
  Array[String] = Array(1, 4)
  // 3. function literal
  scala> a.map(a => a(0))
  Array[String] = Array(1, 4)
  // 4. lift
  scala> a.map(_.lift(0))
  Array[Option[String]] = Array(Some(1), Some(4))
  // 5. head or last 
  scala> a.map(_.head)
  Array[String] = Array(1, 4)

सुरक्षित lift का उपयोग करना lift ताकि यदि आप मौजूद हों तो मूल्य को निकाला जा सकता है और अगर ऐसा नहीं होता तो कृपापूर्वक विफल हो जाता है।

data.lift(2)

यह कोई भी वापस नहीं करेगा यदि सूची उस तत्व को प्रदान करने के लिए पर्याप्त नहीं है, और कुछ (मान) यदि यह है।

scala> val l = List("a", "b", "c")
scala> l.lift(1)
Some("b")
scala> l.lift(5)
None

जब भी आप एक ऐसा ऑपरेशन कर रहे हैं जो इस तरह से असफल हो सकता है तो विकल्प का उपयोग करना बहुत अच्छा होता है और यह सुनिश्चित करने में सहायता के लिए टाइप सिस्टम प्राप्त करें कि आप उस मामले को संभालने में सक्षम हैं जहां तत्व मौजूद नहीं है।

स्पष्टीकरण:

यह काम करता है क्योंकि सूची apply (जो केवल ब्रांड्स के लिए शर्करा, उदाहरण के लिए l(index) ) आंशिक फ़ंक्शन की तरह है जिसे परिभाषित किया जाता है जहां सूची में कोई तत्व होता है। List.lift विधि मूल रूप से एक विकल्प में परिणाम लपेटकर आंशिक apply फ़ंक्शन (एक फ़ंक्शन जिसे केवल कुछ इनपुट के लिए परिभाषित किया जाता है) को सामान्य फ़ंक्शन (किसी भी इनपुट के लिए परिभाषित) में बदल देता है।


// throws a MatchError exception if i isn't found in li
def remove[A](i:A, li:List[A]) = {
   val (head,_::tail) = li.span(i != _)
   head ::: tail
}




scala