स्काला कलेक्शंस - क्विक गाइड

स्काला के पास संग्रह पुस्तकालय का एक समृद्ध समूह है। संग्रह चीजों का कंटेनर है। उन कंटेनरों को अनुक्रमित किया जा सकता है, सूची, टपल, विकल्प, मानचित्र, आदि जैसी वस्तुओं के रैखिक सेट। संग्रह में तत्वों की एक मनमानी संख्या हो सकती है या शून्य या एक तत्व (जैसे, विकल्प) के लिए बाध्य हो सकती है।

संग्रह हो सकते हैं strict या lazy। आलसी संग्रह में ऐसे तत्व होते हैं जो तब तक मेमोरी का उपभोग नहीं कर सकते हैं जब तक वे एक्सेस न हों, जैसेRanges। इसके अतिरिक्त, संग्रह हो सकता हैmutable (संदर्भ की सामग्री बदल सकती है) या immutable(एक संदर्भ को संदर्भित करता है कि बात कभी नहीं बदला है)। ध्यान दें कि अपरिवर्तनीय संग्रह में उत्परिवर्तनीय आइटम हो सकते हैं।

कुछ समस्याओं के लिए, परस्पर संग्रह बेहतर काम करते हैं, और दूसरों के लिए, अपरिवर्तनीय संग्रह बेहतर काम करते हैं। जब संदेह होता है, तो एक अपरिवर्तनीय संग्रह के साथ शुरू करना और बाद में इसे बदलना बेहतर होता है, यदि आपको परस्पर योग्य लोगों की आवश्यकता होती है।

यह अध्याय सबसे अधिक उपयोग किए जाने वाले संग्रह प्रकारों पर प्रकाश फेंकता है और उन संग्रहों पर सबसे अधिक बार उपयोग किए जाने वाले संचालन।

अनु क्रमांक	विवरण के साथ संग्रह
1	Scala Lists स्काला की सूची [T] टाइप T की एक लिंक की गई सूची है।
2	Scala Sets एक सेट एक ही प्रकार के जोड़ीदार विभिन्न तत्वों का एक संग्रह है।
3	Scala Maps एक मानचित्र कुंजी / मूल्य जोड़े का एक संग्रह है। किसी भी मूल्य को उसकी कुंजी के आधार पर प्राप्त किया जा सकता है।
4	Scala Tuples एक सरणी या सूची के विपरीत, एक ट्यूल अलग-अलग प्रकार की वस्तुओं को पकड़ सकता है।
5	Scala Options विकल्प [टी] किसी दिए गए प्रकार के शून्य या एक तत्व के लिए एक कंटेनर प्रदान करता है।
6	Scala Iterators एक पुनरावृत्ति एक संग्रह नहीं है, बल्कि संग्रह के तत्वों को एक-एक करके एक्सेस करने का तरीका है।

Scala को किसी भी UNIX फ्लेवर्ड या विंडोज बेस्ड सिस्टम पर इंस्टॉल किया जा सकता है। इससे पहले कि आप अपनी मशीन पर स्कैला स्थापित करना शुरू करें, आपके पास जावा 1.8 या अधिक आपके कंप्यूटर पर स्थापित होना चाहिए।

स्केल स्थापित करने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: अपने जावा इंस्टॉलेशन को सत्यापित करें

सबसे पहले, आपको अपने सिस्टम पर जावा सॉफ्टवेयर डेवलपमेंट किट (एसडीके) इंस्टॉल करना होगा। इसे सत्यापित करने के लिए, आप जिस प्लेटफ़ॉर्म पर काम कर रहे हैं, उसके आधार पर निम्नलिखित दो कमांड्स में से किसी को निष्पादित करें।

यदि जावा इंस्टॉलेशन ठीक से किया गया है, तो यह आपके जावा इंस्टॉलेशन के वर्तमान संस्करण और विनिर्देश को प्रदर्शित करेगा। निम्न तालिका में एक नमूना आउटपुट दिया गया है।

मंच	आदेश	नमूना आउटपुट
खिड़कियाँ	कमांड कंसोल खोलें और टाइप करें - \>java -version	जावा संस्करण "1.8.0_31" जावा (टीएम) एसई रन टाइम पर्यावरण (1.8.0_31-b31 का निर्माण) जावा हॉटस्पॉट (टीएम) 64-बिट सर्वर VM (बिल्ड 25.31-b07, मिश्रित मोड)
लिनक्स	ओपन कमांड टर्मिनल और प्रकार - $java -version	जावा संस्करण "1.8.0_31" ओपन JDK रनटाइम एनवायरनमेंट (rhel-2.8.10.4.el6_4-x86_64) ओपन JDK 64-बिट सर्वर VM (बिल्ड 25.31-b07, मिश्रित मोड)

हम मानते हैं कि इस ट्यूटोरियल के पाठकों के पास अपने सिस्टम पर जावा एसडीके संस्करण 1.8.0_31 है।

यदि आपके पास जावा एसडीके नहीं है, तो इसका वर्तमान संस्करण डाउनलोड करें https://www.oracle.com/technetwork/java/javase/downloads/index.html और इसे स्थापित करें।

चरण 2: अपना जावा वातावरण सेट करें

वातावरण चर JAVA_HOME को आधार निर्देशिका स्थान पर इंगित करने के लिए सेट करें जहाँ जावा आपकी मशीन पर स्थापित है। उदाहरण के लिए,

अनु क्रमांक	मंच और विवरण
1	Windows JAVA_HOME को C: \ ProgramFiles \ java \ jdk1.8.0_31 पर सेट करें
2	Linux निर्यात JAVA_HOME = / usr / स्थानीय / जावा-वर्तमान

जावा कंपाइलर स्थान का पूरा पथ सिस्टम पथ में जोड़ें।

अनु क्रमांक	मंच और विवरण
1	Windows स्ट्रिंग "C: \ Program Files \ Java \ jdk1.8.0_31 \ bin" सिस्टम चर पथ के अंत में जोड़ें।
2	Linux निर्यात पाथ = $ पाथ: $ जाव_होम / बिन /

आदेश निष्पादित करें java -version ऊपर बताए अनुसार कमांड प्रॉम्प्ट से।

चरण 3: स्कैला स्थापित करें

आप Scala को www.scala-lang.org/downloads से डाउनलोड कर सकते हैं । इस ट्यूटोरियल को लिखने के समय, मैंने 'scala-2.13.1-installer.jar' डाउनलोड किया। सुनिश्चित करें कि आगे बढ़ने के लिए आपके पास विशेषाधिकार है। अब, कमांड प्रॉम्प्ट पर निम्नलिखित कमांड निष्पादित करें -

मंच	कमांड और आउटपुट	विवरण
खिड़कियाँ	\> जावा -जर स्केला-२.१३.१-इंस्टॉलर.जर \>	यह कमांड एक इंस्टॉलेशन विज़ार्ड प्रदर्शित करेगा, जो आपको अपनी विंडोज़ मशीन पर स्केल स्थापित करने के लिए मार्गदर्शन करेगा। स्थापना के दौरान, यह लाइसेंस समझौते के लिए पूछेगा, बस इसे स्वीकार करें और आगे यह एक रास्ता पूछेगा जहां स्काला स्थापित किया जाएगा। मैंने डिफ़ॉल्ट दिए गए पथ "C: \ Program Files \ Scala" का चयन किया , आप अपनी सुविधा के अनुसार उपयुक्त पथ का चयन कर सकते हैं।
लिनक्स	Command - $ जावा -जर स्केला -२.१३.१-इंस्टॉलर.जर Output - Scala 2.13.1 की स्थापना में आपका स्वागत है! मुखपृष्ठ यहां है - http://Scala-lang.org/ जारी रखने के लिए 1 दबाएं, 2 छोड़ें, 3 को फिर से देखें 1 ................................................ [अनपैक करना शुरू कर रहा है] [प्रोसेसिंग पैकेज: सॉफ्टवेयर पैकेज इंस्टालेशन (1/1)] [अनपैकिंग समाप्त] [कंसोल इंस्टॉलेशन किया गया]	स्थापना के दौरान, यह लाइसेंस समझौते के लिए पूछेगा, इसे टाइप 1 स्वीकार करने के लिए और यह एक रास्ता पूछेगा जहां स्काला स्थापित किया जाएगा। मैंने प्रवेश किया / usr / लोकल / शेयर, आप अपनी सुविधा के अनुसार उपयुक्त पथ का चयन कर सकते हैं।

अंत में, एक नया कमांड प्रॉम्प्ट खोलें और टाइप करें Scala -versionऔर Enter दबाएं। आपको निम्नलिखित देखना चाहिए -

मंच	आदेश	उत्पादन
खिड़कियाँ	\ _ scala -version	स्केल कोड रनर संस्करण 2.13.1 - कॉपीराइट 2002-2019, LAMP / EPFL और लाइटबेंड, इंक।
लिनक्स	$ scala -version	स्केल कोड रनर संस्करण 2.13.1 - कॉपीराइट 2002-2019, LAMP / EPFL और लाइटबेंड, इंकट्यूट

स्काला डेटा संरचना प्रदान करता है array, जो एक ही प्रकार के तत्वों के एक निश्चित आकार के अनुक्रमिक संग्रह को संग्रहीत करता है। एक सरणी का उपयोग डेटा के संग्रह को संग्रहीत करने के लिए किया जाता है, लेकिन एक सरणी के एक ही प्रकार के संग्रह के रूप में सरणी के बारे में सोचना अक्सर अधिक उपयोगी होता है।

नंबर चर, नंबर 1, ... और नंबर 99 जैसे अलग-अलग चर घोषित करने के बजाय, आप एक सरणी चर जैसे संख्याओं की घोषणा करते हैं और संख्याओं का उपयोग करते हैं [0], संख्याओं [1] और ..., संख्याओं [99] का प्रतिनिधित्व करने के लिए। अलग-अलग चर। यह ट्यूटोरियल ऐरे वेरिएबल्स को घोषित करने, एरेज़ बनाने और इंडेक्सेड वेरिएबल्स का उपयोग करके एरेज़ को प्रोसेस करने का तरीका बताता है। किसी सरणी के पहले तत्व का सूचकांक संख्या शून्य है और अंतिम तत्व का सूचकांक तत्वों की कुल संख्या है।

ऐरे वेरिएबल की घोषणा

किसी प्रोग्राम में एरे का उपयोग करने के लिए, आपको ऐरे के संदर्भ के लिए एक वैरिएबल की घोषणा करनी चाहिए और आपको उस प्रकार के ऐरे को निर्दिष्ट करना होगा जिसे वेरिएबल रेफर कर सकता है।

सरणी चर घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

var z:Array[String] = new Array[String](3)

or

var z = new Array[String](3)

यहां, z को स्ट्रिंग्स की एक सरणी के रूप में घोषित किया गया है जो तीन तत्वों तक हो सकती है। मूल्यों को व्यक्तिगत तत्वों को सौंपा जा सकता है या व्यक्तिगत तत्वों तक पहुंच प्राप्त की जा सकती है, यह निम्नलिखित जैसे आदेशों का उपयोग करके किया जा सकता है -

आदेश

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

यहां, अंतिम उदाहरण से पता चलता है कि सामान्य रूप से सूचकांक कोई भी अभिव्यक्ति हो सकती है जो एक संपूर्ण संख्या प्राप्त करती है। एक सरणी को परिभाषित करने का एक और तरीका है -

var z = Array("Zara", "Nuha", "Ayan")

निम्नलिखित चित्र एक सरणी का प्रतिनिधित्व करता है myList। यहाँ,myList दस दोहरे मान रखता है और सूचकांक 0 से 9 तक हैं।

प्रसंस्करण

सरणी तत्वों को संसाधित करते समय, हम अक्सर लूप कंटोल संरचनाओं का उपयोग करते हैं क्योंकि एक सरणी में सभी तत्व एक ही प्रकार के होते हैं और सरणी का आकार ज्ञात होता है।

नीचे एक उदाहरण दिखाया गया है कि कैसे बनायें, आरंभ करें और प्रक्रिया करें -

उदाहरण

object Demo {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // Print all the array elements
      for ( x <- myList ) {
         println( x )
      }
      // Summing all elements
      var total = 0.0;
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Total is " + total);
      // Finding the largest element
      var max = myList(0);
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      println("Max is " + max);
   }
}

में उपरोक्त कार्यक्रम सहेजें Demo.scala। इस प्रोग्राम को संकलित करने और निष्पादित करने के लिए निम्न कमांड का उपयोग किया जाता है।

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

स्काला विभिन्न सरणी परिचालनों का सीधे समर्थन नहीं करता है और किसी भी आयाम में सरणियों को संसाधित करने के लिए विभिन्न तरीके प्रदान करता है। यदि आप विभिन्न तरीकों का उपयोग करना चाहते हैं तो आयात करना आवश्यक हैArray._ पैकेज।

ऐसी कई स्थितियाँ हैं जहाँ आपको बहुआयामी सरणियों को परिभाषित करने और उनका उपयोग करने की आवश्यकता होगी (जैसे, सरणियाँ जिनके तत्व सरणियाँ हैं)। उदाहरण के लिए, मैट्रिसेस और टेबल संरचनाओं के उदाहरण हैं जिन्हें दो-आयामी सरणियों के रूप में महसूस किया जा सकता है।

निम्नलिखित एक दो आयामी सरणी को परिभाषित करने का उदाहरण है -

var myMatrix = ofDim[Int](3,3)

यह एक ऐसा सरणी है जिसमें तीन तत्व होते हैं जिसमें प्रत्येक पूर्णांक का एक सरणी होता है जिसमें तीन तत्व होते हैं।

बहुआयामी सरणी को संसाधित करने के लिए निम्न उदाहरण प्रोग्राम का प्रयास करें -

उदाहरण

import Array._
object Demo {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      // build a matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      // Print two dimensional array
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

0 1 2
0 1 2
0 1 2

किसी श्रेणी में बढ़ते पूर्णांक के अनुक्रम वाले सरणी को उत्पन्न करने के लिए रेंज () विधि का उपयोग। आप अनुक्रम बनाने के लिए चरण के रूप में अंतिम तर्क का उपयोग कर सकते हैं; यदि आप अंतिम तर्क का उपयोग नहीं करते हैं, तो चरण 1 माना जाएगा।

आइए हम एक अरेंजमेंट ऑफ़ रेंज (10, 20, 2) बनाने का एक उदाहरण लेते हैं: इसका मतलब है कि 10 और 20 और रेंज फ़र्क के बीच के तत्वों के साथ एक ऐरे बनाना। एरे में तत्व 10, 12, 14, 16 और 18 हैं ।

एक और उदाहरण: रेंज (10, 20)। यहाँ श्रेणी अंतर को डिफ़ॉल्ट रूप से नहीं दिया गया है क्योंकि यह 1 तत्व मानता है। यह श्रेणी अंतर के साथ 10 और 20 के बीच तत्वों के साथ एक सरणी बनाता है। सरणी में तत्व 10, 11, 12, 13, ..., और 19 हैं।

निम्न उदाहरण कार्यक्रम दिखाता है कि श्रेणियों के साथ एक सरणी कैसे बनाई जाए।

उदाहरण

import Array._
object Demo {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)
      // Print all the array elements
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

स्काला डेटा संरचना प्रदान करता है ArrayBuffer, जो प्रारंभिक आकार छोटा होने पर आकार बदल सकता है। चूंकि सरणी ठीक आकार की है और सरणी में अधिक तत्वों को नहीं रखा जा सकता है, ArrayBuffer सरणी का एक विकल्प है जहां आकार लचीला है।

आंतरिक रूप से ArrayBuffer तत्वों को संग्रहीत करने के लिए वर्तमान आकार की एक सरणी रखता है। जब कोई नया तत्व जोड़ा जाता है, तो आकार की जाँच की जाती है। यदि अंतर्निहित सरणी भरी हुई है तो एक नया बड़ा सरणी बनाया जाता है और सभी तत्वों को बड़े सरणी में कॉपी किया जाता है।

एरिकबफरर वेरिएबल्स की घोषणा

ArrayBuffer वैरिएबल घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

var z = ArrayBuffer[String]()

यहां, Z को स्ट्रिंग्स के एक सरणी-बफर के रूप में घोषित किया गया है जो शुरू में खाली है। निम्नलिखित जैसे आदेशों का उपयोग करके मूल्यों को जोड़ा जा सकता है -

आदेश

z += "Zara";
z += "Nuha";
z += "Ayan";

प्रसंस्करण ArrayBuffer

नीचे ArrayBuffer बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.mutable.ArrayBuffer 
object Demo {
   def main(args: Array[String]) = {
      var myList = ArrayBuffer("Zara","Nuha","Ayan")
      println(myList);
      // Add an element
      myList += "Welcome";
      // Add two element
      myList += ("To", "Tutorialspoint");
      println(myList);
      // Remove an element
      myList -= "Welcome";
      // print second element
      println(myList(1));
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

ArrayBuffer(Zara, Nuha, Ayan)
ArrayBuffer(Zara, Nuha, Ayan, Welcome, To, Tutorialspoint)
Nuha

स्केल सूचियाँ सरणियों के समान हैं, जिसका अर्थ है, एक सूची के सभी तत्वों में एक ही प्रकार है, लेकिन दो महत्वपूर्ण अंतर हैं। सबसे पहले, सूचियाँ अपरिवर्तनीय हैं, जिसका अर्थ है कि सूची के तत्वों को असाइनमेंट द्वारा नहीं बदला जा सकता है। दूसरी, सूचियाँ एक लिंक की गई सूची का प्रतिनिधित्व करती हैं जबकि सरणियाँ सपाट होती हैं।

एक सूची का प्रकार जिसमें टाइप T के तत्व होते हैं, लिखा जाता है List[T]।

निम्नलिखित उदाहरण का प्रयास करें, विभिन्न डेटा प्रकारों के लिए यहां कुछ सूचियां निर्धारित की गई हैं।

// List of Strings
val fruit: List[String] = List("apples", "oranges", "pears")
// List of Integers
val nums: List[Int] = List(1, 2, 3, 4)
// Empty List.
val empty: List[Nothing] = List()
// Two dimensional list
val dim: List[List[Int]] = List(
   List(1, 0, 0),
   List(0, 1, 0),
   List(0, 0, 1)
)

सभी सूचियों को दो मौलिक भवन ब्लॉकों, एक पूंछ का उपयोग करके परिभाषित किया जा सकता है Nil तथा ::, जिसका उच्चारण किया जाता है cons। शून्य भी खाली सूची का प्रतिनिधित्व करता है। उपरोक्त सभी सूचियों को निम्नानुसार परिभाषित किया जा सकता है।

// List of Strings
val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
// List of Integers
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
// Empty List.
val empty = Nil
// Two dimensional list
val dim = (1 :: (0 :: (0 :: Nil))) ::
   (0 :: (1 :: (0 :: Nil))) ::
   (0 :: (0 :: (1 :: Nil))) :: Nil

सूचियों पर मूल संचालन

सूचियों के सभी संचालन निम्नलिखित तीन विधियों के संदर्भ में व्यक्त किए जा सकते हैं।

अनु क्रमांक	तरीके और विवरण
1	head यह विधि किसी सूची का पहला तत्व देती है।
2	tail यह विधि पहले को छोड़कर सभी तत्वों से मिलकर एक सूची देती है।
3	isEmpty यदि सूची खाली है तो यह विधि सही है अन्यथा गलत है।

निम्न उदाहरण दिखाता है कि उपरोक्त विधियों का उपयोग कैसे किया जाए।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
      val nums = Nil
      println( "Head of fruit : " + fruit.head )
      println( "Tail of fruit : " + fruit.tail )
      println( "Check if fruit is empty : " + fruit.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Head of fruit : apples
Tail of fruit : List(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true

यूनिफ़ॉर्म लिस्ट बनाना

आप उपयोग कर सकते हैं List.fill()विधि एक सूची बनाती है जिसमें एक ही तत्व की शून्य या अधिक प्रतियां शामिल होती हैं। निम्नलिखित उदाहरण कार्यक्रम का प्रयास करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val fruit = List.fill(3)("apples") // Repeats apples three times.
      println( "fruit : " + fruit  )
      val num = List.fill(10)(2)         // Repeats 2, 10 times.
      println( "num : " + num  )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

fruit : List(apples, apples, apples)
num : List(2, 2, 2, 2, 2, 2, 2, 2, 2, 2)

एक कार्य का सारणीकरण

आप एक फ़ंक्शन का उपयोग कर सकते हैं List.tabulate()सूची को सारणीबद्ध करने से पहले सूची के सभी तत्वों पर लागू करने की विधि। इसकी दलीलें List.fill जैसी ही हैं: पहली तर्क सूची बनाने के लिए सूची के आयाम देती है, और दूसरी सूची के तत्वों का वर्णन करती है। अंतर केवल इतना है कि तत्वों को तय किए जाने के बजाय, उन्हें एक फ़ंक्शन से गणना की जाती है।

निम्नलिखित उदाहरण कार्यक्रम का प्रयास करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      // Creates 5 elements using the given function.
      val squares = List.tabulate(6)(n => n * n)
      println( "squares : " + squares  )
      val mul = List.tabulate( 4,5 )( _ * _ )      
      println( "mul : " + mul  )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

squares : List(0, 1, 4, 9, 16, 25)
mul : List(List(0, 0, 0, 0, 0), List(0, 1, 2, 3, 4), 
   List(0, 2, 4, 6, 8), List(0, 3, 6, 9, 12))

रिवर्स लिस्ट ऑर्डर

आप उपयोग कर सकते हैं List.reverseसूची के सभी तत्वों को उल्टा करने की विधि। निम्नलिखित उदाहरण उपयोग को दर्शाता है।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
      println( "Before reverse fruit : " + fruit )
      println( "After reverse fruit : " + fruit.reverse )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Before reverse fruit : List(apples, oranges, pears)
After reverse fruit : List(pears, oranges, apples)

स्काला डेटा संरचना प्रदान करता है ListBuffer, जो सूची में तत्वों को जोड़ते / हटाते समय सूची से अधिक कुशल है। यह एक सूची में तत्वों को प्रस्तुत करने, संलग्न करने के तरीके प्रदान करता है।

घोषित सूचीबहार चर

निम्नलिखित सूची सूची चर घोषित करने के लिए वाक्यविन्यास है।

वाक्य - विन्यास

var z = ListBuffer[String]()

यहां, Z को स्ट्रिंग्स की सूची-बफर के रूप में घोषित किया गया है जो शुरू में खाली है। निम्नलिखित जैसे आदेशों का उपयोग करके मूल्यों को जोड़ा जा सकता है -

आदेश

z += "Zara";
z += "Nuha";
z += "Ayan";

प्रसंस्करण सूची बफ़र

नीचे ListBuffer बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.mutable.ListBuffer 
object Demo {
   def main(args: Array[String]) = {
      var myList = ListBuffer("Zara","Nuha","Ayan")
      println(myList);
      // Add an element
      myList += "Welcome";
      // Add two element
      myList += ("To", "Tutorialspoint");
      println(myList);
      // Remove an element
      myList -= "Welcome";
      // print second element
      println(myList(1));
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

ListBuffer(Zara, Nuha, Ayan)
ListBuffer(Zara, Nuha, Ayan, Welcome, To, Tutorialspoint)
Nuha

स्काला सेट एक ही प्रकार के विभिन्न तत्वों के जोड़ का एक संग्रह है। दूसरे शब्दों में, एक सेट एक संग्रह है जिसमें कोई डुप्लिकेट तत्व नहीं हैं। ListSet अपरिवर्तनीय सेटों को लागू करता है और सूची संरचना का उपयोग करता है। तत्वों को जमा करते समय तत्वों के सम्मिलन क्रम को संरक्षित किया जाता है।

लिस्टसेट वेरिएबल्स की घोषणा

लिस्टसेट चर घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

var z : ListSet[String] = ListSet("Zara","Nuha","Ayan")

यहां, z को स्ट्रिंग्स की सूची-सेट के रूप में घोषित किया गया है जिसमें तीन सदस्य हैं। निम्नलिखित जैसे आदेशों का उपयोग करके मूल्यों को जोड़ा जा सकता है -

आदेश

var myList1: ListSet[String] = myList + "Naira";

प्रसंस्करण सूची

नीचे सूचीबद्ध करने, आरंभ करने और संसाधित करने के तरीके को दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.immutable.ListSet
object Demo {
   def main(args: Array[String]) = {
      var myList: ListSet[String] = ListSet("Zara","Nuha","Ayan");
      // Add an element
      var myList1: ListSet[String] = myList + "Naira";
      // Remove an element
      var myList2: ListSet[String] = myList - "Nuha";
      // Create empty set
      var myList3: ListSet[String] = ListSet.empty[String];
      println(myList);
      println(myList1);
      println(myList2);
      println(myList3);	  
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

ListSet(Zara, Nuha, Ayan)
ListSet(Zara, Nuha, Ayan, Naira)
ListSet(Zara, Ayan)
ListSet()

स्काला वेक्टर एक सामान्य उद्देश्य अपरिवर्तनीय डेटा संरचना है जहां तत्वों को यादृच्छिक रूप से एक्सेस किया जा सकता है। यह आमतौर पर डेटा के बड़े संग्रह के लिए उपयोग किया जाता है।

वेक्टर वेरिएबल्स की घोषणा

वेक्टर चर घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

var z : Vector[String] = Vector("Zara","Nuha","Ayan")

यहां z को स्ट्रिंग्स के एक वेक्टर के रूप में घोषित किया गया है जिसमें तीन सदस्य हैं। निम्नलिखित जैसे आदेशों का उपयोग करके मूल्यों को जोड़ा जा सकता है -

आदेश

var vector1: Vector[String] = z + "Naira";

प्रसंस्करण वेक्टर

नीचे वेक्टर बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.immutable.Vector
object Demo {
   def main(args: Array[String]) = {
      var vector: Vector[String] = Vector("Zara","Nuha","Ayan");
      // Add an element
      var vector1: Vector[String] = vector :+ "Naira";
      // Reverse an element
      var vector2: Vector[String] = vector.reverse;
      // sort a vector
      var vector3: Vector[String] = vector1.sorted;
      println(vector);
      println(vector1);
      println(vector2);
      println(vector3);	  
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Vector(Zara, Nuha, Ayan)
Vector(Zara, Nuha, Ayan, Naira)
Vector(Ayan, Nuha, Zara)
Vector(Ayan, Naira, Nuha, Zara)

स्काला सेट एक ही प्रकार के विभिन्न तत्वों के जोड़ का एक संग्रह है। दूसरे शब्दों में, एक सेट एक संग्रह है जिसमें कोई डुप्लिकेट तत्व नहीं हैं। सेट के दो प्रकार हैं,immutable और यह mutable। उत्परिवर्तनीय और अपरिवर्तनीय वस्तुओं के बीच का अंतर यह है कि जब कोई वस्तु अपरिवर्तनीय होती है, तो ऑब्जेक्ट को स्वयं नहीं बदला जा सकता है।

डिफ़ॉल्ट रूप से, स्काला अपरिवर्तनीय सेट का उपयोग करता है। यदि आप परिवर्तनशील सेट का उपयोग करना चाहते हैं, तो आपको आयात करना होगाscala.collection.mutable.Setस्पष्ट रूप से कक्षा। यदि आप एक ही संग्रह में दोनों परिवर्तनशील और अपरिवर्तनीय सेटों का उपयोग करना चाहते हैं, तो आप अपरिवर्तनीय सेट को संदर्भित करना जारी रख सकते हैंSet लेकिन आप म्यूटेबल सेट को संदर्भित कर सकते हैं mutable.Set।

यहां बताया गया है कि आप अपरिवर्तनीय सेट कैसे घोषित कर सकते हैं -

वाक्य - विन्यास

// Empty set of integer type
var s : Set[Int] = Set()
// Set of integer type
var s : Set[Int] = Set(1,3,5,7)

or 

var s = Set(1,3,5,7)

खाली सेट को परिभाषित करते समय, टाइप एनोटेशन आवश्यक है क्योंकि सिस्टम को चर के लिए एक ठोस प्रकार असाइन करने की आवश्यकता होती है।

सेट पर बुनियादी संचालन

सेट पर सभी संचालन निम्नलिखित तीन तरीकों के संदर्भ में व्यक्त किए जा सकते हैं -

अनु क्रमांक	तरीके और विवरण
1	head यह विधि किसी सेट का पहला तत्व लौटाती है।
2	tail यह विधि पहले को छोड़कर सभी तत्वों से युक्त एक सेट लौटाती है।
3	isEmpty यदि सेट खाली है तो यह विधि सही है अन्यथा गलत है।

मूल परिचालन विधियों के उपयोग को दिखाने के लिए निम्नलिखित उदाहरण देखें -

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val fruit = Set("apples", "oranges", "pears")
      val nums: Set[Int] = Set()
      println( "Head of fruit : " + fruit.head )
      println( "Tail of fruit : " + fruit.tail )
      println( "Check if fruit is empty : " + fruit.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Head of fruit : apples
Tail of fruit : Set(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true

कॉनटेटनेटिंग सेट्स

आप या तो उपयोग कर सकते हैं ++ ऑपरेटर या Set.++() विधि दो या दो से अधिक सेट करने के लिए, लेकिन सेट जोड़ते समय यह डुप्लिकेट तत्वों को हटा देगा।

निम्नलिखित दो सेटों को समझने के लिए उदाहरण है।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val fruit1 = Set("apples", "oranges", "pears")
      val fruit2 = Set("mangoes", "banana")
      // use two or more sets with ++ as operator
      var fruit = fruit1 ++ fruit2
      println( "fruit1 ++ fruit2 : " + fruit )
      // use two sets with ++ as method
      fruit = fruit1.++(fruit2)
      println( "fruit1.++(fruit2) : " + fruit )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

fruit1 ++ fruit2 : Set(banana, apples, mangoes, pears, oranges)
fruit1.++(fruit2) : Set(banana, apples, mangoes, pears, oranges)

एक सेट में अधिकतम, न्यूनतम तत्व खोजें

आप उपयोग कर सकते हैं Set.min न्यूनतम पता लगाने की विधि और Set.maxएक सेट में उपलब्ध तत्वों का अधिकतम पता लगाने की विधि। निम्नलिखित कार्यक्रम दिखाने के लिए उदाहरण है।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val num = Set(5,6,9,20,30,45)
      // find min and max of the elements
      println( "Min element in Set(5,6,9,20,30,45) : " + num.min )
      println( "Max element in Set(5,6,9,20,30,45) : " + num.max )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Min element in Set(5,6,9,20,30,45) : 5
Max element in Set(5,6,9,20,30,45) : 45

सामान्य मान इनसेट्स खोजें

आप या तो उपयोग कर सकते हैं Set.& विधि या Set.intersectदो सेटों के बीच सामान्य मूल्यों का पता लगाने की विधि। उपयोग दिखाने के लिए निम्न उदाहरण का प्रयास करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val num1 = Set(5,6,9,20,30,45)
      val num2 = Set(50,60,9,20,35,55)
      // find common elements between two sets
      println( "num1.&(num2) : " + num1.&(num2) )
      println( "num1.intersect(num2) : " + num1.intersect(num2) )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

num1.&(num2) : Set(20, 9)
num1.intersect(num2) : Set(20, 9)

बिटसेट परस्पर और अपरिवर्तनीय बिटसेट के लिए एक सामान्य आधार वर्ग है। बिटसेट्स गैर-नकारात्मक पूर्णांक के सेट हैं और 64-बिट शब्दों में पैक बिट्स के चर-आकार के सरणियों के रूप में दर्शाए जाते हैं। एक बिटसेट की मेमोरी पदचिह्न को इसमें संग्रहीत सबसे बड़ी संख्या द्वारा दर्शाया गया है।

बिटसेट वेरिएबल्स की घोषणा

BitSet वैरिएबल घोषित करने के लिए सिंटैक्स निम्नलिखित है।

वाक्य - विन्यास

var z : BitSet = BitSet(0,1,2)

यहां, z को गैर-ऋणात्मक पूर्णांकों के बिट-सेट के रूप में घोषित किया गया है, जिसमें तीन सदस्य हैं। निम्नलिखित जैसे आदेशों का उपयोग करके मूल्यों को जोड़ा जा सकता है -

आदेश

var myList1: BitSet = myList + 3;

प्रसंस्करण बिटसेट

नीचे BitSet बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.immutable.BitSet

object Demo {
   def main(args: Array[String]) = {
      var mySet: BitSet = BitSet(0, 1, 2);
      // Add an element
      var mySet1: BitSet = mySet + 3;
      // Remove an element
      var mySet2: BitSet = mySet - 2;
      var mySet3: BitSet = BitSet(4, 5);
      // Adding sets
      var mySet4: BitSet = mySet1 ++ mySet3;
      println(mySet);
      println(mySet1);
      println(mySet2);
      println(mySet4);	  
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

BitSet(0, 1, 2)
BitSet(0, 1, 2, 3)
BitSet(0, 1)
BitSet(0, 1, 2, 3, 4, 5)

स्काला सेट एक ही प्रकार के विभिन्न तत्वों के जोड़ का एक संग्रह है। दूसरे शब्दों में, एक सेट एक संग्रह है जिसमें कोई डुप्लिकेट तत्व नहीं हैं। हैशसेट अपरिवर्तनीय सेट लागू करता है और हैश तालिका का उपयोग करता है। तत्वों का सम्मिलन क्रम संरक्षित नहीं है।

हैशसेट वेरिएबल्स की घोषणा

HashSet चर घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

var z : HashSet[String] = HashSet("Zara","Nuha","Ayan")

यहां, z को स्ट्रिंग्स के हैश-सेट के रूप में घोषित किया गया है जिसमें तीन सदस्य हैं। निम्नलिखित जैसे आदेशों का उपयोग करके मूल्यों को जोड़ा जा सकता है -

आदेश

var myList1: HashSet[String] = myList + "Naira";

प्रसंस्करण हैशसेट

नीचे हैशसेट बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.immutable.HashSet
object Demo {
   def main(args: Array[String]) = {
      var mySet: HashSet[String] = HashSet("Zara","Nuha","Ayan");
      // Add an element
      var mySet1: HashSet[String] = mySet + "Naira";
      // Remove an element
      var mySet2: HashSet[String] = mySet - "Nuha";
      // Create empty set
      var mySet3: HashSet[String] = HashSet.empty[String];
      println(mySet);
      println(mySet1);
      println(mySet2);
      println(mySet3);	  
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

HashSet(Zara, Nuha, Ayan)
HashSet(Zara, Nuha, Ayan, Naira)
HashSet(Zara, Ayan)
HashSet()

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

ट्रीस्सेट वेरिएबल्स की घोषणा

ट्रीसेट चर को घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

var z : TreeSet[String] = TreeSet("Zara","Nuha","Ayan")

यहां, z को स्ट्रिंग्स के ट्री-सेट के रूप में घोषित किया गया है जिसमें तीन सदस्य हैं। निम्नलिखित जैसे आदेशों का उपयोग करके मूल्यों को जोड़ा जा सकता है -

आदेश

var myList1: TreeSet[String] = myList + "Naira";

ट्रीसेट को संसाधित करना

नीचे ट्रीस्सेट बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.immutable.TreeSet

object Demo {
   def main(args: Array[String]) = {
      var mySet: TreeSet[String] = TreeSet("Zara","Nuha","Ayan");
      // Add an element
      var mySet1: TreeSet[String] = mySet + "Naira";
      // Remove an element
      var mySet2: TreeSet[String] = mySet - "Nuha";
      // Create empty set
      var mySet3: TreeSet[String] = TreeSet.empty[String];
      println(mySet);
      println(mySet1);
      println(mySet2);
      println(mySet3);	  
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

TreeSet(Ayan, Nuha, Zara)
TreeSet(Ayan, Naira, Nuha, Zara)
TreeSet(Ayan, Zara)
TreeSet()

स्काला मैप कुंजी / मूल्य जोड़े का एक संग्रह है। किसी भी मूल्य को उसकी कुंजी के आधार पर प्राप्त किया जा सकता है। मानचित्र में कुंजियाँ अद्वितीय हैं, लेकिन मान अद्वितीय नहीं होने चाहिए। मैप्स को हैश टेबल भी कहा जाता है। मैप्स के दो प्रकार हैं,immutable और यह mutable। उत्परिवर्तनीय और अपरिवर्तनीय वस्तुओं के बीच का अंतर यह है कि जब कोई वस्तु अपरिवर्तनीय होती है, तो ऑब्जेक्ट को स्वयं नहीं बदला जा सकता है।

डिफ़ॉल्ट रूप से, स्काला अपरिवर्तनीय मानचित्र का उपयोग करता है। यदि आप परिवर्तनशील मानचित्र का उपयोग करना चाहते हैं, तो आपको आयात करना होगाscala.collection.mutable.Mapस्पष्ट रूप से कक्षा। यदि आप एक ही में परिवर्तनशील और अपरिवर्तनीय दोनों मानचित्रों का उपयोग करना चाहते हैं, तो आप अपरिवर्तनीय मानचित्र का उल्लेख करना जारी रख सकते हैंMap लेकिन आप म्यूटेबल सेट को संदर्भित कर सकते हैं mutable.Map।

निम्नलिखित उदाहरणों को अपरिवर्तनीय मानचित्र घोषित करने के लिए कथन है -

// Empty hash table whose keys are strings and values are integers:
var A:Map[Char,Int] = Map()

// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

खाली नक्शे को परिभाषित करते समय, टाइप एनोटेशन आवश्यक है क्योंकि सिस्टम को चर के लिए एक ठोस प्रकार असाइन करने की आवश्यकता होती है। यदि हम एक मुख्य-मूल्य जोड़ी को मैप में जोड़ना चाहते हैं, तो हम ऑपरेटर + निम्नानुसार उपयोग कर सकते हैं।

A + = ('I' -> 1)
A + = ('J' -> 5)
A + = ('K' -> 10)
A + = ('L' -> 100)

मूल संचालन MAP पर

मानचित्रों पर सभी संचालन निम्नलिखित तीन विधियों के संदर्भ में व्यक्त किए जा सकते हैं।

अनु क्रमांक	तरीके और विवरण
1	keys यह विधि नक्शे में प्रत्येक कुंजी वाले एक पुनरावृत्ति देता है।
2	values यह विधि नक्शे में प्रत्येक मान वाले पुनरावृत्त को लौटाती है।
3	isEmpty यदि नक्शा खाली है तो यह विधि सही है अन्यथा गलत है।

मानचित्र विधियों का उपयोग दिखाते हुए निम्नलिखित उदाहरण कार्यक्रम का प्रयास करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val colors = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      val nums: Map[Int, Int] = Map()
      println( "Keys in colors : " + colors.keys )
      println( "Values in colors : " + colors.values )
      println( "Check if colors is empty : " + colors.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Keys in colors : Set(red, azure, peru)
Values in colors : MapLike(#FF0000, #F0FFFF, #CD853F)
Check if colors is empty : false
Check if nums is empty : true

मानचित्र से कुंजियाँ और मूल्य प्रिंट करें

आप "फॉर्च्यूनर" लूप का उपयोग करके मानचित्र की कुंजियों और मूल्यों के माध्यम से पुनरावृति कर सकते हैं। यहां, हमने विधि का उपयोग कियाforeachकुंजियों के माध्यम से चलने के लिए पुनरावृत्ति से जुड़े। निम्नलिखित उदाहरण कार्यक्रम है।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF","peru" -> "#CD853F")

      colors.keys.foreach{
         i =>  
         print( "Key = " + i )
         println(" Value = " + colors(i) )
      }
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F

मानचित्र में एक कुंजी की जाँच करें

आप या तो उपयोग कर सकते हैं Map.containsपरीक्षण करने की विधि यदि किसी दिए गए कुंजी के नक्शे में मौजूद है या नहीं। कुंजी जाँच के लिए निम्नलिखित उदाहरण कार्यक्रम का प्रयास करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val colors = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      if( colors.contains( "red" )) {
         println("Red key exists with value :"  + colors("red"))
      } else {
         println("Red key does not exist")
      }
      if( colors.contains( "maroon" )) {
         println("Maroon key exists with value :"  + colors("maroon"))
      } else {
         println("Maroon key does not exist")
      }
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Red key exists with value :#FF0000
Maroon key does not exist

स्काला मैप कुंजी / मूल्य जोड़े का एक संग्रह है। किसी भी मूल्य को उसकी कुंजी के आधार पर प्राप्त किया जा सकता है। मानचित्र में कुंजियाँ अद्वितीय हैं, लेकिन मान अद्वितीय नहीं होने चाहिए। HashMap अपरिवर्तनीय मानचित्र को लागू करता है और उसी को लागू करने के लिए हैश तालिका का उपयोग करता है।

हैशपेयर चर की घोषणा

हशपॅ चर को घोषित करने के लिए सिंटैक्स निम्नलिखित है।

वाक्य - विन्यास

val colors = HashMap("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

यहां, रंगों को स्ट्रिंग्स, इंट के हैश-मैप के रूप में घोषित किया गया है, जिसमें तीन कुंजी-मूल्य जोड़े हैं। निम्नलिखित जैसे आदेशों का उपयोग करके मूल्यों को जोड़ा जा सकता है -

आदेश

var myMap1: HashMap[Char, Int] = colors + ("black" -> "#000000");

प्रसंस्करण HashMap

नीचे हैशमैप बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.immutable.HashMap
object Demo {
   def main(args: Array[String]) = {
      var myMap: HashMap[String,String] = HashMap(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      );
      // Add an element
      var myMap1: HashMap[String,String] = myMap + ("white" -> "#FFFFFF");
      // Print key values
      myMap.keys.foreach{ 
         i =>  
         print( "Key = " + i )
         println(" Value = " + myMap(i) )
      }
      if( myMap.contains( "red" )) {
         println("Red key exists with value :"  + myMap("red"))
      } else {
         println("Red key does not exist")
      }
      if( myMap.contains( "maroon" )) {
         println("Maroon key exists with value :"  + myMap("maroon"))
      } else {
         println("Maroon key does not exist")
      }
      //removing element
      var myMap2: HashMap[String,String] = myMap - ("white");
      // Create empty map
      var myMap3: HashMap[String,String] = HashMap.empty[String, String];
      println(myMap1);
      println(myMap2);
      println(myMap3);		  
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Key = azure Value = #F0FFFF
Key = peru Value = #CD853F
Key = red Value = #FF0000
Red key exists with value :#FF0000
Maroon key does not exist
HashMap(azure -> #F0FFFF, peru -> #CD853F, white -> #FFFFFF, red -> #FF0000)
HashMap(azure -> #F0FFFF, peru -> #CD853F, red -> #FF0000)
HashMap()

स्काला मैप कुंजी / मूल्य जोड़े का एक संग्रह है। किसी भी मूल्य को उसकी कुंजी के आधार पर प्राप्त किया जा सकता है। मानचित्र में कुंजियाँ अद्वितीय हैं, लेकिन मान अद्वितीय नहीं होने चाहिए। ListMap अपरिवर्तनीय मानचित्र को लागू करता है और उसी को लागू करने के लिए सूची का उपयोग करता है। इसका उपयोग कम संख्या में तत्वों के साथ किया जाता है।

घोषणा सूची चर

सूची सूची चर घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

val colors = ListMap("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

आदेश

var myMap1: ListMap[Char, Int] = colors + ("black" -> "#000000");

प्रसंस्करण सूची

उदाहरण

import scala.collection.immutable.ListMap

object Demo {
   def main(args: Array[String]) = {
      var myMap: ListMap[String,String] = ListMap(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      );
      // Add an element
      var myMap1: ListMap[String,String] = myMap + ("white" -> "#FFFFFF");
      // Print key values
      myMap.keys.foreach{ 
         i =>  
         print( "Key = " + i )
         println(" Value = " + myMap(i) ) 
      }
      if( myMap.contains( "red" )) {
         println("Red key exists with value :"  + myMap("red"))
      } else {
         println("Red key does not exist")
      }
      if( myMap.contains( "maroon" )) {
         println("Maroon key exists with value :"  + myMap("maroon"))
      } else {
         println("Maroon key does not exist")
      }
      //removing element
      var myMap2: ListMap[String,String] = myMap - ("white");
      // Create empty map
      var myMap3: ListMap[String,String] = ListMap.empty[String, String];
      println(myMap1);
      println(myMap2);	
      println(myMap3);		  
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F
Red key exists with value :#FF0000
Maroon key does not exist
ListMap(red -> #FF0000, azure -> #F0FFFF, peru -> #CD853F, white -> #FFFFFF)
ListMap(red -> #FF0000, azure -> #F0FFFF, peru -> #CD853F)
ListMap()

एक पुनरावृत्ति एक संग्रह नहीं है, बल्कि संग्रह के तत्वों को एक-एक करके एक्सेस करने का तरीका है। दो बुनियादी संचालन एक परiterator it कर रहे हैं next तथा hasNext। के लिए एक कॉलit.next()पुनरावृति के अगले तत्व को वापस करेगा और पुनरावृत्त की स्थिति को आगे बढ़ाएगा। आप पता लगा सकते हैं कि क्या Iterator का उपयोग करके वापस लौटने के लिए अधिक तत्व हैं या नहींit.hasNext तरीका।

एक पुनरावृत्त द्वारा लौटाए गए सभी तत्वों को "कदम के माध्यम से" करने का सबसे सीधा तरीका थोड़ी देर के लूप का उपयोग करना है। आइए हम निम्नलिखित उदाहरण कार्यक्रम का पालन करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val it = Iterator("a", "number", "of", "words")
      while (it.hasNext){
         println(it.next())
      }
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

a
number
of
words

मिन और मैक्स मान्य तत्व खोजें

आप उपयोग कर सकते हैं it.min तथा it.maxइट्रेटर से न्यूनतम और अधिकतम मूल्यवान तत्वों का पता लगाने के तरीके। यहां, हमने उपयोग कियाita तथा itbदो अलग-अलग ऑपरेशन करने के लिए क्योंकि इट्रिज़र को केवल एक बार ट्रेस किया जा सकता है। निम्नलिखित उदाहरण कार्यक्रम है।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val ita = Iterator(20,40,2,50,69, 90)
      val itb = Iterator(20,40,2,50,69, 90)
      println("Maximum valued element " + ita.max )
      println("Minimum valued element " + itb.min )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Maximum valued element 90
Minimum valued element 2

Iterator की लंबाई ज्ञात कीजिए

आप या तो उपयोग कर सकते हैं it.size या it.lengthइट्रेटर में उपलब्ध तत्वों की संख्या का पता लगाने के तरीके। यहां, हमने दो अलग-अलग ऑपरेशन करने के लिए ita और itb का उपयोग किया है, क्योंकि इट्रेटर को केवल एक बार ट्रैवर्स किया जा सकता है। निम्नलिखित उदाहरण कार्यक्रम है।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val ita = Iterator(20,40,2,50,69, 90)
      val itb = Iterator(20,40,2,50,69, 90)
      println("Value of ita.size : " + ita.size )
      println("Value of itb.length : " + itb.length )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Value of ita.size : 6
Value of itb.length : 6

स्काला ऑप्शन [टी] शून्य या किसी दिए गए प्रकार के एक तत्व के लिए एक कंटेनर है। एक विकल्प [T] भी हो सकता हैSome[T] या Noneऑब्जेक्ट, जो एक लापता मान का प्रतिनिधित्व करता है। उदाहरण के लिए, यदि किसी दिए गए कुंजी के अनुरूप मान पाया गया है, या, तो स्काला के मानचित्र का तरीका विधि कुछ (मूल्य) पैदा करता हैNone यदि दी गई कुंजी को मानचित्र में परिभाषित नहीं किया गया है।

ऑप्शन प्रकार का उपयोग स्काला प्रोग्राम्स में अक्सर किया जाता है और आप इसके साथ तुलना कर सकते हैं nullजावा में उपलब्ध मूल्य जो कोई मूल्य नहीं दर्शाता है। उदाहरण के लिए, java.util.ashMap की विधि पाएं या तो हाशम में संग्रहीत मान लौटाता है, या यदि कोई मान नहीं मिला तो अशक्त।

मान लीजिए कि हमारे पास एक विधि है जो प्राथमिक कुंजी के आधार पर डेटाबेस से एक रिकॉर्ड प्राप्त करता है।

def findPerson(key: Int): Option[Person]

विधि कुछ [व्यक्ति] वापस आ जाएगी यदि रिकॉर्ड पाया जाता है, लेकिन कोई नहीं अगर रिकॉर्ड नहीं मिला है। हमें निम्नलिखित कार्यक्रम का पालन करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
      println("capitals.get( \"France\" ) : " +  capitals.get( "France" ))
      println("capitals.get( \"India\" ) : " +  capitals.get( "India" ))
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

capitals.get( "France" ) : Some(Paris)
capitals.get( "India" ) : None

वैकल्पिक मूल्यों को अलग करने का सबसे आम तरीका एक पैटर्न मैच है। उदाहरण के लिए निम्नलिखित कार्यक्रम का प्रयास करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
      println("show(capitals.get( \"Japan\")) : " + show(capitals.get( "Japan")) )
      println("show(capitals.get( \"India\")) : " + show(capitals.get( "India")) )
   }
   def show(x: Option[String]) = x match {
      case Some(s) => s
      case None => "?"
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

show(capitals.get( "Japan")) : Tokyo
show(capitals.get( "India")) : ?

GetOrElse () मेथड का उपयोग करना

एक मान या डिफ़ॉल्ट का उपयोग करने के लिए getOrElse () विधि का उपयोग करने का तरीका दिखाने के लिए उदाहरण कार्यक्रम निम्नलिखित है जब कोई मूल्य मौजूद नहीं है।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val a:Option[Int] = Some(5)
      val b:Option[Int] = None 
      println("a.getOrElse(0): " + a.getOrElse(0) )
      println("b.getOrElse(10): " + b.getOrElse(10) )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

a.getOrElse(0): 5
b.getOrElse(10): 10

का उपयोग कर रहा है खाली () विधि

यह दिखाने के लिए कि कैसे विकल्प है या नहीं, यह जांचने के लिए isEmpty () विधि का उपयोग करने के लिए उदाहरण कार्यक्रम निम्नलिखित है।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val a:Option[Int] = Some(5)
      val b:Option[Int] = None 
      println("a.isEmpty: " + a.isEmpty )
      println("b.isEmpty: " + b.isEmpty )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उदाहरण

a.isEmpty: false
b.isEmpty: true

कतार पहली बार फर्स्ट आउट में है, फीफो डेटा संरचना और फीफो में तत्वों को सम्मिलित करने और पुनः प्राप्त करने की अनुमति देता है।

कतार चर की घोषणा

कतार चर को घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

val queue = Queue(1, 2, 3, 4, 5)

यहां, कतार को संख्याओं की कतार के रूप में घोषित किया जाता है। निम्नलिखित की तरह कमांड का उपयोग करके मूल्य को आगे जोड़ा जा सकता है -

आदेश

queue.enqueue(6)

निम्नलिखित जैसे आदेशों का उपयोग करके मोर्चे को पीछे छोड़ा जा सकता है -

आदेश

queue.dequeue()

प्रसंस्करण कतार

नीचे कतार बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.mutable.Queue
object Demo {
   def main(args: Array[String]) = {
      var queue = Queue(1, 2, 3, 4, 5);
      // Print queue elements
      queue.foreach{(element:Int) => print(element + " ")}
      println();
      // Print first element
      println("First Element: " + queue.front)
      // Add an element
      queue.enqueue(6);
      // Print queue elements
      queue.foreach{(element:Int) => print(element+ " ")}
      println();
      // Remove an element
      var dq = queue.dequeue;
      // Print dequeued element
      println("Dequeued Element: " + dq)
      // Print queue elements
      queue.foreach{(element:Int) => print(element+ " ")}
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

1 2 3 4 5
First Element: 1
1 2 3 4 5 6
Dequeued Element: 1
2 3 4 5 6

स्काला टपल एक निश्चित संख्या में वस्तुओं को एक साथ जोड़ती है ताकि उन्हें एक पूरे के रूप में पास किया जा सके। एक सरणी या सूची के विपरीत, एक टपल वस्तुओं को विभिन्न प्रकारों से पकड़ सकता है लेकिन वे अपरिवर्तनीय भी हैं।

निम्नलिखित एक पूर्णांक, एक स्ट्रिंग, और कंसोल को पकड़े हुए टपल का एक उदाहरण है।

val t = (1, "hello", Console)

निम्नलिखित के लिए कौन सी सिंथेटिक चीनी (शॉर्ट कट) है -

val t = new Tuple3(1, "hello", Console)

टपल का वास्तविक प्रकार उन तत्वों की संख्या और तत्वों पर निर्भर करता है, जो उन तत्वों के प्रकार हैं। इस प्रकार, (99, "लुफ्टबॉल") का प्रकार ट्यूपल 2 [इंट, स्ट्रिंग] है। का प्रकार ('u', 'r', "the", 1, 4, "me") Tuple6 है [चार, चार, स्ट्रिंग, इंट, इंट, स्ट्रिंग]

Tuples टाइप Tuple1, Tuple2, Tuple3 और इसी तरह के हैं। वर्तमान में स्केल में 22 की ऊपरी सीमा है यदि आपको अधिक की आवश्यकता है, तो आप एक संग्रह का उपयोग कर सकते हैं, न कि एक टपल। प्रत्येक TupleN प्रकार के लिए, जहाँ 1 <= N <= 22, Scala कई तत्व-अभिगम विधियों को परिभाषित करता है। निम्नलिखित परिभाषा को देखते हुए -

val t = (4,3,2,1)

टपल टी के तत्वों को एक्सेस करने के लिए, आप पहले तत्व को एक्सेस करने के लिए t._1 का उपयोग कर सकते हैं, दूसरे पर पहुंचने के लिए t._2 और इसी तरह। उदाहरण के लिए, निम्नलिखित अभिव्यक्ति टी के सभी तत्वों के योग की गणना करती है।

val sum = t._1 + t._2 + t._3 + t._4

आप एक विधि लिखने के लिए Tuple का उपयोग कर सकते हैं, जो एक सूची [Double] लेता है और गिनती, योग, और तीन-तत्व Tuple, Tuple3 [Int, Double, Double] में लौटाए गए वर्गों का योग देता है। वे समवर्ती प्रोग्रामिंग में अभिनेताओं के बीच संदेश के रूप में डेटा मूल्यों की एक सूची को पारित करने के लिए भी उपयोगी हैं।

निम्नलिखित उदाहरण कार्यक्रम का प्रयास करें। यह दिखाता है कि टपल का उपयोग कैसे किया जाता है।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      val sum = t._1 + t._2 + t._3 + t._4
      println( "Sum of elements: "  + sum )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Sum of elements: 10

टुपले पर Iterate

आप उपयोग कर सकते हैं Tuple.productIterator() एक ट्यूपल के सभी तत्वों पर पुनरावृति करने की विधि।

टुपल्स पर पुनरावृति करने के लिए निम्न उदाहरण कार्यक्रम का प्रयास करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      t.productIterator.foreach{ i =>println("Value = " + i )}
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Value = 4
Value = 3
Value = 2
Value = 1

स्ट्रिंग में परिवर्तित हो रहा है

आप उपयोग कर सकते हैं Tuple.toString()टपल के सभी तत्वों को एक स्ट्रिंग में समेटने की विधि। स्ट्रिंग में कनवर्ट करने के लिए निम्न उदाहरण प्रोग्राम का प्रयास करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val t = new Tuple3(1, "hello", Console)
      println("Concatenated String: " + t.toString() )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Concatenated String: (1,hello,scala.Console$@281acd47)

तत्वों को स्वैप करें

आप उपयोग कर सकते हैं Tuple.swap Tuple2 के तत्वों को स्वैप करने की विधि।

तत्वों की अदला-बदली के लिए निम्न उदाहरण कार्यक्रम का प्रयास करें।

उदाहरण

object Demo {
   def main(args: Array[String]) {
      val t = new Tuple2("Scala", "hello")
      println("Swapped Tuple: " + t.swap )
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Swapped tuple: (hello,Scala)

Scala Seq अपरिवर्तनीय अनुक्रमों का प्रतिनिधित्व करने के लिए एक विशेषता है। यह संरचना तत्वों, उनकी घटनाओं और अनुवर्तीताओं को खोजने के लिए सूचकांक आधारित पहुंच और विभिन्न उपयोगिता विधियां प्रदान करती है। एक Seq सम्मिलन क्रम बनाए रखता है।

सेक् चर की घोषणा

निम्नलिखित एक Seq चर घोषित करने के लिए वाक्यविन्यास है।

वाक्य - विन्यास

val seq: Seq[Int] = Seq(1, 2, 3, 4, 5)

यहां, seq को अंकों की Seq के रूप में घोषित किया जाता है। Seq निम्नलिखित की तरह कमांड प्रदान करता है -

आदेश

val isPresent = seq.contains(4);
val contains = seq.endsWith(Seq(4,5));
var lastIndexOf = seq.lasIndexOf(5);

प्रसंस्करण सीक

नीचे Seq बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.immutable.Seq
object Demo {
   def main(args: Array[String]) = {
      var seq = Seq(1, 2, 3, 4, 5, 3)
      // Print seq elements
      seq.foreach{(element:Int) => print(element + " ")}
      println()
      println("Seq ends with (5,3): " + seq.endsWith(Seq(5, 3)))
      println("Seq contains 4: " + seq.contains(4))
      println("Last index of 3: " + seq.lastIndexOf(3))
      println("Reversed Seq" + seq.reverse)           
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

1 2 3 4 5 3
Seq ends with (5,3): true
Seq contains 4: true
Last index of 3: 5
Reversed SeqList(3, 5, 4, 3, 2, 1)

स्टैक लास्ट इन फर्स्ट आउट, LIFO डेटा संरचना है और LIFO तरीके से शीर्ष पर तत्व डालने और पुनः प्राप्त करने की अनुमति देता है।

स्टैक वेरिएबल्स की घोषणा

स्टैक चर घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

val stack = Stack(1, 2, 3, 4, 5)

यहां, स्टैक को संख्याओं के ढेर के रूप में घोषित किया जाता है। निम्नलिखित की तरह कमांड का उपयोग करके मूल्य को शीर्ष पर जोड़ा जा सकता है -

आदेश

stack.push(6)

निम्नलिखित जैसे आदेशों का उपयोग करके मूल्य को ऊपर से पीछे किया जा सकता है -

आदेश

stack.top

निम्न जैसे आदेशों का उपयोग करके मान को ऊपर से हटाया जा सकता है -

आदेश

stack.pop

प्रसंस्करण स्टैक

नीचे स्टैक बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.mutable.Stack
object Demo {
   def main(args: Array[String]) = {
      var stack: Stack[Int] = Stack();
      // Add elements
      stack.push(1);
      stack.push(2);
      // Print element at top
      println("Top Element: " + stack.top)
      // Print element
      println("Removed Element: " + stack.pop())
      // Print element
      println("Top Element: " + stack.top)	
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Top Element: 2
Removed Element: 2
Top Element: 1

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

स्ट्रीम चर की घोषणा

स्ट्रीम चर घोषित करने के लिए निम्नलिखित सिंटैक्स है।

वाक्य - विन्यास

val stream = 1 #:: 2 #:: 3 #:: Stream.empty

यहां, धारा को संख्या की एक धारा के रूप में घोषित किया जाता है। यहाँ 1 धारा का प्रमुख है, 2, 3 धारा की पूंछ है। Stream.empty स्ट्रीम के अंत को चिह्नित करता है। मानों को निम्न की तरह कमांड लेने का उपयोग करके पुनर्प्राप्त किया जा सकता है -

आदेश

stream.take(2)

प्रसंस्करण स्ट्रीम

नीचे स्ट्रीम बनाने, आरंभ करने और संसाधित करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

import scala.collection.immutable.Stream
object Demo {
   def main(args: Array[String]) = {
      val stream = 1 #:: 2 #:: 3 #:: Stream.empty
      // print stream
      println(stream)
      // Print first two elements	
      stream.take(2).print
      println()
      // Create an empty stream
      val stream1: Stream[Int] = Stream.empty[Int]
      // Print element
      println(s"Stream: $stream1")
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Stream(1, <not computed>)
1, 2
Stream: Stream()

ड्रॉप () विधि सूची के पहले n तत्वों को छोड़कर सभी तत्वों का चयन करने के लिए सूची द्वारा उपयोग की जाने वाली विधि है।

वाक्य - विन्यास

निम्नलिखित ड्रॉप विधि का वाक्य विन्यास है।

def drop(n: Int): List[A]

यहाँ, n सूची से हटाए जाने वाले तत्वों की संख्या है। यह विधि पहले n वाले को छोड़कर सूची के सभी तत्वों को लौटाती है।

प्रयोग

नीचे ड्रॉप विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3, 4, 5)
      // print list
      println(list)
      //apply operation
      val result = list.drop(3)
      //print result
      println(result)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

List(1, 2, 3, 4, 5)
List(4, 5)

dropWhile () विधि सभी तत्वों को छोड़ने के लिए सूची द्वारा उपयोग की जाने वाली विधि है जो किसी दिए गए शर्त को पूरा करती है।

वाक्य - विन्यास

निम्नलिखित dropWhile विधि का सिंटैक्स है।

def dropWhile(p: (A) => Boolean): List[A]

यहाँ, p: (A) => बूलियन सूची के प्रत्येक तत्व पर लागू होने वाली एक विधेय या स्थिति है। यह विधि सूची के सभी तत्वों को छोड़ देती है, जिन्हें छोड़ दिया गया है।

प्रयोग

नीचे ड्रॉपडाइल विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(3, 6, 9, 4, 2)
      // print list
      println(list)
      //apply operation
      val result = list.dropWhile(x=>{x % 3 == 0})
      //print result
      println(result)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

List(3, 6, 9, 4, 2)
List(4, 2)

फ़िल्टर () विधि सभी तत्वों का चयन करने के लिए सूची द्वारा उपयोग की जाने वाली विधि है जो किसी दिए गए विधेय को संतुष्ट करती है।

वाक्य - विन्यास

निम्नलिखित फिल्टर विधि का वाक्य विन्यास है।

def filter(p: (A) => Boolean): List[A]

यहाँ, p: (A) => बूलियन सूची के प्रत्येक तत्व पर लागू होने वाली एक विधेय या स्थिति है। यह विधि सूची के सभी तत्वों को लौटाती है जो दी गई स्थिति को संतुष्ट करती है।

प्रयोग

नीचे फ़िल्टर विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(3, 6, 9, 4, 2)
      // print list
      println(list)
      //apply operation
      val result = list.filter(x=>{x % 3 == 0})
      //print result
      println(result)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

List(3, 6, 9, 4, 2)
List(3, 6, 9)

खोज () विधि Iterators द्वारा किसी तत्व को खोजने के लिए प्रयोग की जाने वाली विधि है जो किसी दिए गए विधेय को संतुष्ट करती है।

वाक्य - विन्यास

निम्नलिखित खोज विधि का वाक्य विन्यास है।

def find(p: (A) => Boolean): Option[A]

यहाँ, p: (A) => बूलियन एक प्राइमरेट या कंडीशन है जो इटरेटर के प्रत्येक तत्व पर लगाया जाना है। यह विधि विकल्प तत्व से मेल खाने वाले तत्व का रिटर्न करती है जो दी गई स्थिति को संतुष्ट करता है।

प्रयोग

नीचे खोज विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val iterator = Iterator(3, 6, 9, 4, 2)
      //apply operation
      val result = iterator.find(x=>{x % 3 == 0})
      //print result
      println(result)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

Some(3)

flatMap () विधि ट्रैवर्सिबल लाइक की विधि है, यह एक विधेय लेता है, इसे संग्रह के प्रत्येक तत्व पर लागू करता है और विधेय द्वारा लौटाए गए तत्वों का एक नया संग्रह लौटाता है।

वाक्य - विन्यास

निम्नलिखित फ्लैटपाइप विधि का वाक्य विन्यास है।

def flatMap[B](f: (A) ? GenTraversableOnce[B]): TraversableOnce[B]

यहाँ, एफ: (ए)? GenTraversableOnce [B] संग्रह के प्रत्येक तत्व पर लागू होने वाली एक विधेय या स्थिति है। यह विधि विकल्प तत्व से मेल खाने वाले तत्व का रिटर्न करती है जो दी गई स्थिति को संतुष्ट करता है।

प्रयोग

नीचे फ्लैटपाइप विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 5, 10)
      //apply operation
      val result = list.flatMap{x => List(x,x+1)}
      //print result
      println(result)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

List(1, 2, 5, 6, 10, 11)

समतल () विधि एक सदस्य GenericTraversableTemplate विशेषता है, यह बाल संग्रह को विलय करके तत्वों का एक एकल संग्रह लौटाता है।

वाक्य - विन्यास

निम्नलिखित समतल विधि का वाक्य विन्यास है।

def flatten[B]: Traversable[B]

प्रयोग

नीचे समतल विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(List(1,2), List(3,4))
      //apply operation
      val result = list.flatten
      //print result
      println(result)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

List(1, 2, 3, 4)

तह () विधि TraversableOnce विशेषता का एक सदस्य है, इसका उपयोग संग्रह के तत्वों को ढहाने के लिए किया जाता है।

वाक्य - विन्यास

निम्नलिखित गुना विधि का वाक्यविन्यास है।

def fold[A1 >: A](z: A1)(op: (A1, A1) ? A1): A1

यहां, गुना विधि एक पैरामीटर के रूप में साहचर्य बाइनरी ऑपरेटर फ़ंक्शन को लेती है। यह विधि परिणाम को मान के रूप में लौटाती है। यह पहले इनपुट को प्रारंभिक मूल्य और दूसरे इनपुट को एक फ़ंक्शन (जो संचित मूल्य और इनपुट के रूप में वर्तमान आइटम लेता है) के रूप में मानता है।

प्रयोग

नीचे फोल्ड विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.fold(0)(_ + _)
      //print result
      println(result)      
   }
}

यहां हमने फ़ंक्शन को गुना करने के लिए प्रारंभिक मान के रूप में 0 पास किया है और फिर सभी मान जोड़े गए हैं। में उपरोक्त कार्यक्रम सहेजेंDemo.scala। इस प्रोग्राम को संकलित करने और निष्पादित करने के लिए निम्न कमांड का उपयोग किया जाता है।

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

foldLeft () विधि TraversableOnce विशेषता का एक सदस्य है, इसका उपयोग संग्रह के तत्वों को ढहाने के लिए किया जाता है। यह लेफ्ट से राइट ऑर्डर तक तत्वों को नेविगेट करता है। यह मुख्य रूप से पुनरावर्ती कार्यों में उपयोग किया जाता है और स्टैक ओवरफ्लो अपवादों को रोकता है।

वाक्य - विन्यास

निम्नलिखित गुना विधि का वाक्यविन्यास है।

def foldLeft[B](z: B)(op: (B, A) ? B): B

यहाँ, foldLeft पद्धति एक पैरामीटर के रूप में साहचर्य बाइनरी ऑपरेटर फ़ंक्शन को लेती है। यह विधि परिणाम को मान के रूप में लौटाती है।

प्रयोग

नीचे तह पद्धति का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.foldLeft(0)(_ + _)
      //print result
      println(result)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

foldRight () विधि TraversableOnce विशेषता का एक सदस्य है, इसका उपयोग संग्रह के तत्वों को ढहाने के लिए किया जाता है। यह राइट टू लेफ्ट ऑर्डर से तत्वों को नेविगेट करता है।

वाक्य - विन्यास

निम्नलिखित foldRight विधि का वाक्यविन्यास है।

def foldRight[B](z: B)(op: (B, A) ? B): B

यहां, गुना विधि एक पैरामीटर के रूप में साहचर्य बाइनरी ऑपरेटर फ़ंक्शन को लेती है। यह विधि परिणामी मान लौटाता है।

प्रयोग

नीचे तह पद्धति का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.foldRight(0)(_ + _)
      //print result
      println(result)      
   }
}

यहाँ हमने फोल्डर राइट फ़ंक्शन के लिए प्रारंभिक मान के रूप में 0 पास किया है और फिर सभी मान जोड़े गए हैं। में उपरोक्त कार्यक्रम सहेजेंDemo.scala। इस प्रोग्राम को संकलित करने और निष्पादित करने के लिए निम्न कमांड का उपयोग किया जाता है।

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

नक्शा () विधि ट्रैवर्सेबल लाइक विशेषता का एक सदस्य है, इसका उपयोग संग्रह के प्रत्येक तत्वों पर एक विधेय विधि को चलाने के लिए किया जाता है। यह एक नया संग्रह लौटाता है।

वाक्य - विन्यास

निम्नलिखित मानचित्र विधि का वाक्य विन्यास है।

def map[B](f: (A) ? B): Traversable[B]

यहां, मानचित्र विधि एक पैरामीटर के रूप में एक पूर्ववर्ती फ़ंक्शन लेती है। यह विधि अद्यतन संग्रह लौटाता है।

प्रयोग

नीचे मानचित्र विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get twice of each element.
      val result = list.map(_ * 2)
      //print result
      println(result)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

List(2, 4, 6, 8)

विभाजन () विधि TraversableLike विशेषता का एक सदस्य है, इसका उपयोग संग्रह के प्रत्येक तत्वों पर एक विधेय विधि को चलाने के लिए किया जाता है। यह दो संग्रह लौटाता है, एक संग्रह तत्वों का है जो किसी दिए गए विधेय फ़ंक्शन को संतुष्ट करता है और दूसरा संग्रह उन तत्वों का है जो दिए गए विधेय फ़ंक्शन को संतुष्ट नहीं करते हैं।

वाक्य - विन्यास

निम्नलिखित मानचित्र विधि का वाक्य विन्यास है।

def partition(p: (A) ? Boolean): (Repr, Repr)

यहां, विभाजन विधि एक पैरामीटर के रूप में एक पूर्ववर्ती फ़ंक्शन लेती है। यह विधि संग्रह लौटाती है।

प्रयोग

नीचे दिखाया गया है कि विभाजन विधि का उपयोग करने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3, 4, 5, 6, 7)
      //apply operation to get twice of each element.
      val (result1, result2) = list.partition(x=>{x % 3 == 0})
      //print result
      println(result1)
      println(result2)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

List(3, 6)
List(1, 2, 4, 5, 7)

कम () विधि ट्रैवर्सिबलऑस विशेषता का एक सदस्य है, इसका उपयोग संग्रह के तत्वों को ढहाने के लिए किया जाता है। यह गुना विधि के समान है लेकिन यह प्रारंभिक मूल्य नहीं लेता है।

वाक्य - विन्यास

निम्नलिखित कम करने की विधि का वाक्य विन्यास है।

def reduce[A1 >: A](op: (A1, A1) ? A1): A1

यहां, कम करने की विधि एक पैरामीटर के रूप में साहचर्य बाइनरी ऑपरेटर फ़ंक्शन को लेती है। यह विधि परिणामी मान लौटाता है।

प्रयोग

नीचे फोल्ड विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.reduce(_ + _)
      //print result
      println(result)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

स्कैन () विधि TraversableLike विशेषता का एक सदस्य है, यह तह विधि के समान है लेकिन संग्रह के प्रत्येक तत्वों पर एक ऑपरेशन को लागू करने और एक संग्रह को वापस करने के लिए उपयोग किया जाता है।

वाक्य - विन्यास

निम्नलिखित गुना विधि का वाक्यविन्यास है।

def scan[B >: A, That](z: B)(op: (B, B) ? B)(implicit cbf: CanBuildFrom[Repr, B, That]): That

यहां, स्कैन विधि एक पैरामीटर के रूप में साहचर्य बाइनरी ऑपरेटर फ़ंक्शन को लेती है। यह विधि परिणाम के रूप में अद्यतन संग्रह लौटाती है। यह पहले इनपुट को प्रारंभिक मूल्य और दूसरे इनपुट को फ़ंक्शन के रूप में मानता है।

प्रयोग

नीचे स्कैन विधि का उपयोग दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to create a running total of all elements of the list
      val list1 = list.scan(0)(_ + _)
      //print list
      println(list1)      
   }
}

यहां हमने फ़ंक्शन स्कैन करने के लिए प्रारंभिक मान के रूप में 0 पास किया है और फिर सभी मान जोड़े गए हैं। में उपरोक्त कार्यक्रम सहेजेंDemo.scala। इस प्रोग्राम को संकलित करने और निष्पादित करने के लिए निम्न कमांड का उपयोग किया जाता है।

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

List(0, 1, 3, 6, 10)

zip () विधि IterableLike विशेषता का एक सदस्य है, इसका उपयोग संग्रह को वर्तमान संग्रह में मर्ज करने के लिए किया जाता है और परिणाम दोनों संग्रह से टपल तत्वों की जोड़ी का संग्रह होता है।

वाक्य - विन्यास

निम्नलिखित ज़िप विधि का वाक्य विन्यास है।

def zip[B](that: GenIterable[B]): Iterable[(A, B)]

यहाँ, ज़िप विधि एक संग्रह को पैरामीटर के रूप में लेती है। यह विधि परिणाम के रूप में जोड़ी के अपडेट किए गए संग्रह को लौटाती है।

प्रयोग

नीचे जिप विधि का उपयोग करने का तरीका दिखाने का एक उदाहरण कार्यक्रम है -

उदाहरण

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      val list1 = List("A", "B", "C", "D")
      //apply operation to create a zip of list
      val list2 = list zip list1
      //print list
      println(list2)      
   }
}

आदेश

\>scalac Demo.scala
\>scala Demo

उत्पादन

List((1,A), (2,B), (3,C), (4,D))

स्काला कलेक्शंस - क्विक गाइड

चरण 1: अपने जावा इंस्टॉलेशन को सत्यापित करें

चरण 2: अपना जावा वातावरण सेट करें

चरण 3: स्कैला स्थापित करें

ऐरे वेरिएबल की घोषणा

वाक्य - विन्यास

आदेश

प्रसंस्करण

उदाहरण

आदेश

उत्पादन

उदाहरण

आदेश

उत्पादन

उदाहरण

आदेश

उत्पादन

एरिकबफरर वेरिएबल्स की घोषणा

वाक्य - विन्यास

आदेश

प्रसंस्करण ArrayBuffer

उदाहरण

आदेश

उत्पादन

सूचियों पर मूल संचालन

उदाहरण

आदेश

उत्पादन

संबंधित सूची

उदाहरण

आदेश

उत्पादन

यूनिफ़ॉर्म लिस्ट बनाना

उदाहरण

आदेश

उत्पादन

एक कार्य का सारणीकरण

उदाहरण

आदेश

उत्पादन

रिवर्स लिस्ट ऑर्डर

उदाहरण

आदेश

उत्पादन

घोषित सूचीबहार चर

वाक्य - विन्यास

आदेश

प्रसंस्करण सूची बफ़र

उदाहरण

आदेश

उत्पादन

लिस्टसेट वेरिएबल्स की घोषणा

वाक्य - विन्यास

आदेश

प्रसंस्करण सूची

उदाहरण

आदेश

उत्पादन

वेक्टर वेरिएबल्स की घोषणा

वाक्य - विन्यास

आदेश

प्रसंस्करण वेक्टर

उदाहरण

आदेश

उत्पादन

वाक्य - विन्यास

सेट पर बुनियादी संचालन

उदाहरण

आदेश

उत्पादन

कॉनटेटनेटिंग सेट्स

उदाहरण

आदेश

उत्पादन

एक सेट में अधिकतम, न्यूनतम तत्व खोजें

उदाहरण

आदेश

उत्पादन

सामान्य मान इनसेट्स खोजें

उदाहरण