Scala Koleksiyonları - Hızlı Kılavuz

Scala, zengin bir koleksiyon kitaplığına sahiptir. Koleksiyonlar, nesnelerin kapsayıcılarıdır. Bu kaplar sıralı olabilir, Liste, Tuple, Seçenek, Harita, vb. Gibi öğelerin doğrusal kümeleri olabilir. Koleksiyonlar, rastgele sayıda öğeye sahip olabilir veya sıfır veya bir öğeye (örn., Seçenek) sınırlandırılabilir.

Koleksiyonlar olabilir strict veya lazy. Tembel koleksiyonlar, erişilene kadar hafızayı tüketmeyecek öğelere sahiptir.Ranges. Ek olarak koleksiyonlar olabilirmutable (referansın içeriği değişebilir) veya immutable(bir referansın ifade ettiği şey asla değişmez). Değişmez koleksiyonların değiştirilebilir öğeler içerebileceğini unutmayın.

Bazı problemler için değiştirilebilir koleksiyonlar daha iyi çalışır ve diğerleri için değişmez koleksiyonlar daha iyi çalışır. Şüpheye düştüğünüzde, değişmez bir koleksiyonla başlamak ve değiştirilebilir olanlara ihtiyacınız varsa daha sonra değiştirmek daha iyidir.

Bu bölüm, en sık kullanılan koleksiyon türlerine ve bu koleksiyonlar üzerinde en sık kullanılan işlemlere ışık tutmaktadır.

Sr.No	Açıklamalı Koleksiyonlar
1	Scala Lists Scala Listesi [T], T türünün bağlantılı bir listesidir.
2	Scala Sets Bir küme, aynı türden ikili farklı elemanların bir koleksiyonudur.
3	Scala Maps Harita, anahtar / değer çiftlerinden oluşan bir koleksiyondur. Herhangi bir değer, anahtarına bağlı olarak alınabilir.
4	Scala Tuples Bir dizi veya listeden farklı olarak, bir demet farklı türlerdeki nesneleri tutabilir.
5	Scala Options Seçenek [T], sıfır veya belirli bir türden bir eleman için bir kap sağlar.
6	Scala Iterators Yineleyici bir koleksiyon değil, daha çok bir koleksiyonun öğelerine tek tek erişmenin bir yoludur.

Scala, herhangi bir UNIX aromalı veya Windows tabanlı sisteme kurulabilir. Scala'yı makinenize kurmaya başlamadan önce, bilgisayarınızda Java 1.8 veya üstünün kurulu olması gerekir.

Scala'yı kurmak için aşağıda verilen adımları izleyin.

1. Adım: Java Kurulumunuzu Doğrulayın

Öncelikle sisteminizde Java Yazılım Geliştirme Kiti (SDK) kurulu olması gerekir. Bunu doğrulamak için üzerinde çalıştığınız platforma bağlı olarak aşağıdaki iki komuttan herhangi birini uygulayın.

Java yüklemesi düzgün bir şekilde yapıldıysa, Java yüklemenizin mevcut sürümünü ve teknik özelliklerini gösterecektir. Aşağıdaki tabloda örnek bir çıktı verilmiştir.

Platform	Komut	Örnek Çıktı
pencereler	Komut Konsolunu açın ve şunu yazın - \>java -version	Java sürümü "1.8.0_31" Java (TM) SE Çalışma Süresi Çevre (derleme 1.8.0_31-b31) Java Hotspot (TM) 64-bit Sunucusu VM (25.31-b07 derlemesi, karma mod)
Linux	Komut terminalini açın ve şunu yazın - $java -version	Java sürümü "1.8.0_31" JDK Çalışma Zamanı Ortamını açın (rhel-2.8.10.4.el6_4-x86_64) JDK 64-Bit Sunucu VM'yi açın (25.31-b07 derleme, karma mod)

Bu öğreticinin okuyucularının sistemlerinde Java SDK sürüm 1.8.0_31 yüklü olduğunu varsayıyoruz.

Java SDK'nız yoksa, mevcut sürümünü şuradan indirin: https://www.oracle.com/technetwork/java/javase/downloads/index.html ve kurun.

Adım 2: Java Ortamınızı Ayarlayın

JAVA_HOME ortam değişkenini, Java'nın makinenizde kurulu olduğu temel dizin konumunu gösterecek şekilde ayarlayın. Örneğin,

Sr.No	Platform ve Açıklama
1	Windows JAVA_HOME'u C: \ ProgramFiles \ java \ jdk1.8.0_31 olarak ayarlayın
2	Linux JAVA_HOME = / usr / local / java-current dosyasını dışa aktar

Java derleyici konumunun tam yolunu Sistem Yoluna ekleyin.

Sr.No	Platform ve Açıklama
1	Windows PATH sistem değişkeninin sonuna "C: \ Program Files \ Java \ jdk1.8.0_31 \ bin" Dizesini ekleyin.
2	Linux Export PATH = $ PATH: $ JAVA_HOME / bin /

Komutu yürütün java -version yukarıda açıklandığı gibi komut isteminden.

3. Adım: Scala'yı yükleyin

Scala'yı www.scala-lang.org/downloads adresinden indirebilirsiniz . Bu öğreticiyi yazarken, 'scala-2.13.1-installer.jar'ı indirdim. Devam etmek için yönetici ayrıcalığına sahip olduğunuzdan emin olun. Şimdi, komut isteminde aşağıdaki komutu yürütün -

Platform	Komut ve Çıktı	Açıklama
pencereler	\> java -jar scala-2.13.1-installer.jar \>	Bu komut, Windows makinenize Scala'yı kurmanız için size rehberlik edecek bir kurulum sihirbazı gösterecektir. Kurulum sırasında lisans sözleşmesi isteyecek, sadece kabul edecek ve ayrıca Scala'nın kurulacağı yolu soracaktır. Varsayılan olarak verilen "C: \ Program Files \ Scala" yolunu seçtim , rahatınıza göre uygun bir yol seçebilirsiniz.
Linux	Command - $ java -jar scala-2.13.1-installer.jar Output - Scala 2.13.1 kurulumuna hoş geldiniz! Ana sayfa - http://Scala-lang.org/ devam etmek için 1'e, çıkmak için 2'ye, yeniden görüntülemek için 3'e basın 1 ................................................ [Paketi açmaya başlıyorum] [İşleme paketi: Yazılım Paketi Kurulumu (1/1)] [Paketin açılması bitti] [Konsol kurulumu tamamlandı]	Kurulum sırasında, lisans sözleşmesi isteyecek, tip 1'i kabul edecek ve Scala'nın kurulacağı yolu soracaktır. / Usr / local / share yazdım , rahatınıza göre uygun bir yol seçebilirsiniz.

Son olarak, yeni bir komut istemi açın ve yazın Scala -versionve Enter tuşuna basın. Aşağıdakileri görmelisiniz -

Platform	Komut	Çıktı
pencereler	\> ölçekleme sürümü	Scala kod çalıştırıcısı sürüm 2.13.1 - Telif Hakkı 2002-2019, LAMP / EPFL ve Lightbend, Inc.
Linux	$ scala -version	Scala kod çalıştırıcısı sürüm 2.13.1 - Telif Hakkı 2002-2019, LAMP / EPFL ve Lightbend, Inc.tut

Scala bir veri yapısı sağlar, array, aynı türden öğelerin sabit boyutlu sıralı bir koleksiyonunu depolayan. Bir dizi, bir veri koleksiyonunu depolamak için kullanılır, ancak bir diziyi aynı türden bir değişkenler koleksiyonu olarak düşünmek genellikle daha kullanışlıdır.

Sayı0, sayı1, ... ve sayı99 gibi tek tek değişkenleri bildirmek yerine, sayılar gibi bir dizi değişkeni bildirir ve temsil etmek için sayılar [0], sayılar [1] ve ..., sayılar [99] kullanırsınız bireysel değişkenler. Bu öğretici, dizi değişkenlerinin nasıl bildirileceğini, dizilerin nasıl oluşturulacağını ve dizinlenmiş değişkenler kullanılarak dizilerin nasıl işleneceğini açıklamaktadır. Bir dizinin ilk öğesinin dizini sıfır sayısıdır ve son öğenin dizini, öğelerin toplam sayısı eksi birdir.

Dizi Değişkenlerini Bildirme

Bir programda bir dizi kullanmak için, diziye başvurmak üzere bir değişken bildirmeniz ve değişkenin başvurabileceği dizi türünü belirtmeniz gerekir.

Aşağıda, bir dizi değişkenini bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

or

var z = new Array[String](3)

Burada z, en fazla üç öğe tutabilen bir Dizeler dizisi olarak bildirilir. Değerler tek tek öğelere atanabilir veya tek tek öğelere erişim elde edilebilir, aşağıdaki gibi komutlar kullanılarak yapılabilir -

Komut

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

Buradaki son örnek, genel olarak dizinin tam sayı veren herhangi bir ifade olabileceğini göstermektedir. Bir diziyi tanımlamanın bir yolu daha var -

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

Aşağıdaki resim bir diziyi temsil eder myList. Buraya,myList on çift değer tutar ve endeksler 0'dan 9'a kadardır.

Dizileri İşleme

Dizi öğelerini işlerken, genellikle döngü kontrol yapılarını kullanırız çünkü bir dizideki tüm öğeler aynı türdedir ve dizinin boyutu bilinir.

Aşağıda dizilerin nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scala, çeşitli dizi işlemlerini doğrudan desteklemez ve herhangi bir boyuttaki dizileri işlemek için çeşitli yöntemler sağlar. Farklı yöntemleri kullanmak istiyorsanız, içe aktarmanız gerekir.Array._ paketi.

Çok boyutlu dizileri tanımlamanız ve kullanmanız gereken birçok durum vardır (yani, elemanları diziler olan diziler). Örneğin, matrisler ve tablolar, iki boyutlu diziler olarak gerçekleştirilebilecek yapı örnekleridir.

Aşağıda, iki boyutlu bir dizi tanımlama örneği verilmiştir -

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

Bu, her biri üç öğe içeren bir tamsayı dizisi olan üç öğeye sahip bir dizidir.

Çok boyutlu bir diziyi işlemek için aşağıdaki örnek programı deneyin -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

0 1 2
0 1 2
0 1 2

Belirli bir aralıkta artan tam sayı dizisini içeren bir dizi oluşturmak için range () yönteminin kullanılması. Diziyi oluşturmak için son bağımsız değişkeni adım olarak kullanabilirsiniz; son argümanı kullanmazsanız, adım 1 olarak kabul edilir.

Bir aralık dizisi oluşturmanın bir örneğini ele alalım (10, 20, 2): Bu, 10 ile 20 arasındaki öğeler ve aralık farkı 2 olan bir dizi oluşturmak anlamına gelir. Dizideki öğeler 10, 12, 14, 16 ve 18'dir. .

Başka bir örnek: aralık (10, 20). Burada aralık farkı verilmez, bu nedenle varsayılan olarak 1 eleman olduğunu varsayar. Aralık farkı 1 ile 10 ile 20 arasındaki öğelerle bir dizi oluşturur. Dizideki öğeler 10, 11, 12, 13, ... ve 19'dur.

Aşağıdaki örnek program, aralıklarla bir dizinin nasıl oluşturulacağını gösterir.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala bir veri yapısı sağlar, ArrayBuffer, başlangıç boyutu kısaldığında boyutu değiştirebilir. Dizi sabit boyutta olduğundan ve bir dizide daha fazla öğe kullanılamadığından, ArrayBuffer, boyutun esnek olduğu diziye bir alternatiftir.

ArrayBuffer, öğeleri depolamak için dahili olarak geçerli boyutta bir dizi tutar. Yeni bir eleman eklendiğinde boyut kontrol edilir. Temel dizinin dolu olması durumunda, yeni bir daha büyük dizi oluşturulur ve tüm öğeler daha büyük diziye kopyalanır.

ArrayBuffer Değişkenlerini Bildirme

Aşağıda, ArrayBuffer değişkenini bildirmek için sözdizimi verilmiştir.

Sözdizimi

var z = ArrayBuffer[String]()

Burada z, başlangıçta boş olan Dizelerin bir dizi tamponu olarak bildirilir. Değerler, aşağıdaki gibi komutlar kullanılarak eklenebilir -

Komut

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

ArrayBuffer işleniyor

Aşağıda, ArrayBuffer'ın nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala Listeleri dizilere oldukça benzer, yani bir listedeki tüm elemanlar aynı türe sahiptir, ancak iki önemli fark vardır. Birincisi, listeler değişmezdir, yani bir listenin öğeleri atama ile değiştirilemez. İkinci olarak, listeler bağlantılı bir listeyi temsil ederken diziler düzdür.

T tipi elemanlara sahip bir listenin tipi şu şekilde yazılır: List[T].

Aşağıdaki örneği deneyin, burada çeşitli veri türleri için tanımlanmış birkaç liste bulunmaktadır.

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

Tüm listeler iki temel yapı taşı kullanılarak tanımlanabilir, bir kuyruk Nil ve ::, telaffuz edilen cons. Nil ayrıca boş listeyi temsil eder. Yukarıdaki tüm listeler aşağıdaki gibi tanımlanabilir.

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

Listelerdeki Temel İşlemler

Listelerdeki tüm işlemler aşağıdaki üç yöntemle ifade edilebilir.

Sr.No	Yöntemler ve Açıklama
1	head Bu yöntem, bir listenin ilk öğesini döndürür.
2	tail Bu yöntem, ilki dışındaki tüm öğelerden oluşan bir liste döndürür.
3	isEmpty Liste boşsa bu yöntem true, aksi takdirde false döndürür.

Aşağıdaki örnek, yukarıdaki yöntemlerin nasıl kullanılacağını gösterir.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Listeleri Birleştirme

İkisini de kullanabilirsiniz ::: operatör veya List.:::() yöntem veya List.concat()iki veya daha fazla liste eklemek için yöntem. Lütfen aşağıda verilen aşağıdaki örneği bulun -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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)

Üniforma Listeleri Oluşturma

Kullanabilirsiniz List.fill()yöntem aynı elemanın sıfır veya daha fazla kopyasından oluşan bir liste oluşturur. Aşağıdaki örnek programı deneyin.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Bir Fonksiyonu Tablo Oluşturma

İle birlikte bir işlevi kullanabilirsiniz List.tabulate()Listeyi tablo haline getirmeden önce listenin tüm öğelerine uygulama yöntemi. Argümanları List.fill'inkiler gibidir: ilk argüman listesi oluşturulacak listenin boyutlarını verir ve ikincisi listenin öğelerini açıklar. Tek fark, sabitlenen elemanlar yerine bir fonksiyondan hesaplanmalarıdır.

Aşağıdaki örnek programı deneyin.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Ters Liste Sırası

Kullanabilirsiniz List.reverselistenin tüm öğelerini tersine çevirme yöntemi. Aşağıdaki örnek, kullanımı göstermektedir.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala bir veri yapısı sağlar, ListBufferBu, bir listedeki öğeleri eklerken / kaldırırken List'den daha etkilidir. Öğeleri bir listeye eklemek, eklemek için yöntemler sağlar.

ListBuffer Değişkenlerini Bildirme

Aşağıda bir ListBuffer değişkenini bildirmek için sözdizimi verilmiştir.

Sözdizimi

var z = ListBuffer[String]()

Burada z, başlangıçta boş olan Dizelerin bir liste tamponu olarak bildirilir. Değerler, aşağıdaki gibi komutlar kullanılarak eklenebilir -

Komut

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

İşleme Listesi

Aşağıda ListBuffer'ın nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala Set, aynı türden ikili farklı unsurların bir koleksiyonudur. Başka bir deyişle, bir Set, yinelenen öğeler içermeyen bir koleksiyondur. ListSet değişmez kümeler uygular ve liste yapısını kullanır. Öğeler saklanırken öğe ekleme sırası korunur.

ListSet Değişkenlerini Bildirme

Aşağıda bir ListSet değişkeni bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada z, üç üyesi olan bir Dizeler listesi olarak tanımlanır. Değerler, aşağıdaki gibi komutlar kullanılarak eklenebilir -

Komut

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

İşleme Listesi

Aşağıda, ListSet'in nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala Vector, öğelere rastgele erişilebilen genel amaçlı, değişmez bir veri yapısıdır. Genellikle büyük veri koleksiyonları için kullanılır.

Vektör Değişkenlerini Bildirme

Aşağıda bir Vector değişkeni bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada z, üç üyesi olan Dizelerin bir vektörü olarak tanımlanır. Değerler, aşağıdaki gibi komutlar kullanılarak eklenebilir -

Komut

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

Vektör işleme

Aşağıda Vector'ün nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala Set, aynı türden ikili farklı unsurların bir koleksiyonudur. Başka bir deyişle, bir Set, yinelenen öğeler içermeyen bir koleksiyondur. İki tür Set vardır:immutable ve mutable. Değişken ve değişmez nesneler arasındaki fark, bir nesne değişmez olduğunda, nesnenin kendisinin değiştirilememesidir.

Scala varsayılan olarak değişmez Seti kullanır. Değiştirilebilir Seti kullanmak istiyorsanız, içe aktarmanız gerekecekscala.collection.mutable.Setsınıf açıkça. Aynı koleksiyonda hem değiştirilebilir hem de değişmez kümeleri kullanmak istiyorsanız, değişmez Küme'ye şu şekilde başvurmaya devam edebilirsiniz:Set ancak değiştirilebilir Set'e şu şekilde başvurabilirsiniz: mutable.Set.

Değişmez Kümeleri nasıl ilan edeceğiniz aşağıda açıklanmıştır -

Sözdizimi

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

Boş bir küme tanımlanırken, sistemin değişkene somut bir tip ataması gerektiğinden tip ek açıklaması gereklidir.

Sette Temel İşlemler

Setlerdeki tüm işlemler aşağıdaki üç yöntemle ifade edilebilir:

Sr.No	Yöntemler ve Açıklama
1	head Bu yöntem, bir kümenin ilk öğesini döndürür.
2	tail Bu yöntem, ilki dışındaki tüm öğelerden oluşan bir küme döndürür.
3	isEmpty Bu yöntem, küme boşsa, aksi takdirde yanlışsa doğru döndürür.

Temel işletim yöntemlerinin kullanımını gösteren aşağıdaki örneği deneyin -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Birleştirme Setleri

İkisini de kullanabilirsiniz ++ operatör veya Set.++() iki veya daha fazla seti birleştirmek için yöntem, ancak kümeler eklerken yinelenen öğeleri kaldıracaktır.

Aşağıdaki, iki kümeyi birleştirme örneğidir.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Bir Kümedeki Max, Min Elemanları Bul

Kullanabilirsiniz Set.min minimum bulma yöntemi ve Set.maxBir kümede bulunan maksimum eleman sayısını bulma yöntemi. Programı göstermek için örnek aşağıdadır.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Ortak Değer Ekleri Bulun

İkisini de kullanabilirsiniz Set.& yöntem veya Set.intersectiki küme arasındaki ortak değerleri bulma yöntemi. Kullanımı göstermek için aşağıdaki örneği deneyin.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Bit kümesi, değiştirilebilir ve değiştirilemez bit kümeleri için ortak bir temel sınıftır. Bit kümeleri, negatif olmayan tam sayılardan oluşan kümelerdir ve 64 bit sözcükler halinde paketlenmiş değişken boyutlu bit dizileri olarak temsil edilir. Bir bit kümesinin bellek ayak izi, içinde depolanan en büyük sayı ile temsil edilir.

BitSet Değişkenlerini Bildirme

Aşağıda bir BitSet değişkenini bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada z, üç üyesi olan negatif olmayan tamsayılardan oluşan bir bit kümesi olarak tanımlanır. Değerler, aşağıdaki gibi komutlar kullanılarak eklenebilir -

Komut

var myList1: BitSet = myList + 3;

BitSet işleniyor

Aşağıda, BitSet'in nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala Set, aynı türden ikili farklı unsurların bir koleksiyonudur. Başka bir deyişle, bir Set, yinelenen öğeler içermeyen bir koleksiyondur. HashSet, değişmez kümeler uygular ve karma tablo kullanır. Öğeler ekleme sırası korunmaz.

HashSet Değişkenlerini Bildirme

Aşağıda bir HashSet değişkeni bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada z, üç üyesi olan bir dizge kümesi olarak tanımlanır. Değerler, aşağıdaki gibi komutlar kullanılarak eklenebilir -

Komut

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

HashSet işleniyor

Aşağıda HashSet'in nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala Set, aynı türden ikili farklı unsurların bir koleksiyonudur. Başka bir deyişle, bir Set, yinelenen öğeler içermeyen bir koleksiyondur. TreeSet, değişmez kümeler uygular ve öğeleri sıralı düzende tutar.

TreeSet Değişkenlerini Bildirme

Aşağıda bir TreeSet değişkeni bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada z, üç üyesi olan bir Dizeler ağaç kümesi olarak ilan edilir. Değerler, aşağıdaki gibi komutlar kullanılarak eklenebilir -

Komut

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

TreeSet işleniyor

Aşağıda, TreeSet'in nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala haritası, anahtar / değer çiftlerinden oluşan bir koleksiyondur. Herhangi bir değer, anahtarına bağlı olarak alınabilir. Anahtarlar Harita'da benzersizdir, ancak değerlerin benzersiz olması gerekmez. Haritalara ayrıca Karma tablolar da denir. İki tür Harita vardır:immutable ve mutable. Değişken ve değişmez nesneler arasındaki fark, bir nesne değişmez olduğunda, nesnenin kendisinin değiştirilememesidir.

Varsayılan olarak, Scala değişmez Haritayı kullanır. Değişken Haritayı kullanmak istiyorsanız, içeri aktarmanız gerekecekscala.collection.mutable.Mapsınıf açıkça. Hem değiştirilebilir hem de değişmez Haritaları aynı anda kullanmak istiyorsanız, değişmez Haritaya şu şekilde atıfta bulunmaya devam edebilirsiniz:Map ancak değiştirilebilir kümeye şu şekilde başvurabilirsiniz: mutable.Map.

Aşağıda, değişmez Haritaları beyan etmek için örnek ifadeler verilmiştir -

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

Boş harita tanımlanırken, sistemin değişkene somut bir tip ataması gerektiğinden tip ek açıklaması gereklidir. Bir Haritaya anahtar-değer çifti eklemek istersek, + operatörünü aşağıdaki gibi kullanabiliriz.

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

MAP üzerindeki Temel İşlemler

Haritalardaki tüm işlemler aşağıdaki üç yöntemle ifade edilebilir.

Sr.No	Yöntemler ve Açıklama
1	keys Bu yöntem, haritadaki her anahtarı içeren bir yinelenebilir döndürür.
2	values Bu yöntem, haritadaki her bir değeri içeren bir yinelenebilir döndürür.
3	isEmpty Bu yöntem, harita boşsa doğru, aksi takdirde yanlış döndürür.

Harita yöntemlerinin kullanımını gösteren aşağıdaki örnek programı deneyin.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Haritaları Birleştirme

İkisini de kullanabilirsiniz ++ operatör veya Map.++() iki veya daha fazla Haritayı birleştirme yöntemidir, ancak Haritalar eklenirken yinelenen anahtarları kaldırır.

İki Haritayı birleştirmek için aşağıdaki örnek programı deneyin.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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)

Bir Haritadan Anahtarları ve Değerleri Yazdır

"Foreach" döngüsünü kullanarak bir Haritanın anahtarları ve değerleri arasında yineleme yapabilirsiniz. Burada yöntem kullandıkforeachanahtarlar arasında gezinmek için yineleyici ile ilişkili. Örnek program aşağıdadır.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Haritada bir anahtarı kontrol edin

İkisini de kullanabilirsiniz Map.containsBelirli bir anahtarın haritada olup olmadığını test etme yöntemi. Anahtar kontrolü için aşağıdaki örnek programı deneyin.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

HashMap Değişkenlerini Bildirme

Aşağıda bir HashMap değişkeni bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada renkler, üç anahtar-değer çiftine sahip olan Dizelerin, Int'in bir karma haritası olarak bildirilir. Değerler, aşağıdaki gibi komutlar kullanılarak eklenebilir -

Komut

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

HashMap işleniyor

Aşağıda HashMap'in nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program verilmiştir -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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 haritası, anahtar / değer çiftlerinden oluşan bir koleksiyondur. Herhangi bir değer, anahtarına bağlı olarak alınabilir. Anahtarlar Harita'da benzersizdir, ancak değerlerin benzersiz olması gerekmez. ListMap değişmez eşlemeyi uygular ve aynısını uygulamak için listeyi kullanır. Az sayıda eleman ile kullanılır.

ListMap Değişkenlerini Bildirme

Aşağıda bir ListMap değişkenini bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada renkler, üç anahtar-değer çiftine sahip olan Dizelerin, Int'in bir karma haritası olarak bildirilir. Değerler, aşağıdaki gibi komutlar kullanılarak eklenebilir -

Komut

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

İşleme Listesi Haritası

Aşağıda ListMap'in nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Yineleyici bir koleksiyon değil, daha çok bir koleksiyonun öğelerine tek tek erişmenin bir yoludur. Bir üzerinde iki temel işlemiterator it vardır next ve hasNext. Bir çağrıit.next()yineleyicinin bir sonraki öğesini döndürür ve yineleyicinin durumunu ilerletir. Yineleyici'yi kullanarak döndürülecek daha fazla öğe olup olmadığını öğrenebilirsiniz.it.hasNext yöntem.

Bir yineleyici tarafından döndürülen tüm öğeleri "adım adım ilerletmenin" en kolay yolu bir while döngüsü kullanmaktır. Aşağıdaki örnek programı takip edelim.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

a
number
of
words

Min ve Maks Değerli Öğeyi Bul

Kullanabilirsiniz it.min ve it.maxbir yineleyiciden minimum ve maksimum değerli öğeleri bulma yöntemleri. Burada kullandıkita ve itbYineleyici yalnızca bir kez geçilebildiğinden iki farklı işlem gerçekleştirmek için. Örnek program aşağıdadır.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

Maximum valued element 90
Minimum valued element 2

Yineleyicinin Uzunluğunu Bulun

İkisini de kullanabilirsiniz it.size veya it.lengthbir yineleyicide bulunan öğelerin sayısını bulma yöntemleri. Burada ita ve itb'yi iki farklı işlemi gerçekleştirmek için kullandık çünkü yineleyici yalnızca bir kez geçilebilir. Örnek program aşağıdadır.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala Seçeneği [T], sıfır veya belirli bir türden bir eleman için bir kaptır. Bir Seçenek [T] şunlar olabilir:Some[T] veya Noneeksik bir değeri temsil eden nesne. Örneğin, belirli bir anahtara karşılık gelen bir değer bulunursa, Scala Haritasının get yöntemi Bazı (değer) üretir veyaNone verilen anahtar haritada tanımlı değilse.

Seçenek türü Scala programlarında sıklıkla kullanılır ve bunu, nullJava'da hiçbir değer belirtmeyen değer. Örneğin, java.util.HashMap'in get yöntemi, HashMap'te saklanan bir değeri veya hiçbir değer bulunmadıysa null döndürür.

Bir birincil anahtara dayalı olarak veritabanından bir kayıt alan bir yöntemimiz olduğunu varsayalım.

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

Yöntem, kayıt bulunursa Bazı [Kişi], kayıt bulunamazsa Hiçbiri döndürür. Aşağıdaki programı takip edelim.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

İsteğe bağlı değerleri ayırmanın en yaygın yolu bir kalıp eşleştirmesidir. Örneğin aşağıdaki programı deneyin.

Misal

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 => "?"
   }
}

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

GetOrElse () Yöntemini Kullanma

Aşağıda, bir değere veya hiçbir değer olmadığında bir varsayılana erişmek için getOrElse () yönteminin nasıl kullanılacağını gösteren örnek program verilmiştir.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

İsEmpty () Yöntemini Kullanma

Aşağıda, seçeneğin None olup olmadığını kontrol etmek için isEmpty () yönteminin nasıl kullanılacağını gösteren örnek program verilmiştir.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Misal

a.isEmpty: false
b.isEmpty: true

Kuyruk İlk Giren İlk Çıkar, FIFO veri yapısıdır ve öğeleri FIFO tarzında eklemeye ve almaya izin verir.

Kuyruk Değişkenlerini Bildirme

Aşağıda bir Kuyruk değişkeni bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada sıra, sayıların Sırası olarak ilan edilir. Değer, aşağıdaki gibi komutlar kullanılarak öne eklenebilir -

Komut

queue.enqueue(6)

Değer, aşağıdaki gibi komutlar kullanılarak önden alınabilir -

Komut

queue.dequeue()

İşleme Kuyruğu

Aşağıda, Kuyruğun nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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+ " ")}
   }
}

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala tuple, sabit sayıda öğeyi bir bütün olarak aktarılabilmeleri için bir araya getirir. Bir dizi veya listeden farklı olarak, bir demet farklı türlerdeki nesneleri tutabilir ancak bunlar aynı zamanda değişmezdir.

Aşağıda, bir tamsayı, bir dize ve konsol içeren bir demet örneğidir.

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

Aşağıdakiler için sözdizimsel şeker (kısa yol) hangisidir -

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

Bir demetinin gerçek türü, içerdiği öğelerin sayısına ve bu öğelerin türlerine bağlıdır. Bu nedenle, (99, "Luftballons") tipi Tuple2 [Int, String] 'dir. ('U', 'r', "the", 1, 4, "me") türü Tuple6'dır [Char, Char, String, Int, Int, String]

Tuple'lar Tuple1, Tuple2, Tuple3 ve benzeri türlerdedir. Şu anda Scala'da 22'lik bir üst sınır vardır, daha fazlasına ihtiyacınız varsa, o zaman bir grup değil, bir koleksiyon kullanabilirsiniz. 1 <= N <= 22 olan her TupleN türü için, Scala bir dizi öğe erişim yöntemi tanımlar. Aşağıdaki tanım göz önüne alındığında -

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

Bir tuple t'nin öğelerine erişmek için, birinci öğeye erişmek için t._1 yöntemini, ikinciye erişmek için t._2 yöntemini vb. Kullanabilirsiniz. Örneğin, aşağıdaki ifade t'nin tüm elemanlarının toplamını hesaplar.

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

Bir List [Double] alan ve üç öğeli bir Tuple, bir Tuple3 [Int, Double, Double] içinde döndürülen karelerin sayısını, toplamını ve toplamını döndüren bir yöntem yazmak için Tuple'ı kullanabilirsiniz. Aynı zamanda, eşzamanlı programlamada aktörler arasında mesaj olarak veri değerleri listesini iletmek için de kullanışlıdırlar.

Aşağıdaki örnek programı deneyin. Bir demetinin nasıl kullanılacağını gösterir.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komutlar

\>scalac Demo.scala
\>scala Demo

Çıktı

Sum of elements: 10

Tuple üzerinde yineleyin

Kullanabilirsiniz Tuple.productIterator() Tuple'ın tüm öğeleri üzerinde yineleme yöntemi.

Tupleları yinelemek için aşağıdaki örnek programı deneyin.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komutlar

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Dizeye Dönüştürme

Kullanabilirsiniz Tuple.toString()demetin tüm öğelerini bir dizeye birleştirme yöntemi. String'e dönüştürmek için aşağıdaki örnek programı deneyin.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Öğeleri Değiştirin

Kullanabilirsiniz Tuple.swap Tuple2 öğelerini takas etme yöntemi.

Öğeleri değiştirmek için aşağıdaki örnek programı deneyin.

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

Swapped tuple: (hello,Scala)

Scala Seq, değişmez dizileri temsil eden bir özelliktir. Bu yapı, indeks tabanlı erişim ve öğeleri, oluşumlarını ve alt dizilerini bulmak için çeşitli yardımcı yöntemler sağlar. Bir Seq, ekleme sırasını korur.

Sıra Değişkenlerini Bildirme

Aşağıda bir Seq değişkenini bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada seq, bir sayı dizisi olarak ilan edilir. Seq, aşağıdaki gibi komutlar sağlar -

Komut

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

İşleme Sırası

Aşağıda, Seq'in nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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)

Yığın Son Giren İlk Çıkar, LIFO veri yapısıdır ve LIFO tarzında üstte eleman yerleştirmeye ve almaya izin verir.

Yığın Değişkenlerini Bildirme

Aşağıda bir Yığın değişkenini bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada yığın, sayı yığını olarak tanımlanır. Değer, aşağıdaki gibi komutlar kullanılarak en üste eklenebilir -

Komut

stack.push(6)

Değer, aşağıdaki gibi komutlar kullanılarak üstten alınabilir -

Komut

stack.top

Değer, aşağıdaki gibi komutlar kullanılarak yukarıdan kaldırılabilir -

Komut

stack.pop

İşleme Yığını

Aşağıda Stack'in nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

Scala Stream, tembel değerlendirme özelliğine sahip özel bir listedir. Ölçekli akışta, öğeler yalnızca ihtiyaç duyulduğunda değerlendirilir. Akış, tembel hesaplamayı destekler ve performans konusunda bilgili.

Akış Değişkenlerini Bildirme

Aşağıda bir Stream değişkenini bildirmek için sözdizimi verilmiştir.

Sözdizimi

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

Burada akım bir sayı akışı olarak ilan edilir. Burada 1 akışın başı, 2, 3 akıntının kuyruğu. Stream.empty, akışın sonunu gösterir. Değerler, aşağıdaki gibi alma komutları kullanılarak alınabilir -

Komut

stream.take(2)

Akış İşleme

Aşağıda, Akışın nasıl oluşturulacağını, başlatılacağını ve işleneceğini gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

drop () yöntemi, List tarafından listenin ilk n öğesi dışındaki tüm öğeleri seçmek için kullanılan yöntemdir.

Sözdizimi

Aşağıdakiler, bırakma yönteminin sözdizimidir.

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

Burada n, listeden çıkarılacak eleman sayısıdır. Bu yöntem, listenin ilk n olanlar dışındaki tüm öğelerini döndürür.

Kullanım

Aşağıda drop yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

dropWhile () yöntemi, List tarafından belirli bir koşulu sağlayan tüm öğeleri bırakmak için kullanılan bir yöntemdir.

Sözdizimi

DropWhile yönteminin sözdizimi aşağıdadır.

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

Burada, p: (A) => Boole, listenin her bir öğesine uygulanacak bir yüklem veya koşuldur. Bu yöntem, listenin bırakılanlar dışındaki tüm öğelerini döndürür.

Kullanım

DropWhile yönteminin nasıl kullanılacağını gösteren örnek bir program aşağıdadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

filter () yöntemi, List tarafından belirli bir koşulu karşılayan tüm öğeleri seçmek için kullanılan bir yöntemdir.

Sözdizimi

Aşağıda, filtre yönteminin sözdizimi verilmiştir.

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

Burada, p: (A) => Boole, listenin her bir öğesine uygulanacak bir yüklem veya koşuldur. Bu yöntem, verilen koşulu sağlayan listenin tüm öğelerini döndürür.

Kullanım

Aşağıda, filtre yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

find () yöntemi, belirli bir koşulu karşılayan bir öğeyi bulmak için Yineleyiciler tarafından kullanılan yöntemdir.

Sözdizimi

Aşağıdaki, bulma yönteminin sözdizimidir.

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

Burada, p: (A) => Boole, yineleyicinin her bir öğesine uygulanacak bir yüklem veya koşuldur. Bu yöntem, verilen koşulu karşılayan yineleyicinin eşleşen öğesini içeren Option öğesini döndürür.

Kullanım

Aşağıda, bulma yönteminin nasıl kullanılacağını gösteren örnek bir program verilmiştir -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

Some(3)

flatMap () yöntemi, TraversableLike özelliğinin yöntemidir, bir yüklem alır, bunu koleksiyonun her bir öğesine uygular ve yüklem tarafından döndürülen yeni bir öğe koleksiyonu döndürür.

Sözdizimi

Aşağıda flatMap yönteminin sözdizimi verilmiştir.

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

Burada, f: (A)? GenTraversableOnce [B], koleksiyonun her bir öğesine uygulanacak bir tahmin veya koşuldur. Bu yöntem, verilen koşulu karşılayan yineleyicinin eşleşen öğesini içeren Option öğesini döndürür.

Kullanım

Aşağıda flatMap yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

flatten () yöntemi bir GenericTraversableTemplate üyesidir, alt koleksiyonları birleştirerek tek bir öğe koleksiyonu döndürür.

Sözdizimi

Aşağıda düzleştirme yönteminin sözdizimi verilmiştir.

def flatten[B]: Traversable[B]

Kullanım

Aşağıda, düzleştirme yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

List(1, 2, 3, 4)

fold () yöntemi TraversableOnce özelliğinin bir üyesidir, koleksiyonların öğelerini daraltmak için kullanılır.

Sözdizimi

Aşağıda, katlama yönteminin sözdizimi verilmiştir.

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

Burada katlama yöntemi, ilişkilendirilebilir ikili operatör fonksiyonunu parametre olarak alır. Bu yöntem sonucu değer olarak döndürür. İlk girişi başlangıç değeri olarak ve ikinci girişi bir işlev olarak kabul eder (bu, giriş olarak birikmiş değeri ve mevcut öğeyi alır).

Kullanım

Aşağıda, katlama yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Burada, katlama işlevine başlangıç değeri olarak 0'ı geçtik ve ardından tüm değerler eklendi. Yukarıdaki programı şuraya kaydedin:Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

foldLeft () yöntemi TraversableOnce özelliğinin bir üyesidir, koleksiyonların öğelerini daraltmak için kullanılır. Öğeleri Soldan Sağa sıraya taşır. Öncelikle özyinelemeli işlevlerde kullanılır ve yığın taşması istisnalarını önler.

Sözdizimi

Aşağıda, katlama yönteminin sözdizimi verilmiştir.

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

Burada foldLeft metodu, ilişkilendirilebilir ikili operatör fonksiyonunu parametre olarak alır. Bu yöntem sonucu değer olarak döndürür.

Kullanım

Aşağıda foldLeft yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

foldRight () yöntemi, TraversableOnce özelliğinin bir üyesidir, koleksiyonların öğelerini daraltmak için kullanılır. Öğeleri Sağdan Sola sırayla gezdirir.

Sözdizimi

Aşağıda, foldRight yönteminin sözdizimi verilmiştir.

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

Burada katlama yöntemi, ilişkilendirilebilir ikili operatör fonksiyonunu parametre olarak alır. Bu yöntem sonuçlanan değeri döndürür.

Kullanım

Aşağıda, foldRight yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Burada foldRight fonksiyonuna başlangıç değeri olarak 0'ı geçtik ve sonra tüm değerler eklendi. Yukarıdaki programı şuraya kaydedin:Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

map () yöntemi, TraversableLike özelliğinin bir üyesidir, bir koleksiyonun her öğesinde bir yüklem yöntemi çalıştırmak için kullanılır. Yeni bir koleksiyon döndürür.

Sözdizimi

Aşağıda harita yönteminin sözdizimi verilmiştir.

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

Burada, harita yöntemi parametre olarak bir ön işlev alır. Bu yöntem güncellenmiş koleksiyonu döndürür.

Kullanım

Aşağıda, harita yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

List(2, 4, 6, 8)

partition () yöntemi, TraversableLike özelliğinin bir üyesidir, bir koleksiyonun her öğesinde bir yüklem yöntemi çalıştırmak için kullanılır. İki koleksiyon döndürür; bir koleksiyon, belirli bir yüklem işlevini karşılayan öğelerden ve diğer koleksiyon, verilen yüklem işlevini karşılamayan öğelerden oluşur.

Sözdizimi

Aşağıda harita yönteminin sözdizimi verilmiştir.

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

Burada, bölümleme yöntemi parametre olarak bir ön işlev alır. Bu yöntem koleksiyonları döndürür.

Kullanım

Aşağıda, bölümleme yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

azaltma () yöntemi, TraversableOnce özelliğinin bir üyesidir, koleksiyonların öğelerini daraltmak için kullanılır. Katlama yöntemine benzer ancak başlangıç değerini almaz.

Sözdizimi

Aşağıda, azaltma yönteminin sözdizimi verilmiştir.

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

Burada, azaltma yöntemi, ilişkilendirilebilir ikili operatör işlevini parametre olarak alır. Bu yöntem, sonuçtaki değeri döndürür.

Kullanım

Aşağıda, katlama yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

scan () yöntemi TraversableLike özelliğinin bir üyesidir, katlama yöntemine benzer, ancak koleksiyonun her öğesine bir işlem uygulamak ve bir koleksiyon döndürmek için kullanılır.

Sözdizimi

Aşağıda, katlama yönteminin sözdizimi verilmiştir.

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

Burada, tarama yöntemi bir parametre olarak ilişkili ikili operatör işlevini alır. Bu yöntem, sonuç olarak güncellenmiş koleksiyonu döndürür. İlk girişi başlangıç değeri ve ikinci girişi bir fonksiyon olarak kabul eder.

Kullanım

Aşağıda, tarama yönteminin nasıl kullanılacağını gösteren örnek bir program bulunmaktadır -

Misal

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

Burada tarama fonksiyonuna başlangıç değeri olarak 0'ı geçtik ve ardından tüm değerler eklendi. Yukarıdaki programı şuraya kaydedin:Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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

zip () yöntemi, IterableLike özelliğinin bir üyesidir, bir koleksiyonu mevcut koleksiyonla birleştirmek için kullanılır ve sonuç, her iki koleksiyondan bir çift tuple öğesi koleksiyonudur.

Sözdizimi

Aşağıda zip yönteminin sözdizimi verilmiştir.

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

Burada zip yöntemi parametre olarak bir koleksiyon alır. Bu yöntem, sonuç olarak güncellenmiş çift koleksiyonunu döndürür.

Kullanım

Aşağıda zip yönteminin nasıl kullanılacağını gösteren örnek bir program verilmiştir -

Misal

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

Yukarıdaki programı şuraya kaydedin: Demo.scala. Bu programı derlemek ve çalıştırmak için aşağıdaki komutlar kullanılır.

Komut

\>scalac Demo.scala
\>scala Demo

Çıktı

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