Scala Collections - คู่มือฉบับย่อ

Scala มีคลังคอลเลกชันมากมาย คอลเลกชันคือภาชนะบรรจุสิ่งของ คอนเทนเนอร์เหล่านั้นสามารถเรียงลำดับได้ชุดรายการเชิงเส้นเช่น List, Tuple, Option, Map ฯลฯ คอลเลกชันอาจมีจำนวนองค์ประกอบตามอำเภอใจหรือล้อมรอบเป็นศูนย์หรือองค์ประกอบเดียว (เช่น Option)

คอลเลกชันอาจเป็น strict หรือ lazy. Lazy คอลเลกชันมีองค์ประกอบที่อาจไม่ใช้หน่วยความจำจนกว่าจะเข้าถึงได้เช่นRanges. นอกจากนี้คอลเลกชันอาจเป็นmutable (เนื้อหาของข้อมูลอ้างอิงสามารถเปลี่ยนแปลงได้) หรือ immutable(สิ่งที่อ้างอิงอ้างถึงจะไม่เปลี่ยนแปลง) โปรดทราบว่าคอลเล็กชันที่ไม่เปลี่ยนรูปอาจมีรายการที่เปลี่ยนแปลงได้

สำหรับปัญหาบางอย่างคอลเลกชันที่เปลี่ยนแปลงไม่ได้จะทำงานได้ดีขึ้นและสำหรับคอลเลกชันอื่น ๆ ที่ไม่เปลี่ยนรูปจะทำงานได้ดีกว่า หากมีข้อสงสัยควรเริ่มต้นด้วยคอลเล็กชันที่ไม่เปลี่ยนรูปและเปลี่ยนในภายหลังหากคุณต้องการสิ่งที่ไม่แน่นอน

บทนี้จะให้ความสำคัญกับประเภทคอลเลกชันที่ใช้บ่อยที่สุดและการดำเนินการที่ใช้บ่อยที่สุดในคอลเล็กชันเหล่านั้น

ซีเนียร์ No	คอลเล็กชันพร้อมคำอธิบาย
1	Scala Lists Scala's List [T] เป็นรายการที่เชื่อมโยงกับประเภท T.
2	Scala Sets ชุดคือชุดขององค์ประกอบประเภทเดียวกันที่แตกต่างกันเป็นคู่ ๆ
3	Scala Maps แผนที่คือชุดของคู่คีย์ / ค่า สามารถเรียกดูค่าใดก็ได้ตามคีย์
4	Scala Tuples ทูเปิลสามารถเก็บวัตถุที่มีประเภทต่างๆได้ไม่เหมือนอาร์เรย์หรือรายการ
5	Scala Options ตัวเลือก [T] จัดเตรียมคอนเทนเนอร์สำหรับศูนย์หรือองค์ประกอบหนึ่งของประเภทที่กำหนด
6	Scala Iterators ตัววนซ้ำไม่ใช่คอลเล็กชัน แต่เป็นวิธีเข้าถึงองค์ประกอบของคอลเล็กชันทีละรายการ

สามารถติดตั้ง Scala บนระบบ UNIX หรือระบบที่ใช้ Windows ก่อนที่คุณจะเริ่มติดตั้ง Scala บนเครื่องของคุณคุณต้องติดตั้ง Java 1.8 ขึ้นไปบนคอมพิวเตอร์ของคุณ

ทำตามขั้นตอนด้านล่างเพื่อติดตั้ง Scala

ขั้นตอนที่ 1: ตรวจสอบการติดตั้ง Java ของคุณ

ก่อนอื่นคุณต้องติดตั้ง Java Software Development Kit (SDK) ในระบบของคุณ ในการตรวจสอบสิ่งนี้ให้ดำเนินการสองคำสั่งต่อไปนี้ขึ้นอยู่กับแพลตฟอร์มที่คุณกำลังทำงานอยู่

หากการติดตั้ง Java ทำได้อย่างถูกต้องการติดตั้งจะแสดงเวอร์ชันปัจจุบันและข้อมูลจำเพาะของการติดตั้ง Java ของคุณ ตัวอย่างผลลัพธ์จะได้รับในตารางต่อไปนี้

แพลตฟอร์ม	คำสั่ง	ตัวอย่างผลลัพธ์
Windows	เปิด Command Console แล้วพิมพ์ - \>java -version	เวอร์ชัน Java "1.8.0_31" เวลารัน Java (TM) SE สภาพแวดล้อม (รุ่น 1.8.0_31-b31) Java Hotspot (TM) เซิร์ฟเวอร์ 64 บิต VM (สร้าง 25.31-b07 โหมดผสม)
ลินุกซ์	เปิด Command Terminal แล้วพิมพ์ - $java -version	เวอร์ชัน Java "1.8.0_31" เปิด JDK Runtime Environment (rhel-2.8.10.4.el6_4-x86_64) เปิด JDK 64-Bit Server VM (สร้าง 25.31-b07 โหมดผสม)

เราถือว่าผู้อ่านบทช่วยสอนนี้มี Java SDK เวอร์ชัน 1.8.0_31 ติดตั้งอยู่ในระบบ

ในกรณีที่คุณไม่มี Java SDK ให้ดาวน์โหลดเวอร์ชันปัจจุบันจากไฟล์ https://www.oracle.com/technetwork/java/javase/downloads/index.html และติดตั้ง

ขั้นตอนที่ 2: ตั้งค่าสภาพแวดล้อม Java ของคุณ

ตั้งค่าตัวแปรสภาพแวดล้อม JAVA_HOME ให้ชี้ไปยังตำแหน่งไดเร็กทอรีฐานที่ติดตั้ง Java บนเครื่องของคุณ ตัวอย่างเช่น,

ซีเนียร์ No	แพลตฟอร์มและคำอธิบาย
1	Windows ตั้งค่า JAVA_HOME เป็น C: \ ProgramFiles \ java \ jdk1.8.0_31
2	Linux ส่งออก JAVA_HOME = / usr / local / java-current

ผนวกพา ธ แบบเต็มของตำแหน่งคอมไพเลอร์ Java เข้ากับ System Path

ซีเนียร์ No	แพลตฟอร์มและคำอธิบาย
1	Windows ต่อท้าย String "C: \ Program Files \ Java \ jdk1.8.0_31 \ bin" ต่อท้ายตัวแปรระบบ PATH
2	Linux ส่งออกเส้นทาง = $ PATH: $ JAVA_HOME / bin /

ดำเนินการคำสั่ง java -version จากพรอมต์คำสั่งตามที่อธิบายไว้ข้างต้น

ขั้นตอนที่ 3: ติดตั้ง Scala

คุณสามารถดาวน์โหลด Scala จากwww.scala-lang.org/downloads ในขณะที่เขียนบทช่วยสอนนี้ฉันดาวน์โหลด 'scala-2.13.1-installer.jar' ตรวจสอบว่าคุณมีสิทธิ์ระดับผู้ดูแลระบบเพื่อดำเนินการต่อ ตอนนี้ดำเนินการคำสั่งต่อไปนี้ที่พรอมต์คำสั่ง -

แพลตฟอร์ม	คำสั่งและเอาต์พุต	คำอธิบาย
Windows	\> java -jar scala-2.13.1-installer.jar \>	คำสั่งนี้จะแสดงวิซาร์ดการติดตั้งซึ่งจะแนะนำให้คุณติดตั้ง Scala บนเครื่อง windows ของคุณ ในระหว่างการติดตั้งระบบจะขอข้อตกลงสิทธิ์การใช้งานเพียงยอมรับและต่อไปจะถามเส้นทางที่จะติดตั้ง Scala ฉันเลือกเส้นทางที่กำหนดเป็นค่าเริ่มต้น"C: \ Program Files \ Scala"คุณสามารถเลือกเส้นทางที่เหมาะสมได้ตามความสะดวกของคุณ
ลินุกซ์	Command - $ java -jar scala-2.13.1-installer.jar Output - ยินดีต้อนรับสู่การติดตั้ง Scala 2.13.1! โฮมเพจอยู่ที่ - http://Scala-lang.org/ กด 1 เพื่อดำเนินการต่อ, 2 เพื่อออก, 3 เพื่อแสดงซ้ำ 1 ................................................ [เริ่มแกะกล่อง] [แพ็คเกจการประมวลผล: การติดตั้งแพ็คเกจซอฟต์แวร์ (1/1)] [แกะกล่องเสร็จแล้ว] [ติดตั้งคอนโซลเสร็จแล้ว]	ระหว่างการติดตั้งระบบจะขอข้อตกลงสิทธิ์การใช้งานเพื่อยอมรับประเภท 1 และจะถามเส้นทางที่จะติดตั้ง Scala ฉันป้อน/ usr / local / shareคุณสามารถเลือกเส้นทางที่เหมาะสมได้ตามความสะดวกของคุณ

สุดท้ายเปิดพรอมต์คำสั่งใหม่แล้วพิมพ์ Scala -versionแล้วกด Enter คุณควรเห็นสิ่งต่อไปนี้ -

แพลตฟอร์ม	คำสั่ง	เอาต์พุต
Windows	\> รุ่น scala	Scala code runner เวอร์ชัน 2.13.1 - ลิขสิทธิ์ 2002-2019, LAMP / EPFL และ Lightbend, Inc.
ลินุกซ์	$ scala - รุ่น	Scala code runner เวอร์ชัน 2.13.1 - ลิขสิทธิ์ 2002-2019, LAMP / EPFL และ Lightbend, Inc.tut

Scala จัดเตรียมโครงสร้างข้อมูลไฟล์ arrayซึ่งเก็บคอลเลกชันตามลำดับขนาดคงที่ขององค์ประกอบประเภทเดียวกัน อาร์เรย์ใช้ในการจัดเก็บชุดข้อมูล แต่มักจะมีประโยชน์มากกว่าที่จะคิดว่าอาร์เรย์เป็นชุดของตัวแปรประเภทเดียวกัน

แทนที่จะประกาศตัวแปรเดี่ยวเช่น number0, number1, ... และ number99 คุณประกาศตัวแปรอาร์เรย์หนึ่งตัวเช่นตัวเลขและใช้ตัวเลข [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

Scala ไม่สนับสนุนการดำเนินการอาร์เรย์ต่างๆโดยตรงและมีวิธีการต่างๆในการประมวลผลอาร์เรย์ในมิติใด ๆ หากคุณต้องการใช้วิธีการต่างๆจำเป็นต้องนำเข้า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

ใช้วิธี range () เพื่อสร้างอาร์เรย์ที่มีลำดับของจำนวนเต็มที่เพิ่มขึ้นในช่วงที่กำหนด คุณสามารถใช้อาร์กิวเมนต์สุดท้ายเป็นขั้นตอนในการสร้างลำดับ หากคุณไม่ใช้อาร์กิวเมนต์สุดท้ายขั้นตอนจะถือว่าเป็น 1

ให้เรายกตัวอย่างการสร้างอาร์เรย์ของช่วง (10, 20, 2): หมายถึงการสร้างอาร์เรย์ที่มีองค์ประกอบระหว่าง 10 ถึง 20 และความแตกต่างของช่วง 2 องค์ประกอบในอาร์เรย์คือ 10, 12, 14, 16 และ 18 .

อีกตัวอย่างหนึ่ง: ช่วง (10, 20) ความแตกต่างของช่วงที่นี่จะไม่ได้รับดังนั้นโดยค่าเริ่มต้นจะถือว่า 1 องค์ประกอบ สร้างอาร์เรย์ที่มีองค์ประกอบอยู่ระหว่าง 10 ถึง 20 โดยมีความแตกต่างของช่วง 1. องค์ประกอบในอาร์เรย์คือ 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

Scala จัดเตรียมโครงสร้างข้อมูลไฟล์ ArrayBufferซึ่งสามารถเปลี่ยนขนาดได้เมื่อขนาดเริ่มต้นสั้นลง เนื่องจากอาร์เรย์มีขนาดฟิกซ์และไม่สามารถใช้องค์ประกอบอื่น ๆ ในอาร์เรย์ได้ ArrayBuffer จึงเป็นอีกทางเลือกหนึ่งของอาร์เรย์ที่ขนาดมีความยืดหยุ่น

ArrayBuffer ภายในจะรักษาอาร์เรย์ของขนาดปัจจุบันเพื่อจัดเก็บองค์ประกอบ เมื่อมีการเพิ่มองค์ประกอบใหม่ขนาดจะถูกตรวจสอบ ในกรณีที่อาร์เรย์พื้นฐานเต็มแล้วจะมีการสร้างอาร์เรย์ขนาดใหญ่ขึ้นใหม่และองค์ประกอบทั้งหมดจะถูกคัดลอกไปยังอาร์เรย์ที่มีขนาดใหญ่ขึ้น

การประกาศตัวแปร ArrayBuffer

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร ArrayBuffer

ไวยากรณ์

var z = ArrayBuffer[String]()

ที่นี่ z ถูกประกาศว่าเป็นอาร์เรย์บัฟเฟอร์ของ Strings ซึ่งในตอนแรกว่างเปล่า สามารถเพิ่มค่าได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

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

Scala Lists ค่อนข้างคล้ายกับอาร์เรย์ซึ่งหมายความว่าองค์ประกอบทั้งหมดของรายการมีประเภทเดียวกัน แต่มีความแตกต่างที่สำคัญสองประการ ประการแรกรายการไม่เปลี่ยนรูปซึ่งหมายความว่าองค์ประกอบของรายการไม่สามารถเปลี่ยนแปลงได้โดยการมอบหมาย ประการที่สองรายการแสดงถึงรายการที่เชื่อมโยงในขณะที่อาร์เรย์แบน

ประเภทของรายการที่มีองค์ประกอบประเภท 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. Nil ยังแสดงถึงรายการว่าง รายการทั้งหมดข้างต้นสามารถกำหนดได้ดังต่อไปนี้

// 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

การดำเนินการขั้นพื้นฐานในรายการ

การดำเนินการทั้งหมดในรายการสามารถแสดงในรูปแบบของสามวิธีต่อไปนี้

ซีเนียร์ No	วิธีการและคำอธิบาย
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.:::() วิธีการหรือ List.concat()วิธีการเพิ่มสองรายการขึ้นไป โปรดดูตัวอย่างต่อไปนี้ด้านล่าง -

ตัวอย่าง

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

คำสั่ง

\>scalac Demo.scala
\>scala Demo

เอาต์พุต

fruit1 ::: fruit2 : List(apples, oranges, pears, mangoes, banana)
fruit1.:::(fruit2) : List(mangoes, banana, apples, oranges, pears)
List.concat(fruit1, fruit2) : List(apples, oranges, pears, mangoes, banana)

การสร้างรายการเครื่องแบบ

คุณสามารถใช้ได้ 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)

Scala จัดเตรียมโครงสร้างข้อมูลไฟล์ ListBufferซึ่งมีประสิทธิภาพมากกว่า List ในขณะที่เพิ่ม / ลบองค์ประกอบในรายการ มีวิธีการในการต่อท้ายผนวกองค์ประกอบเข้ากับรายการ

การประกาศตัวแปร ListBuffer

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร ListBuffer

ไวยากรณ์

var z = ListBuffer[String]()

ที่นี่ z ถูกประกาศว่าเป็น list-buffer ของ Strings ซึ่งในตอนแรกว่างเปล่า สามารถเพิ่มค่าได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

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

Scala Set คือชุดขององค์ประกอบประเภทเดียวกันที่แตกต่างกันเป็นคู่ ๆ กล่าวอีกนัยหนึ่งชุดคือคอลเล็กชันที่ไม่มีองค์ประกอบซ้ำกัน ListSet ใช้ชุดที่ไม่เปลี่ยนรูปและใช้โครงสร้างรายการ ลำดับการแทรกองค์ประกอบจะถูกเก็บรักษาไว้ในขณะที่จัดเก็บองค์ประกอบ

การประกาศตัวแปร ListSet

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร ListSet

ไวยากรณ์

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

ที่นี่ z ถูกประกาศเป็นชุดสตริงรายการซึ่งมีสมาชิกสามคน สามารถเพิ่มค่าได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

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

การประมวลผล ListSet

ด้านล่างนี้เป็นโปรแกรมตัวอย่างในการแสดงวิธีการสร้างเริ่มต้นและประมวลผล ListSet -

ตัวอย่าง

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()

Scala Vector เป็นโครงสร้างข้อมูลที่ไม่เปลี่ยนรูปสำหรับวัตถุประสงค์ทั่วไปที่องค์ประกอบต่างๆสามารถเข้าถึงได้แบบสุ่ม โดยทั่วไปจะใช้สำหรับการรวบรวมข้อมูลจำนวนมาก

การประกาศตัวแปรเวกเตอร์

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร Vector

ไวยากรณ์

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

ที่นี่ z ถูกประกาศเป็นเวกเตอร์ของ Strings ซึ่งมีสมาชิกสามคน สามารถเพิ่มค่าได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

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

กำลังประมวลผลเวกเตอร์

ด้านล่างนี้เป็นโปรแกรมตัวอย่างในการแสดงวิธีสร้างเริ่มต้นและประมวลผล Vector -

ตัวอย่าง

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)

Scala Set คือชุดขององค์ประกอบประเภทเดียวกันที่แตกต่างกันเป็นคู่ ๆ กล่าวอีกนัยหนึ่งชุดคือคอลเล็กชันที่ไม่มีองค์ประกอบซ้ำกัน ชุดมีสองประเภทคือimmutable และ mutable. ความแตกต่างระหว่างวัตถุที่เปลี่ยนแปลงไม่ได้และไม่เปลี่ยนรูปก็คือเมื่อวัตถุไม่เปลี่ยนรูปวัตถุนั้นจะไม่สามารถเปลี่ยนแปลงได้

ตามค่าเริ่มต้น Scala จะใช้ชุดที่ไม่เปลี่ยนรูป หากคุณต้องการใช้ชุดที่เปลี่ยนได้คุณจะต้องนำเข้า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)

ในขณะที่กำหนดชุดว่างคำอธิบายประกอบประเภทเป็นสิ่งที่จำเป็นเนื่องจากระบบจำเป็นต้องกำหนดชนิดคอนกรีตให้กับตัวแปร

การใช้งานพื้นฐานในชุด

การดำเนินการทั้งหมดในชุดสามารถแสดงในรูปแบบของสามวิธีต่อไปนี้ -

ซีเนียร์ No	วิธีการและคำอธิบาย
1	head วิธีนี้ส่งคืนองค์ประกอบแรกของชุด
2	tail วิธีนี้ส่งคืนชุดที่ประกอบด้วยองค์ประกอบทั้งหมดยกเว้นรายการแรก
3	isEmpty เมธอดนี้จะคืนค่า true หากเซตว่างหรือเป็นเท็จ

ลองใช้ตัวอย่างต่อไปนี้แสดงการใช้วิธีการปฏิบัติงานพื้นฐาน -

ตัวอย่าง

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)

ค้นหา Max, Min Elements ในชุด

คุณสามารถใช้ได้ 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

ค้นหาค่านิยมทั่วไป Insets

คุณสามารถใช้อย่างใดอย่างหนึ่ง 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)

Bitset เป็นคลาสพื้นฐานทั่วไปสำหรับบิตเซ็ตที่เปลี่ยนแปลงได้และไม่เปลี่ยนรูป บิตเซ็ตคือชุดของจำนวนเต็มที่ไม่เป็นลบและแสดงเป็นอาร์เรย์ขนาดตัวแปรของบิตที่บรรจุในคำ 64 บิต รอยเท้าหน่วยความจำของบิตเซ็ตแสดงด้วยจำนวนที่มากที่สุดที่จัดเก็บไว้ในนั้น

การประกาศตัวแปร BitSet

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร BitSet

ไวยากรณ์

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

ในที่นี้ z ถูกประกาศว่าเป็นบิตเซตของจำนวนเต็มที่ไม่เป็นลบซึ่งมีสมาชิกสามตัว สามารถเพิ่มค่าได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

var myList1: BitSet = myList + 3;

กำลังประมวลผล BitSet

ด้านล่างนี้เป็นโปรแกรมตัวอย่างในการแสดงวิธีการสร้างเริ่มต้นและประมวลผล 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)

Scala Set คือชุดขององค์ประกอบประเภทเดียวกันที่แตกต่างกันเป็นคู่ ๆ กล่าวอีกนัยหนึ่งชุดคือคอลเล็กชันที่ไม่มีองค์ประกอบซ้ำกัน HashSet ใช้ชุดที่ไม่เปลี่ยนรูปและใช้ตารางแฮช ลำดับการแทรกองค์ประกอบไม่ได้รับการรักษาไว้

การประกาศตัวแปร HashSet

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร HashSet

ไวยากรณ์

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

ที่นี่ z ถูกประกาศว่าเป็นชุดแฮชของสตริงซึ่งมีสมาชิกสามคน สามารถเพิ่มค่าได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

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

กำลังประมวลผล HashSet

ด้านล่างนี้เป็นโปรแกรมตัวอย่างในการแสดงวิธีสร้างเริ่มต้นและประมวลผล HashSet -

ตัวอย่าง

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()

Scala Set คือชุดขององค์ประกอบประเภทเดียวกันที่แตกต่างกันเป็นคู่ ๆ กล่าวอีกนัยหนึ่งชุดคือคอลเล็กชันที่ไม่มีองค์ประกอบซ้ำกัน TreeSet ใช้ชุดที่ไม่เปลี่ยนรูปและเก็บองค์ประกอบตามลำดับ

การประกาศตัวแปร TreeSet

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร TreeSet

ไวยากรณ์

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

ที่นี่ z ถูกประกาศให้เป็นชุดสตริงแบบต้นไม้ซึ่งมีสมาชิกสามคน สามารถเพิ่มค่าได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

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

กำลังประมวลผล TreeSet

ด้านล่างนี้เป็นโปรแกรมตัวอย่างในการแสดงวิธีสร้างเริ่มต้นและประมวลผล TreeSet -

ตัวอย่าง

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()

แผนที่ Scala คือชุดของคู่คีย์ / ค่า สามารถเรียกดูค่าใดก็ได้ตามคีย์ คีย์ไม่ซ้ำกันในแผนที่ แต่ค่าไม่จำเป็นต้องซ้ำกัน แผนที่เรียกอีกอย่างว่าตารางแฮช แผนที่มีสองประเภทคือimmutable และ mutable. ความแตกต่างระหว่างวัตถุที่เปลี่ยนแปลงไม่ได้และไม่เปลี่ยนรูปก็คือเมื่อวัตถุไม่เปลี่ยนรูปวัตถุนั้นจะไม่สามารถเปลี่ยนแปลงได้

ตามค่าเริ่มต้น Scala จะใช้แผนที่ที่ไม่เปลี่ยนรูป หากคุณต้องการใช้แผนที่ที่เปลี่ยนแปลงได้คุณจะต้องนำเข้า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)

การทำงานพื้นฐานบนแผนที่

การดำเนินการทั้งหมดบนแผนที่สามารถแสดงได้ในสามวิธีต่อไปนี้

ซีเนียร์ No	วิธีการและคำอธิบาย
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

การเชื่อมต่อแผนที่

คุณสามารถใช้อย่างใดอย่างหนึ่ง ++ ตัวดำเนินการหรือ Map.++() วิธีการเชื่อมต่อแผนที่ตั้งแต่สองแผนที่ขึ้นไป แต่ในขณะที่เพิ่มแผนที่จะเป็นการลบคีย์ที่ซ้ำกันออกไป

ลองใช้โปรแกรมตัวอย่างต่อไปนี้เพื่อเชื่อมสองแผนที่เข้าด้วยกัน

ตัวอย่าง

object Demo {
   def main(args: Array[String]) {
      val colors1 = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      val colors2 = Map(
         "blue" -> "#0033FF", "yellow" -> "#FFFF00", "red" -> "#FF0000"
      )
      // use two or more Maps with ++ as operator
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )
      // use two maps with ++ as method
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )
   }
}

คำสั่ง

\>scalac Demo.scala
\>scala Demo

เอาต์พุต

colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

พิมพ์คีย์และค่าจากแผนที่

คุณสามารถวนซ้ำผ่านคีย์และค่าของแผนที่โดยใช้ลูป "foreach" ที่นี่เราใช้วิธีการ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

แผนที่ Scala คือชุดของคู่คีย์ / ค่า สามารถเรียกดูค่าใดก็ได้ตามคีย์ คีย์ไม่ซ้ำกันในแผนที่ แต่ค่าไม่จำเป็นต้องซ้ำกัน HashMap ใช้แผนที่ที่ไม่เปลี่ยนรูปและใช้ตารางแฮชเพื่อใช้งานแบบเดียวกัน

การประกาศตัวแปร HashMap

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร HashMap

ไวยากรณ์

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

ในที่นี้จะมีการประกาศสีเป็นแฮชแมปของสตริงซึ่งเป็น Int ซึ่งมีคู่คีย์ - ค่าสามคู่ สามารถเพิ่มค่าได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

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

กำลังประมวลผล HashMap

ด้านล่างนี้เป็นโปรแกรมตัวอย่างที่แสดงวิธีการสร้างเริ่มต้นและประมวลผล 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()

แผนที่ Scala คือชุดของคู่คีย์ / ค่า สามารถเรียกดูค่าใดก็ได้ตามคีย์ คีย์ไม่ซ้ำกันในแผนที่ แต่ค่าไม่จำเป็นต้องซ้ำกัน ListMap ใช้แผนที่ที่ไม่เปลี่ยนรูปและใช้รายการเพื่อใช้งานแบบเดียวกัน ใช้กับองค์ประกอบจำนวนน้อย

การประกาศตัวแปร ListMap

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร ListMap

ไวยากรณ์

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

คำสั่ง

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

กำลังดำเนินการรายการแผนที่

ด้านล่างนี้เป็นโปรแกรมตัวอย่างในการแสดงวิธีสร้างเริ่มต้นและประมวลผล ListMap -

ตัวอย่าง

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 วิธี.

วิธีที่ตรงไปตรงมาที่สุดในการ "ก้าวผ่าน" องค์ประกอบทั้งหมดที่ส่งคืนโดยตัววนซ้ำคือการใช้ while loop ให้เราทำตามโปรแกรมตัวอย่างต่อไปนี้

ตัวอย่าง

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

Scala Option [T] คือคอนเทนเนอร์สำหรับศูนย์หรือองค์ประกอบหนึ่งของประเภทที่กำหนด ตัวเลือก [T] สามารถเป็นได้Some[T] หรือ Noneวัตถุซึ่งแสดงถึงค่าที่ขาดหายไป ตัวอย่างเช่นเมธอด get ของ Scala's Map จะสร้าง Some (value) หากพบค่าที่ตรงกับคีย์ที่กำหนดหรือNone หากไม่ได้กำหนดคีย์ที่กำหนดไว้ในแผนที่

ประเภทตัวเลือกถูกใช้บ่อยในโปรแกรม Scala และคุณสามารถเปรียบเทียบสิ่งนี้กับไฟล์ nullค่าที่มีอยู่ใน Java ซึ่งระบุว่าไม่มีค่า ตัวอย่างเช่นเมธอด get ของ java.util.HashMap จะส่งคืนค่าที่เก็บไว้ใน HashMap หรือ null หากไม่พบค่า

สมมติว่าเรามีวิธีการดึงข้อมูลจากฐานข้อมูลโดยใช้คีย์หลัก

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 () วิธีการ

ต่อไปนี้เป็นโปรแกรมตัวอย่างเพื่อแสดงวิธีการใช้ isEmpty () method เพื่อตรวจสอบว่าตัวเลือกนั้นเป็น None หรือไม่

ตัวอย่าง

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

Queue เป็นโครงสร้างข้อมูลแบบเข้าก่อนออกก่อน FIFO และอนุญาตให้แทรกและดึงข้อมูลองค์ประกอบในลักษณะ FIFO

การประกาศตัวแปรคิว

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปรคิว

ไวยากรณ์

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

Scala tuple รวมจำนวนคงที่ของรายการเข้าด้วยกันเพื่อให้สามารถส่งต่อได้โดยรวม ซึ่งแตกต่างจากอาร์เรย์หรือรายการทูเปิลสามารถเก็บวัตถุที่มีประเภทต่างๆได้ แต่ก็ไม่เปลี่ยนรูปเช่นกัน

ต่อไปนี้เป็นตัวอย่างของทูเพิลที่มีจำนวนเต็มสตริงและคอนโซล

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

ซึ่งเป็นน้ำตาลซินแทติก (ชอร์ตคัท) ดังนี้ -

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

ประเภทที่แท้จริงของทูเปิลขึ้นอยู่กับจำนวนและองค์ประกอบที่มีและประเภทขององค์ประกอบเหล่านั้น ดังนั้นประเภทของ (99, "Luftballons") คือ Tuple2 [Int, String] ประเภทของ ('u', 'r', "the", 1, 4, "me") คือ Tuple6 [Char, Char, String, Int, Int, String]

ทูเปิลเป็นประเภท Tuple1, Tuple2, Tuple3 และอื่น ๆ ขณะนี้มีขีด จำกัด สูงสุดที่ 22 ใน Scala หากคุณต้องการมากกว่านั้นคุณสามารถใช้คอลเลคชันไม่ใช่ทูเปิล สำหรับ TupleN แต่ละประเภทโดยที่ 1 <= N <= 22 Scala จะกำหนดวิธีการเข้าถึงองค์ประกอบจำนวนหนึ่ง ให้คำจำกัดความต่อไปนี้ -

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

ในการเข้าถึงองค์ประกอบของทูเปิล t คุณสามารถใช้เมธอด t._1 เพื่อเข้าถึงองค์ประกอบแรก t._2 เพื่อเข้าถึงองค์ประกอบที่สองและอื่น ๆ ตัวอย่างเช่นนิพจน์ต่อไปนี้คำนวณผลรวมขององค์ประกอบทั้งหมดของ t

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

คุณสามารถใช้ Tuple เพื่อเขียนเมธอดที่ใช้ List [Double] และส่งคืนจำนวนผลรวมและผลรวมของกำลังสองที่ส่งคืนใน Tuple สามองค์ประกอบ a 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

วนซ้ำบน Tuple

คุณสามารถใช้ได้ 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

กำลังแปลงเป็น String

คุณสามารถใช้ได้ Tuple.toString()วิธีการเชื่อมต่อองค์ประกอบทั้งหมดของทูเปิลเป็นสตริง ลองใช้โปรแกรมตัวอย่างต่อไปนี้เพื่อแปลงเป็น String

ตัวอย่าง

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

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร Seq

ไวยากรณ์

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

ในที่นี้ seq ถูกประกาศเป็น Seq of numbers Seq มีคำสั่งดังต่อไปนี้ -

คำสั่ง

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

กำลังประมวลผล Seq

ด้านล่างนี้เป็นโปรแกรมตัวอย่างในการแสดงวิธีการสร้างเริ่มต้นและประมวลผล 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)

Stack คือ Last In First Out โครงสร้างข้อมูล LIFO และอนุญาตให้แทรกและดึงข้อมูลองค์ประกอบที่ด้านบนในลักษณะ LIFO

การประกาศตัวแปรสแตก

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร Stack

ไวยากรณ์

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

ที่นี่สแต็กถูกประกาศเป็นสแต็คของตัวเลข สามารถเพิ่มมูลค่าที่ด้านบนได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

stack.push(6)

สามารถดึงค่าจากด้านบนได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

stack.top

ค่าสามารถลบออกจากด้านบนได้โดยใช้คำสั่งดังต่อไปนี้ -

คำสั่ง

stack.pop

กองการประมวลผล

ด้านล่างนี้เป็นโปรแกรมตัวอย่างในการแสดงวิธีสร้างเริ่มต้นและประมวลผล Stack -

ตัวอย่าง

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

Scala Stream เป็นรายการพิเศษที่มีคุณลักษณะการประเมินแบบขี้เกียจ ในสตรีมสกาลาองค์ประกอบต่างๆจะได้รับการประเมินเมื่อจำเป็นเท่านั้น สตรีมรองรับการคำนวณแบบขี้เกียจและเข้าใจประสิทธิภาพ

การประกาศตัวแปรสตรีม

ต่อไปนี้เป็นไวยากรณ์สำหรับการประกาศตัวแปร Stream

ไวยากรณ์

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

ที่นี่สตรีมถูกประกาศว่าเป็นสตรีมของตัวเลข ที่นี่ 1 คือหัวสตรีม 2, 3 คือหางของสตรีม Stream.empty ทำเครื่องหมายจุดสิ้นสุดของสตรีม สามารถเรียกดูค่าได้โดยใช้คำสั่ง take ดังต่อไปนี้ -

คำสั่ง

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()

drop () method เป็นวิธีที่ List ใช้เพื่อเลือกองค์ประกอบทั้งหมดยกเว้น n องค์ประกอบแรกของรายการ

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการวาง

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

ในที่นี้ n คือจำนวนองค์ประกอบที่จะทิ้งจากรายการ วิธีนี้จะคืนค่าองค์ประกอบทั้งหมดของรายการยกเว้น n รายการแรก

การใช้งาน

ด้านล่างนี้เป็นโปรแกรมตัวอย่างการแสดงวิธีใช้ drop method -

ตัวอย่าง

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 () method เป็นวิธีการที่ List ใช้เพื่อดร็อปองค์ประกอบทั้งหมดที่ตรงตามเงื่อนไขที่กำหนด

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของเมธอด dropWhile

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

ที่นี่ p: (A) => บูลีนเป็นเพรดิเคตหรือเงื่อนไขที่จะใช้กับแต่ละองค์ประกอบของรายการ วิธีนี้จะคืนค่าองค์ประกอบทั้งหมดของรายการยกเว้นรายการที่ตกหล่น

การใช้งาน

ด้านล่างนี้เป็นโปรแกรมตัวอย่างการแสดงวิธีใช้ dropWhile method -

ตัวอย่าง

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)

find () method เป็นวิธีที่ Iterators ใช้เพื่อค้นหาองค์ประกอบที่ตรงตามเพรดิเคตที่กำหนด

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการค้นหา

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

ที่นี่ p: (A) => บูลีนเป็นเพรดิเคตหรือเงื่อนไขที่จะใช้กับแต่ละองค์ประกอบของตัววนซ้ำ วิธีนี้ส่งคืนองค์ประกอบ Option ที่มีองค์ประกอบที่ตรงกันของตัววนซ้ำซึ่งเป็นไปตามเงื่อนไขที่กำหนด

การใช้งาน

ด้านล่างนี้เป็นตัวอย่างโปรแกรมแสดงวิธีใช้ find method -

ตัวอย่าง

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 () method เป็นวิธี TraversableLike trait โดยใช้เพรดิเคตใช้กับแต่ละองค์ประกอบของคอลเล็กชันและส่งกลับคอลเล็กชันองค์ประกอบใหม่ที่ส่งคืนโดยเพรดิเคต

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธี flatMap

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

ที่นี่ f: (A)? GenTraversableOnce [B] คือเพรดิเคตหรือเงื่อนไขที่จะใช้กับแต่ละองค์ประกอบของคอลเลกชัน วิธีนี้ส่งคืนองค์ประกอบ Option ที่มีองค์ประกอบที่ตรงกันของตัววนซ้ำซึ่งเป็นไปตามเงื่อนไขที่กำหนด

การใช้งาน

ด้านล่างนี้เป็นโปรแกรมตัวอย่างการแสดงวิธีการใช้วิธี flatMap -

ตัวอย่าง

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)

วิธีการ flatten () เป็นลักษณะสมาชิก 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)

fold () method เป็นสมาชิกของ TraversableOnce trait ใช้เพื่อยุบองค์ประกอบของคอลเลกชัน

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการพับ

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 () method เป็นสมาชิกของ TraversableOnce trait ซึ่งจะใช้เพื่อยุบองค์ประกอบของคอลเลกชัน มันนำทางองค์ประกอบจากซ้ายไปขวาตามลำดับ ส่วนใหญ่จะใช้ในฟังก์ชันแบบเรียกซ้ำและป้องกันข้อยกเว้นของสแตกล้น

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการพับ

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

ที่นี่เมธอด foldLeft ใช้ฟังก์ชันตัวดำเนินการไบนารีที่เชื่อมโยงเป็นพารามิเตอร์ วิธีนี้จะส่งคืนผลลัพธ์เป็นค่า

การใช้งาน

ด้านล่างนี้เป็นโปรแกรมตัวอย่างการแสดงวิธีใช้วิธี 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 () method เป็นสมาชิกของ TraversableOnce trait ซึ่งใช้เพื่อยุบองค์ประกอบของคอลเลกชัน มันนำทางองค์ประกอบจากขวาไปซ้ายตามลำดับ

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของเมธอด foldRight

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

วิธีการพับใช้ฟังก์ชันตัวดำเนินการไบนารีที่เชื่อมโยงเป็นพารามิเตอร์ วิธีนี้ส่งคืนค่าผลลัพธ์

การใช้งาน

ด้านล่างนี้เป็นโปรแกรมตัวอย่างการแสดงวิธีใช้เมธอด foldRight -

ตัวอย่าง

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 เป็นค่าเริ่มต้นไปยังฟังก์ชัน foldRight จากนั้นค่าทั้งหมดจะถูกเพิ่ม บันทึกโปรแกรมข้างต้นในDemo.scala. คำสั่งต่อไปนี้ใช้เพื่อคอมไพล์และรันโปรแกรมนี้

คำสั่ง

\>scalac Demo.scala
\>scala Demo

เอาต์พุต

map () method เป็นสมาชิกของ TraversableLike trait ซึ่งใช้เพื่อเรียกใช้เมธอดเพรดิเคตในแต่ละองค์ประกอบของคอลเล็กชัน ส่งคืนคอลเล็กชันใหม่

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีแผนที่

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

ที่นี่เมธอดแผนที่ใช้ฟังก์ชัน prediate เป็นพารามิเตอร์ วิธีนี้ส่งคืนคอลเล็กชันที่อัปเดต

การใช้งาน

ด้านล่างนี้เป็นโปรแกรมตัวอย่างการแสดงวิธีใช้ map method -

ตัวอย่าง

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)

partition () method เป็นสมาชิกของ TraversableLike trait ซึ่งใช้เพื่อรันเมธอดเพรดิเคตในแต่ละองค์ประกอบของคอลเล็กชัน ส่งคืนสองคอลเลกชันโดยคอลเลกชันหนึ่งเป็นองค์ประกอบที่ตอบสนองฟังก์ชันเพรดิเคตที่กำหนดและอีกคอลเลกชันหนึ่งเป็นองค์ประกอบที่ไม่ตรงตามฟังก์ชันเพรดิเคต

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีแผนที่

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

ที่นี่วิธีการแบ่งพาร์ติชันใช้ฟังก์ชัน prediate เป็นพารามิเตอร์ วิธีนี้ส่งคืนคอลเล็กชัน

การใช้งาน

ด้านล่างนี้เป็นตัวอย่างโปรแกรมแสดงวิธีการใช้งานวิธีการแบ่งพาร์ติชัน -

ตัวอย่าง

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)

วิธีการลด () เป็นสมาชิกของ TraversableOnce trait ซึ่งใช้เพื่อยุบองค์ประกอบของคอลเล็กชัน คล้ายกับวิธีการพับ แต่ไม่ใช้ค่าเริ่มต้น

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการลด

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

เอาต์พุต

scan () method เป็นสมาชิกของ TraversableLike trait ซึ่งคล้ายกับวิธีการพับ แต่ใช้เพื่อใช้การดำเนินการกับแต่ละองค์ประกอบของคอลเลกชันและส่งคืนคอลเล็กชัน

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการพับ

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 () method เป็นสมาชิกของ IterableLike trait ซึ่งใช้เพื่อรวมคอลเล็กชันกับคอลเล็กชันปัจจุบันและผลลัพธ์คือคอลเล็กชันคู่ขององค์ประกอบทูเปิลจากทั้งสองคอลเล็กชัน

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของวิธีการ zip

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

ที่นี่วิธีการ zip รับคอลเลกชันเป็นพารามิเตอร์ วิธีนี้ส่งคืนคอลเลคชันที่อัปเดตของคู่ตามผลลัพธ์

การใช้งาน

ด้านล่างนี้เป็นโปรแกรมตัวอย่างการแสดงวิธีใช้ zip method -

ตัวอย่าง

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))