Kolekcje Scala - szybki przewodnik
Scala posiada bogaty zestaw zbiorów bibliotecznych. Kolekcje to pojemniki na rzeczy. Te kontenery mogą być sekwencjonowane, liniowe zestawy elementów, takie jak Lista, Krotka, Opcja, Mapa itp. Kolekcje mogą mieć dowolną liczbę elementów lub być ograniczone do zera lub jednego elementu (np. Opcja).
Kolekcje mogą być strict lub lazy. Leniwe kolekcje zawierają elementy, które mogą nie zajmować pamięci, dopóki nie zostaną udostępnione, na przykładRanges. Dodatkowo kolekcje mogą byćmutable (treść odniesienia może ulec zmianie) lub immutable(rzecz, do której odwołuje się odwołanie, nigdy się nie zmienia). Pamiętaj, że niezmienne kolekcje mogą zawierać zmienne elementy.
W przypadku niektórych problemów zbiory zmienne działają lepiej, a w przypadku innych zbiory niezmienne działają lepiej. W razie wątpliwości lepiej zacząć od niezmiennej kolekcji i zmienić ją później, jeśli potrzebujesz zmiennych.
Ten rozdział rzuca światło na najczęściej używane typy kolekcji i najczęściej używane operacje na tych kolekcjach.
Sr.No | Kolekcje z opisem |
---|---|
1 | Scala Lists Lista Scali [T] jest połączoną listą typu T. |
2 | Scala Sets Zestaw jest zbiorem par różnych elementów tego samego typu. |
3 | Scala Maps Mapa to zbiór par klucz / wartość. Dowolną wartość można pobrać na podstawie jej klucza. |
4 | Scala Tuples W przeciwieństwie do tablicy lub listy, krotka może zawierać obiekty różnych typów. |
5 | Scala Options Opcja [T] zapewnia kontener na zero lub jeden element danego typu. |
6 | Scala Iterators Iterator nie jest zbiorem, ale raczej sposobem na dostęp do elementów kolekcji jeden po drugim. |
Scala może być zainstalowana na dowolnym systemie UNIX lub Windows. Zanim zaczniesz instalować Scala na swoim komputerze, musisz mieć na swoim komputerze zainstalowaną Javę 1.8 lub nowszą.
Wykonaj poniższe czynności, aby zainstalować Scala.
Krok 1: Zweryfikuj instalację oprogramowania Java
Przede wszystkim musisz mieć zainstalowany zestaw Java Software Development Kit (SDK) w swoim systemie. Aby to sprawdzić, wykonaj dowolne z następujących dwóch poleceń w zależności od platformy, na której pracujesz.
Jeśli instalacja Java została wykonana poprawnie, wyświetli się aktualna wersja i specyfikacja instalacji Java. Przykładowe dane wyjściowe podano w poniższej tabeli.
Platforma | Komenda | Przykładowe wyjście |
---|---|---|
Windows | Otwórz konsolę poleceń i wpisz - \>java -version |
Wersja Java „1.8.0_31” Java (TM) SE Run Time Środowisko (kompilacja 1.8.0_31-b31) 64-bitowy serwer Java Hotspot (TM) VM (kompilacja 25.31-b07, tryb mieszany) |
Linux | Otwórz terminal poleceń i wpisz - $java -version |
Wersja Java „1.8.0_31” Otwórz środowisko wykonawcze JDK (rhel-2.8.10.4.el6_4-x86_64) Otwórz 64-bitową maszynę wirtualną serwera JDK (kompilacja 25.31-b07, tryb mieszany) |
Zakładamy, że czytelnicy tego samouczka mają zainstalowany w swoim systemie pakiet Java SDK w wersji 1.8.0_31.
Jeśli nie masz Java SDK, pobierz jego aktualną wersję z https://www.oracle.com/technetwork/java/javase/downloads/index.html i zainstaluj.
Krok 2: Ustaw środowisko Java
Ustaw zmienną środowiskową JAVA_HOME, aby wskazywała lokalizację katalogu podstawowego, w którym na komputerze jest zainstalowana Java. Na przykład,
Sr.No | Platforma i opis |
---|---|
1 | Windows Ustaw JAVA_HOME na C: \ ProgramFiles \ java \ jdk1.8.0_31 |
2 | Linux Eksportuj JAVA_HOME = / usr / local / java-current |
Dołącz pełną ścieżkę lokalizacji kompilatora Java do ścieżki systemowej.
Sr.No | Platforma i opis |
---|---|
1 | Windows Dołącz ciąg „C: \ Program Files \ Java \ jdk1.8.0_31 \ bin” na końcu zmiennej systemowej PATH. |
2 | Linux Export PATH = $ PATH: $ JAVA_HOME / bin / |
Wykonaj polecenie java -version z wiersza polecenia, jak wyjaśniono powyżej.
Krok 3: Zainstaluj Scala
Możesz pobrać Scala ze strony www.scala-lang.org/downloads . W czasie pisania tego samouczka pobrałem plik „scala-2.13.1-installer.jar”. Upewnij się, że masz uprawnienia administratora, aby kontynuować. Teraz wykonaj następujące polecenie w wierszu polecenia -
Platforma | Polecenie i wyjście | Opis |
---|---|---|
Windows | \> java -jar scala-2.13.1-installer.jar \> |
To polecenie wyświetli kreatora instalacji, który poprowadzi Cię przez instalację Scali na komputerze z systemem Windows. Podczas instalacji zapyta o umowę licencyjną, po prostu ją zaakceptuj, a następnie zapyta o ścieżkę, w której zostanie zainstalowana Scala. Wybrałem domyślną podaną ścieżkę "C: \ Program Files \ Scala", możesz wybrać odpowiednią ścieżkę według własnego uznania. |
Linux | Command - $ java -jar scala-2.13.1-installer.jar Output - Witamy w instalacji Scala 2.13.1! Strona główna jest pod adresem - http://Scala-lang.org/ naciśnij 1, aby kontynuować, 2, aby wyjść, 3, aby wyświetlić ponownie 1 ................................................ [Rozpoczynanie rozpakowywania] [Pakiet przetwarzania: Instalacja pakietu oprogramowania (1/1)] [Rozpakowywanie zakończone] [Instalacja konsoli zakończona] |
Podczas instalacji zapyta o umowę licencyjną, aby ją zaakceptować typ 1 i zapyta o ścieżkę, w której zostanie zainstalowana Scala. Wpisałem / usr / local / share, możesz wybrać odpowiednią ścieżkę według swojej wygody. |
Na koniec otwórz nowy wiersz polecenia i wpisz Scala -versioni naciśnij Enter. Powinieneś zobaczyć następujące -
Platforma | Komenda | Wynik |
---|---|---|
Windows | \> scala -version |
Scala code runner w wersji 2.13.1 - Copyright 2002-2019, LAMP / EPFL and Lightbend, Inc. |
Linux | $ scala -version |
Scala code runner w wersji 2.13.1 - Copyright 2002-2019, LAMP / EPFL and Lightbend, Inc. tut |
Scala zapewnia strukturę danych, plik array, który przechowuje sekwencyjną kolekcję elementów tego samego typu o stałym rozmiarze. Tablica jest używana do przechowywania kolekcji danych, ale często bardziej przydatne jest myślenie o tablicy jako o zbiorze zmiennych tego samego typu.
Zamiast deklarować pojedyncze zmienne, takie jak liczba0, liczba1, ... i liczba99, deklarujesz jedną zmienną tablicową, taką jak liczby, i używasz liczb [0], liczb [1] i ..., liczb [99] do reprezentowania indywidualne zmienne. W tym samouczku przedstawiono, jak deklarować zmienne tablicowe, tworzyć tablice i przetwarzać tablice przy użyciu zmiennych indeksowanych. Indeks pierwszego elementu tablicy to liczba zero, a indeks ostatniego elementu to całkowita liczba elementów minus jeden.
Deklarowanie zmiennych tablicowych
Aby użyć tablicy w programie, należy zadeklarować zmienną odwołującą się do tablicy i określić typ tablicy, do której zmienna może się odwoływać.
Poniżej przedstawiono składnię deklarowania zmiennej tablicowej.
Składnia
var z:Array[String] = new Array[String](3)
or
var z = new Array[String](3)
Tutaj z jest zadeklarowane jako tablica ciągów, która może zawierać do trzech elementów. Wartości można przypisać do poszczególnych elementów lub uzyskać dostęp do poszczególnych elementów, można to zrobić za pomocą poleceń takich jak:
Komenda
z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"
Tutaj ostatni przykład pokazuje, że generalnie indeksem może być dowolne wyrażenie, które daje liczbę całkowitą. Jest jeszcze jeden sposób definiowania tablicy -
var z = Array("Zara", "Nuha", "Ayan")
Poniższy rysunek przedstawia tablicę myList. Tutaj,myList zawiera dziesięć podwójnych wartości, a indeksy wynoszą od 0 do 9.
![](https://post.nghiatu.com/assets/tutorial/scala_collections/images/scala_array.jpg)
Przetwarzanie tablic
Podczas przetwarzania elementów tablicy często używamy struktur kontrolnych pętli, ponieważ wszystkie elementy w tablicy są tego samego typu i znany jest rozmiar tablicy.
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać tablice -
Przykład
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);
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
Scala nie obsługuje bezpośrednio różnych operacji tablicowych i zapewnia różne metody przetwarzania tablic w dowolnym wymiarze. Jeśli chcesz użyć różnych metod, musisz zaimportowaćArray._ pakiet.
Istnieje wiele sytuacji, w których należałoby zdefiniować i używać tablic wielowymiarowych (tj. Tablic, których elementami są tablice). Na przykład macierze i tabele są przykładami struktur, które można zrealizować jako tablice dwuwymiarowe.
Poniżej znajduje się przykład definiowania dwuwymiarowej tablicy -
var myMatrix = ofDim[Int](3,3)
Jest to tablica składająca się z trzech elementów, z których każdy jest tablicą liczb całkowitych, która ma trzy elementy.
Wypróbuj poniższy przykładowy program do przetwarzania wielowymiarowej tablicy -
Przykład
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();
}
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
0 1 2
0 1 2
0 1 2
Użycie metody range () do wygenerowania tablicy zawierającej sekwencję rosnących liczb całkowitych w podanym zakresie. Możesz użyć końcowego argumentu jako kroku do utworzenia sekwencji; jeśli nie użyjesz argumentu końcowego, to krok zostanie przyjęty jako 1.
Weźmy przykład tworzenia tablicy z zakresu (10, 20, 2): Oznacza to tworzenie tablicy z elementami od 10 do 20 i różnicą zakresu 2. Elementy tablicy to 10, 12, 14, 16 i 18 .
Inny przykład: zakres (10, 20). Tutaj różnica zakresu nie jest podana, więc domyślnie przyjmuje 1 element. Tworzy tablicę z elementami od 10 do 20 z różnicą zakresu 1. Elementy w tablicy to 10, 11, 12, 13, ... i 19.
Poniższy przykładowy program pokazuje, jak utworzyć tablicę z zakresami.
Przykład
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 )
}
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19
Scala zapewnia strukturę danych, plik ArrayBuffer, który może zmienić rozmiar, gdy rozmiar początkowy jest za mały. Ponieważ tablica ma stały rozmiar i nie można w niej zajmować więcej elementów, ArrayBuffer jest alternatywą dla tablicy, w której rozmiar jest elastyczny.
Wewnętrznie ArrayBuffer przechowuje tablicę o bieżącym rozmiarze do przechowywania elementów. Po dodaniu nowego elementu sprawdzany jest rozmiar. W przypadku, gdy podstawowa tablica jest pełna, tworzona jest nowa, większa tablica, a wszystkie elementy są kopiowane do większej tablicy.
Deklarowanie zmiennych ArrayBuffer
Poniżej przedstawiono składnię deklarowania zmiennej ArrayBuffer.
Składnia
var z = ArrayBuffer[String]()
Tutaj z jest zadeklarowany jako bufor tablicowy zawierający ciągi znaków, który jest początkowo pusty. Wartości można dodawać za pomocą poleceń takich jak następujące -
Komenda
z += "Zara";
z += "Nuha";
z += "Ayan";
Przetwarzanie ArrayBuffer
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać ArrayBuffer -
Przykład
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));
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
ArrayBuffer(Zara, Nuha, Ayan)
ArrayBuffer(Zara, Nuha, Ayan, Welcome, To, Tutorialspoint)
Nuha
Listy Scala są dość podobne do tablic, co oznacza, że wszystkie elementy listy mają ten sam typ, ale są dwie ważne różnice. Po pierwsze, listy są niezmienne, co oznacza, że elementów listy nie można zmieniać przez przypisanie. Po drugie, listy reprezentują listę połączoną, podczas gdy tablice są płaskie.
Typ listy zawierającej elementy typu T jest zapisywany jako List[T].
Wypróbuj następujący przykład, oto kilka list zdefiniowanych dla różnych typów danych.
// 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)
)
Wszystkie listy można zdefiniować za pomocą dwóch podstawowych bloków konstrukcyjnych, ogona Nil i ::, który jest wymawiany cons. Brak reprezentuje również pustą listę. Wszystkie powyższe listy można zdefiniować w następujący sposób.
// 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
Podstawowe operacje na listach
Wszystkie operacje na listach można wyrazić za pomocą trzech poniższych metod.
Sr.No | Metody i opis |
---|---|
1 | head Ta metoda zwraca pierwszy element listy. |
2 | tail Ta metoda zwraca listę zawierającą wszystkie elementy oprócz pierwszego. |
3 | isEmpty Ta metoda zwraca wartość true, jeśli lista jest pusta, w przeciwnym razie false. |
Poniższy przykład pokazuje, jak używać powyższych metod.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Head of fruit : apples
Tail of fruit : List(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true
Listy łączone
Możesz użyć jednego z nich ::: operator lub List.:::() metoda lub List.concat()metoda dodawania dwóch lub więcej list. Proszę znaleźć następujący przykład podany poniżej -
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
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)
Tworzenie jednolitych list
Możesz użyć List.fill()metoda tworzy listę składającą się z zera lub więcej kopii tego samego elementu. Wypróbuj następujący przykładowy program.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
fruit : List(apples, apples, apples)
num : List(2, 2, 2, 2, 2, 2, 2, 2, 2, 2)
Tabelarowanie funkcji
Możesz użyć funkcji razem z List.tabulate()metoda, która ma być zastosowana do wszystkich elementów listy przed umieszczeniem listy w tabeli. Jego argumenty są takie same, jak te z List.fill: pierwszy argument lista podaje wymiary listy do utworzenia, a drugi opisuje elementy listy. Jedyna różnica polega na tym, że zamiast naprawianych elementów są one obliczane z funkcji.
Wypróbuj następujący przykładowy program.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
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))
Odwróć kolejność listy
Możesz użyć List.reversemetoda odwrócenia wszystkich elementów listy. Poniższy przykład pokazuje użycie.
Przykład
object Demo {
def main(args: Array[String]) {
val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
println( "Before reverse fruit : " + fruit )
println( "After reverse fruit : " + fruit.reverse )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Before reverse fruit : List(apples, oranges, pears)
After reverse fruit : List(pears, oranges, apples)
Scala zapewnia strukturę danych, plik ListBuffer, co jest bardziej wydajne niż lista podczas dodawania / usuwania elementów na liście. Zapewnia metody dodawania elementów przed i dołączania elementów do listy.
Deklarowanie zmiennych ListBuffer
Poniżej przedstawiono składnię deklarowania zmiennej ListBuffer.
Składnia
var z = ListBuffer[String]()
Tutaj z jest zadeklarowany jako bufor listy ciągów, który jest początkowo pusty. Wartości można dodawać za pomocą poleceń takich jak następujące -
Komenda
z += "Zara";
z += "Nuha";
z += "Ayan";
Przetwarzanie ListBuffer
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać ListBuffer -
Przykład
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));
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
ListBuffer(Zara, Nuha, Ayan)
ListBuffer(Zara, Nuha, Ayan, Welcome, To, Tutorialspoint)
Nuha
Zestaw Scala to zbiór par różnych elementów tego samego typu. Innymi słowy, zestaw to kolekcja, która nie zawiera zduplikowanych elementów. ListSet implementuje niezmienne zestawy i używa struktury listy. Podczas ich przechowywania zachowywana jest kolejność wstawiania elementów.
Deklarowanie zmiennych ListSet
Poniżej przedstawiono składnię deklarowania zmiennej ListSet.
Składnia
var z : ListSet[String] = ListSet("Zara","Nuha","Ayan")
Tutaj z jest zadeklarowany jako zestaw ciągów znaków, który ma trzech członków. Wartości można dodawać za pomocą poleceń takich jak następujące -
Komenda
var myList1: ListSet[String] = myList + "Naira";
Przetwarzanie zestawu list
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać ListSet -
Przykład
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);
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
ListSet(Zara, Nuha, Ayan)
ListSet(Zara, Nuha, Ayan, Naira)
ListSet(Zara, Ayan)
ListSet()
Scala Vector to niezmienna struktura danych ogólnego przeznaczenia, w której do elementów można uzyskać losowy dostęp. Zwykle jest używany do dużych zbiorów danych.
Deklarowanie zmiennych wektorowych
Poniżej przedstawiono składnię deklarowania zmiennej Vector.
Składnia
var z : Vector[String] = Vector("Zara","Nuha","Ayan")
Tutaj z jest zadeklarowany jako wektor ciągów, który ma trzy elementy. Wartości można dodawać za pomocą poleceń takich jak następujące -
Komenda
var vector1: Vector[String] = z + "Naira";
Przetwarzanie wektora
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać Vector -
Przykład
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);
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Vector(Zara, Nuha, Ayan)
Vector(Zara, Nuha, Ayan, Naira)
Vector(Ayan, Nuha, Zara)
Vector(Ayan, Naira, Nuha, Zara)
Zestaw Scala to zbiór par różnych elementów tego samego typu. Innymi słowy, zestaw to kolekcja, która nie zawiera zduplikowanych elementów. Istnieją dwa rodzaje zestawówimmutable i mutable. Różnica między obiektami zmiennymi i niezmiennymi polega na tym, że gdy obiekt jest niezmienny, sam obiekt nie może zostać zmieniony.
Domyślnie Scala używa niezmiennego zestawu. Jeśli chcesz użyć mutowalnego zestawu, musisz zaimportowaćscala.collection.mutable.Setklasa jawnie. Jeśli chcesz używać zarówno zmiennych, jak i niezmiennych zestawów w tej samej kolekcji, możesz nadal odwoływać się do niezmiennego zestawu jakoSet ale możesz odwołać się do mutable Set as mutable.Set.
Oto jak możesz zadeklarować niezmienne zestawy -
Składnia
// 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)
Podczas definiowania pustego zestawu adnotacja typu jest konieczna, ponieważ system musi przypisać konkretny typ do zmiennej.
Podstawowe operacje na planie
Wszystkie operacje na zbiorach można wyrazić za pomocą następujących trzech metod -
Sr.No | Metody i opis |
---|---|
1 | head Ta metoda zwraca pierwszy element zestawu. |
2 | tail Ta metoda zwraca zestaw składający się ze wszystkich elementów oprócz pierwszego. |
3 | isEmpty Ta metoda zwraca wartość true, jeśli zestaw jest pusty, w przeciwnym razie false. |
Wypróbuj następujący przykład pokazujący użycie podstawowych metod operacyjnych -
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Head of fruit : apples
Tail of fruit : Set(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true
Zestawy łączące
Możesz użyć jednego z nich ++ operator lub Set.++() metoda łączenia dwóch lub więcej zestawów, ale podczas dodawania zestawów usunie zduplikowane elementy.
Oto przykład łączenia dwóch zestawów.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
fruit1 ++ fruit2 : Set(banana, apples, mangoes, pears, oranges)
fruit1.++(fruit2) : Set(banana, apples, mangoes, pears, oranges)
Znajdź maks., Min. Elementów w zestawie
Możesz użyć Set.min metoda, aby znaleźć minimum i Set.maxmetoda, aby znaleźć maksimum elementów dostępnych w zestawie. Poniżej znajduje się przykład pokazujący program.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Min element in Set(5,6,9,20,30,45) : 5
Max element in Set(5,6,9,20,30,45) : 45
Znajdź wkładki dotyczące wspólnych wartości
Możesz użyć jednego z nich Set.& metoda lub Set.intersectmetoda, aby znaleźć wspólne wartości między dwoma zestawami. Wypróbuj poniższy przykład, aby pokazać użycie.
Przykład
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) )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
num1.&(num2) : Set(20, 9)
num1.intersect(num2) : Set(20, 9)
Zestaw bitów jest wspólną klasą bazową dla zmiennych i niezmiennych zestawów bitów. Zestawy bitów są zestawami nieujemnych liczb całkowitych i są reprezentowane jako tablice o zmiennej wielkości bitów upakowanych w 64-bitowe słowa. Ślad pamięci zestawu bitów jest reprezentowany przez największą przechowywaną w nim liczbę.
Deklarowanie zmiennych BitSet
Poniżej przedstawiono składnię deklarowania zmiennej BitSet.
Składnia
var z : BitSet = BitSet(0,1,2)
Tutaj z jest zadeklarowany jako zbiór bitów nieujemnych liczb całkowitych, który ma trzy elementy. Wartości można dodawać za pomocą poleceń takich jak następujące -
Komenda
var myList1: BitSet = myList + 3;
Przetwarzanie BitSet
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać BitSet -
Przykład
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);
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
BitSet(0, 1, 2)
BitSet(0, 1, 2, 3)
BitSet(0, 1)
BitSet(0, 1, 2, 3, 4, 5)
Zestaw Scala to zbiór par różnych elementów tego samego typu. Innymi słowy, zestaw to kolekcja, która nie zawiera zduplikowanych elementów. HashSet implementuje niezmienne zestawy i używa tablicy skrótów. Kolejność wstawiania elementów nie jest zachowywana.
Deklarowanie zmiennych HashSet
Poniżej przedstawiono składnię deklarowania zmiennej HashSet.
Składnia
var z : HashSet[String] = HashSet("Zara","Nuha","Ayan")
Tutaj z jest zadeklarowany jako zestaw skrótów ciągów, który ma trzech członków. Wartości można dodawać za pomocą poleceń takich jak następujące -
Komenda
var myList1: HashSet[String] = myList + "Naira";
Przetwarzanie HashSet
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać HashSet -
Przykład
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);
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
HashSet(Zara, Nuha, Ayan)
HashSet(Zara, Nuha, Ayan, Naira)
HashSet(Zara, Ayan)
HashSet()
Zestaw Scala to zbiór par różnych elementów tego samego typu. Innymi słowy, zestaw to kolekcja, która nie zawiera zduplikowanych elementów. TreeSet implementuje niezmienne zestawy i utrzymuje elementy w posortowanej kolejności.
Deklarowanie zmiennych TreeSet
Poniżej przedstawiono składnię deklarowania zmiennej TreeSet.
Składnia
var z : TreeSet[String] = TreeSet("Zara","Nuha","Ayan")
Tutaj z jest zadeklarowany jako zbiór ciągów znaków, który ma trzy elementy. Wartości można dodawać za pomocą poleceń takich jak następujące -
Komenda
var myList1: TreeSet[String] = myList + "Naira";
Przetwarzanie TreeSet
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjalizować i przetwarzać TreeSet -
Przykład
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);
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
TreeSet(Ayan, Nuha, Zara)
TreeSet(Ayan, Naira, Nuha, Zara)
TreeSet(Ayan, Zara)
TreeSet()
Mapa Scala to zbiór par klucz / wartość. Dowolną wartość można pobrać na podstawie jej klucza. Klucze są unikalne na mapie, ale wartości nie muszą być niepowtarzalne. Mapy są również nazywane tabelami mieszania. Istnieją dwa rodzaje map:immutable i mutable. Różnica między obiektami zmiennymi i niezmiennymi polega na tym, że gdy obiekt jest niezmienny, sam obiekt nie może zostać zmieniony.
Domyślnie Scala używa niezmiennej mapy. Jeśli chcesz użyć mutowalnej mapy, musisz zaimportowaćscala.collection.mutable.Mapklasa jawnie. Jeśli chcesz używać zarówno zmiennych, jak i niezmiennych map w tym samym, możesz nadal odnosić się do niezmiennej mapy jakoMap ale możesz odwołać się do zestawu zmiennego jako mutable.Map.
Poniżej przedstawiono przykładowe instrukcje deklarujące niezmienne mapy -
// 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")
Podczas definiowania pustej mapy konieczne jest podanie typu, ponieważ system musi przypisać konkretny typ zmiennej. Jeśli chcemy dodać parę klucz-wartość do mapy, możemy użyć operatora + w następujący sposób.
A + = ('I' -> 1)
A + = ('J' -> 5)
A + = ('K' -> 10)
A + = ('L' -> 100)
Podstawowe operacje na MAP
Wszystkie operacje na mapach można wyrazić za pomocą trzech poniższych metod.
Sr.No | Metody i opis |
---|---|
1 | keys Ta metoda zwraca iterację zawierającą każdy klucz w mapie. |
2 | values Ta metoda zwraca iterowalną wartość zawierającą każdą wartość w mapie. |
3 | isEmpty Ta metoda zwraca wartość true, jeśli mapa jest pusta, w przeciwnym razie false. |
Wypróbuj poniższy przykładowy program pokazujący użycie metod Map.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
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
Mapy łączone
Możesz użyć jednego z nich ++ operator lub Map.++() metoda łączenia dwóch lub więcej map, ale podczas dodawania map usunie zduplikowane klucze.
Wypróbuj poniższy przykładowy program, aby połączyć dwie mapy.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
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)
Drukowanie kluczy i wartości z mapy
Możesz iterować przez klucze i wartości Map używając pętli „foreach”. Tutaj użyliśmy metodyforeachzwiązane z iteratorem, aby przejść przez klucze. Poniżej znajduje się przykładowy program.
Przykład
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) )
}
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F
Sprawdź klucz na mapie
Możesz użyć jednego z nich Map.containsmetoda, aby sprawdzić, czy dany klucz istnieje w mapie, czy nie. Wypróbuj poniższy przykładowy program, aby sprawdzić klucz.
Przykład
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")
}
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Red key exists with value :#FF0000
Maroon key does not exist
Mapa Scala to zbiór par klucz / wartość. Dowolną wartość można pobrać na podstawie jej klucza. Klucze są unikalne na mapie, ale wartości nie muszą być niepowtarzalne. HashMap implementuje niezmienną mapę i używa tablicy skrótów do implementacji tego samego.
Deklarowanie zmiennych HashMap
Poniżej przedstawiono składnię deklarowania zmiennej HashMap.
Składnia
val colors = HashMap("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")
Tutaj kolory są zadeklarowane jako mapa skrótów ciągów, Int, która ma trzy pary klucz-wartość. Wartości można dodawać za pomocą poleceń takich jak następujące -
Komenda
var myMap1: HashMap[Char, Int] = colors + ("black" -> "#000000");
Przetwarzanie HashMap
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjalizować i przetwarzać HashMap -
Przykład
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);
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
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()
Mapa Scala to zbiór par klucz / wartość. Dowolną wartość można pobrać na podstawie jej klucza. Klucze są unikalne na mapie, ale wartości nie muszą być niepowtarzalne. ListMap implementuje niezmienną mapę i używa listy do implementacji tego samego. Jest używany z małą liczbą elementów.
Deklarowanie zmiennych ListMap
Poniżej przedstawiono składnię deklarowania zmiennej ListMap.
Składnia
val colors = ListMap("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")
Tutaj kolory są zadeklarowane jako mapa skrótów ciągów, Int, która ma trzy pary klucz-wartość. Wartości można dodawać za pomocą poleceń takich jak następujące -
Komenda
var myMap1: ListMap[Char, Int] = colors + ("black" -> "#000000");
Przetwarzanie ListMap
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjalizować i przetwarzać ListMap -
Przykład
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);
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
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 nie jest zbiorem, ale raczej sposobem na dostęp do elementów kolekcji jeden po drugim. Dwie podstawowe operacje naiterator it są next i hasNext. Wezwanie doit.next()zwróci następny element iteratora i zmieni stan iteratora. Możesz dowiedzieć się, czy jest więcej elementów do zwrócenia, korzystając z iteratorówit.hasNext metoda.
Najprostszym sposobem „przejścia przez” wszystkie elementy zwracane przez iterator jest użycie pętli while. Prześledźmy następujący przykładowy program.
Przykład
object Demo {
def main(args: Array[String]) {
val it = Iterator("a", "number", "of", "words")
while (it.hasNext){
println(it.next())
}
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
a
number
of
words
Znajdź element o wartości minimalnej i maksymalnej
Możesz użyć it.min i it.maxmetody znajdowania elementów o minimalnej i maksymalnej wartości z iteratora. Tutaj używaliśmyita i itbdo wykonania dwóch różnych operacji, ponieważ przez iterator można przejść tylko raz. Poniżej znajduje się przykładowy program.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Maximum valued element 90
Minimum valued element 2
Znajdź długość iteratora
Możesz użyć jednego z nich it.size lub it.lengthmetody, aby znaleźć liczbę elementów dostępnych w iteratorze. Tutaj użyliśmy ita i itb do wykonania dwóch różnych operacji, ponieważ przez iterator można przejść tylko raz. Poniżej znajduje się przykładowy program.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Value of ita.size : 6
Value of itb.length : 6
Opcja Scala [T] to kontener na zero lub jeden element danego typu. Opcją [T] może być dowolnaSome[T] lub Noneobiekt, który reprezentuje brakującą wartość. Na przykład metoda get mapy Scali daje Some (wartość), jeśli została znaleziona wartość odpowiadająca danemu kluczowi, lubNone jeśli dany klucz nie jest zdefiniowany w Map.
Typ opcji jest często używany w programach Scala i można go porównać z nullwartość dostępna w Javie, która oznacza brak wartości. Na przykład metoda get z java.util.HashMap zwraca wartość przechowywaną w HashMap lub null, jeśli nie znaleziono żadnej wartości.
Powiedzmy, że mamy metodę, która pobiera rekord z bazy danych na podstawie klucza podstawowego.
def findPerson(key: Int): Option[Person]
Metoda zwróci wartość Some [Person], jeśli rekord zostanie znaleziony, ale None, jeśli rekord nie zostanie znaleziony. Prześledźmy następujący program.
Przykład
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" ))
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
capitals.get( "France" ) : Some(Paris)
capitals.get( "India" ) : None
Najczęstszym sposobem rozdzielania wartości opcjonalnych jest dopasowanie do wzorca. Na przykład wypróbuj następujący program.
Przykład
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 => "?"
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
show(capitals.get( "Japan")) : Tokyo
show(capitals.get( "India")) : ?
Korzystanie z metody getOrElse ()
Poniżej znajduje się przykładowy program pokazujący, jak używać metody getOrElse () w celu uzyskania dostępu do wartości lub wartości domyślnej, gdy żadna wartość nie jest obecna.
Przykład
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) )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
a.getOrElse(0): 5
b.getOrElse(10): 10
Korzystanie z metody isEmpty ()
Poniżej znajduje się przykładowy program pokazujący, jak używać metody isEmpty () do sprawdzania, czy opcja ma wartość None, czy nie.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Przykład
a.isEmpty: false
b.isEmpty: true
Queue is First In First Out, struktura danych FIFO i pozwala na wstawianie i pobieranie elementów w sposób FIFO.
Deklarowanie zmiennych kolejki
Poniżej przedstawiono składnię deklarowania zmiennej kolejki.
Składnia
val queue = Queue(1, 2, 3, 4, 5)
Tutaj kolejka jest zadeklarowana jako kolejka liczb. Wartość można dodać z przodu za pomocą poleceń takich jak:
Komenda
queue.enqueue(6)
Wartość można pobrać z przodu za pomocą poleceń takich jak:
Komenda
queue.dequeue()
Kolejka przetwarzania
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać kolejkę -
Przykład
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+ " ")}
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
1 2 3 4 5
First Element: 1
1 2 3 4 5 6
Dequeued Element: 1
2 3 4 5 6
Krotka Scala łączy w sobie stałą liczbę elementów, dzięki czemu można je przekazywać jako całość. W przeciwieństwie do tablicy lub listy, krotka może zawierać obiekty różnych typów, ale są one również niezmienne.
Poniżej przedstawiono przykład krotki zawierającej liczbę całkowitą, ciąg znaków i konsolę.
val t = (1, "hello", Console)
Co to jest cukier syntaktyczny (skrót) dla następujących -
val t = new Tuple3(1, "hello", Console)
Rzeczywisty typ krotki zależy od liczby i elementów, które zawiera, oraz typów tych elementów. Zatem typ (99, „Luftballons”) to Tuple2 [Int, String]. Typ ('u', 'r', "the", 1, 4, "me") to Tuple6 [Char, Char, String, Int, Int, String]
Krotki są typu Tuple1, Tuple2, Tuple3 i tak dalej. Obecnie w Scali istnieje górny limit 22, jeśli potrzebujesz więcej, możesz użyć kolekcji, a nie krotki. Dla każdego typu TupleN, gdzie 1 <= N <= 22, Scala definiuje szereg metod dostępu do elementów. Biorąc pod uwagę następującą definicję -
val t = (4,3,2,1)
Aby uzyskać dostęp do elementów krotki t, możesz użyć metody t._1, aby uzyskać dostęp do pierwszego elementu, t._2, aby uzyskać dostęp do drugiego i tak dalej. Na przykład poniższe wyrażenie oblicza sumę wszystkich elementów t.
val sum = t._1 + t._2 + t._3 + t._4
Możesz użyć Tuple do napisania metody, która pobiera List [Double] i zwraca liczbę, sumę i sumę kwadratów zwróconych w trzyelementowej Tuple, Tuple3 [Int, Double, Double]. Są również przydatne do przekazywania listy wartości danych jako komunikatów między aktorami w programowaniu współbieżnym.
Wypróbuj następujący przykładowy program. Pokazuje, jak używać krotki.
Przykład
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 )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Polecenia
\>scalac Demo.scala
\>scala Demo
Wynik
Sum of elements: 10
Iteruj po Tuple
Możesz użyć Tuple.productIterator() metoda iteracji po wszystkich elementach krotki.
Wypróbuj poniższy przykładowy program, aby wykonać iterację po krotkach.
Przykład
object Demo {
def main(args: Array[String]) {
val t = (4,3,2,1)
t.productIterator.foreach{ i =>println("Value = " + i )}
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Polecenia
\>scalac Demo.scala
\>scala Demo
Wynik
Value = 4
Value = 3
Value = 2
Value = 1
Konwersja do String
Możesz użyć Tuple.toString()metoda łączenia wszystkich elementów krotki w ciąg. Wypróbuj poniższy przykładowy program, aby przekonwertować na ciąg.
Przykład
object Demo {
def main(args: Array[String]) {
val t = new Tuple3(1, "hello", Console)
println("Concatenated String: " + t.toString() )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Concatenated String: (1,hello,scala.Console$@281acd47)
Zamień elementy
Możesz użyć Tuple.swap metoda, aby zamienić elementy Tuple2.
Wypróbuj poniższy przykładowy program, aby zamienić elementy.
Przykład
object Demo {
def main(args: Array[String]) {
val t = new Tuple2("Scala", "hello")
println("Swapped Tuple: " + t.swap )
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Swapped tuple: (hello,Scala)
Scala Seq to cecha reprezentująca niezmienne sekwencje. Ta struktura zapewnia dostęp w oparciu o indeksy i różne narzędzia użytkowe do znajdowania elementów, ich występowania i podciągów. Sekwencja utrzymuje zamówienie reklamowe.
Deklarowanie zmiennych sekwencyjnych
Poniżej przedstawiono składnię deklarowania zmiennej Seq.
Składnia
val seq: Seq[Int] = Seq(1, 2, 3, 4, 5)
Tutaj sekwencja jest zadeklarowana jako Sekwencja liczb. Seq udostępnia polecenia takie jak następujące -
Komenda
val isPresent = seq.contains(4);
val contains = seq.endsWith(Seq(4,5));
var lastIndexOf = seq.lasIndexOf(5);
Sekwencja przetwarzania
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać Seq -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
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 is Last In First Out, struktura danych LIFO i pozwala na wstawianie i pobieranie elementu u góry, w sposób LIFO.
Deklarowanie zmiennych stosu
Poniżej przedstawiono składnię deklarowania zmiennej stosu.
Składnia
val stack = Stack(1, 2, 3, 4, 5)
Tutaj stos jest zadeklarowany jako stos liczb. Wartość można dodać u góry za pomocą poleceń takich jak:
Komenda
stack.push(6)
Wartość można pobrać od góry za pomocą poleceń takich jak:
Komenda
stack.top
Wartość można usunąć od góry za pomocą poleceń takich jak:
Komenda
stack.pop
Przetwarzanie stosu
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać stos -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Top Element: 2
Removed Element: 2
Top Element: 1
Scala Stream to specjalna lista z funkcją leniwej oceny. W strumieniu scala elementy są oceniane tylko wtedy, gdy są potrzebne. Stream obsługuje leniwe obliczenia i zna wydajność.
Deklarowanie zmiennych strumienia
Poniżej przedstawiono składnię deklarowania zmiennej Stream.
Składnia
val stream = 1 #:: 2 #:: 3 #:: Stream.empty
Tutaj strumień jest zadeklarowany jako strumień liczb. Tutaj 1 to początek strumienia, 2, 3 to koniec strumienia. Stream.empty oznacza koniec strumienia. Wartości można pobrać za pomocą poleceń take, takich jak:
Komenda
stream.take(2)
Przetwarzanie strumienia
Poniżej znajduje się przykładowy program pokazujący, jak tworzyć, inicjować i przetwarzać Stream -
Przykład
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")
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Stream(1, <not computed>)
1, 2
Stream: Stream()
drop () jest metodą używaną przez List do wybierania wszystkich elementów z wyjątkiem pierwszych n elementów listy.
Składnia
Poniżej przedstawiono składnię metody drop.
def drop(n: Int): List[A]
Tutaj n to liczba elementów do usunięcia z listy. Ta metoda zwraca wszystkie elementy listy oprócz pierwszych n.
Stosowanie
Poniżej przykładowy program pokazujący jak używać metody drop -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
List(1, 2, 3, 4, 5)
List(4, 5)
dropWhile () jest metodą używaną przez List do usuwania wszystkich elementów spełniających dany warunek.
Składnia
Poniżej przedstawiono składnię metody dropWhile.
def dropWhile(p: (A) => Boolean): List[A]
Tutaj p: (A) => Boolean to predykat lub warunek, który ma być zastosowany do każdego elementu listy. Ta metoda zwraca wszystkie elementy listy z wyjątkiem usuniętych.
Stosowanie
Poniżej przykładowy program pokazujący jak używać metody dropWhile -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
List(3, 6, 9, 4, 2)
List(4, 2)
metoda filter () to metoda używana przez List do wybierania wszystkich elementów spełniających dany predykat.
Składnia
Poniżej przedstawiono składnię metody filtrującej.
def filter(p: (A) => Boolean): List[A]
Tutaj p: (A) => Boolean to predykat lub warunek, który ma być zastosowany do każdego elementu listy. Ta metoda zwraca wszystkie elementy listy, które spełniają zadany warunek.
Stosowanie
Poniżej przykładowy program pokazujący, jak korzystać z metody filtrowania -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
List(3, 6, 9, 4, 2)
List(3, 6, 9)
find () jest metodą używaną przez Iteratory do znajdowania elementu spełniającego zadany predykat.
Składnia
Poniżej przedstawiono składnię metody find.
def find(p: (A) => Boolean): Option[A]
Tutaj p: (A) => Boolean to predykat lub warunek do zastosowania na każdym elemencie iteratora. Ta metoda zwraca element Option zawierający dopasowany element iteratora, który spełnia podany warunek.
Stosowanie
Poniżej przykładowy program pokazujący, jak używać metody find -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
Some(3)
flatMap () jest metodą cechy TraversableLike, pobiera predykat, stosuje go do każdego elementu kolekcji i zwraca nową kolekcję elementów zwróconych przez predykat.
Składnia
Poniżej przedstawiono składnię metody flatMap.
def flatMap[B](f: (A) ? GenTraversableOnce[B]): TraversableOnce[B]
Tutaj, f: (A)? GenTraversableOnce [B] jest predykatem lub warunkiem do zastosowania w każdym elemencie kolekcji. Ta metoda zwraca element Option zawierający dopasowany element iteratora, który spełnia podany warunek.
Stosowanie
Poniżej przykładowy program pokazujący jak korzystać z metody flatMap -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
List(1, 2, 5, 6, 10, 11)
flatten () jest cechą składową GenericTraversableTemplate, zwraca pojedynczą kolekcję elementów poprzez scalenie kolekcji podrzędnych.
Składnia
Poniżej przedstawiono składnię metody flatten.
def flatten[B]: Traversable[B]
Tutaj, f: (A)? GenTraversableOnce [B] jest predykatem lub warunkiem do zastosowania w każdym elemencie kolekcji. Ta metoda zwraca element Option zawierający dopasowany element iteratora, który spełnia podany warunek.
Stosowanie
Poniżej przykładowy program pokazujący jak używać metody spłaszczania -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
List(1, 2, 3, 4)
fold () należy do cechy TraversableOnce i służy do zwijania elementów kolekcji.
Składnia
Poniżej przedstawiono składnię metody fold.
def fold[A1 >: A](z: A1)(op: (A1, A1) ? A1): A1
W tym przypadku metoda fold przyjmuje funkcję asocjacyjnego operatora binarnego jako parametr. Ta metoda zwraca wynik jako wartość. Traktuje pierwsze wejście jako wartość początkową, a drugie wejście jako funkcję (która przyjmuje skumulowaną wartość i bieżącą pozycję jako dane wejściowe).
Stosowanie
Poniżej przykładowy program pokazujący jak używać metody fold -
Przykład
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)
}
}
Tutaj przekazaliśmy 0 jako wartość początkową funkcji fold, a następnie wszystkie wartości są dodawane. Zapisz powyższy program w formacieDemo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
10
foldLeft () jest składnikiem cechy TraversableOnce, służy do zwijania elementów kolekcji. Nawiguje po elementach od lewej do prawej. Jest używany głównie w funkcjach rekurencyjnych i zapobiega wyjątkom przepełnienia stosu.
Składnia
Poniżej przedstawiono składnię metody fold.
def foldLeft[B](z: B)(op: (B, A) ? B): B
Tutaj metoda foldLeft przyjmuje funkcję asocjacyjnego operatora binarnego jako parametr. Ta metoda zwraca wynik jako wartość.
Stosowanie
Poniżej przykładowy program pokazujący jak używać metody foldLeft -
Przykład
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)
}
}
Tutaj przekazaliśmy 0 jako wartość początkową funkcji fold, a następnie wszystkie wartości są dodawane. Zapisz powyższy program w formacieDemo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
10
foldRight () jest składową cechy TraversableOnce, służy do zwijania elementów kolekcji. Nawiguje po elementach w kolejności od prawej do lewej.
Składnia
Poniżej przedstawiono składnię metody foldRight.
def foldRight[B](z: B)(op: (B, A) ? B): B
W tym przypadku metoda fold przyjmuje funkcję asocjacyjnego operatora binarnego jako parametr. Ta metoda zwraca wynikową wartość.
Stosowanie
Poniżej przykładowy program pokazujący jak korzystać z metody foldRight -
Przykład
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)
}
}
Tutaj przekazaliśmy 0 jako wartość początkową funkcji foldRight, a następnie wszystkie wartości zostały dodane. Zapisz powyższy program w formacieDemo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
10
map () należy do cechy TraversableLike i służy do uruchamiania metody predykatu na każdym elemencie kolekcji. Zwraca nową kolekcję.
Składnia
Poniżej przedstawiono składnię metody map.
def map[B](f: (A) ? B): Traversable[B]
Tutaj metoda map przyjmuje funkcję prediatu jako parametr. Ta metoda zwraca zaktualizowaną kolekcję.
Stosowanie
Poniżej przykładowy program pokazujący jak korzystać z metody mapowej -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
List(2, 4, 6, 8)
Partition () jest składową cechy TraversableLike i służy do uruchamiania metody predykatu na każdym elemencie kolekcji. Zwraca dwie kolekcje, jedna kolekcja składa się z elementów spełniających daną funkcję predykatu, a druga z elementów, które nie spełniają danej funkcji predykatu.
Składnia
Poniżej przedstawiono składnię metody map.
def partition(p: (A) ? Boolean): (Repr, Repr)
W tym przypadku metoda partycji przyjmuje funkcję predykatu jako parametr. Ta metoda zwraca kolekcje.
Stosowanie
Poniżej przykładowy program pokazujący jak używać metody partycji -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
List(3, 6)
List(1, 2, 4, 5, 7)
Redukcja () jest składową cechy TraversableOnce i służy do zwijania elementów kolekcji. Jest podobna do metody zwijania, ale nie przyjmuje wartości początkowej.
Składnia
Poniżej przedstawiono składnię metody redukcji.
def reduce[A1 >: A](op: (A1, A1) ? A1): A1
W tym przypadku metoda REDR ma jako parametr funkcję asocjacyjnego operatora binarnego. Ta metoda zwraca wynikową wartość.
Stosowanie
Poniżej przykładowy program pokazujący jak używać metody fold -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
10
Metoda scan () jest składową cechy TraversableLike, jest podobna do metody fold, ale służy do wykonywania operacji na każdym elemencie kolekcji i zwracania kolekcji.
Składnia
Poniżej przedstawiono składnię metody fold.
def scan[B >: A, That](z: B)(op: (B, B) ? B)(implicit cbf: CanBuildFrom[Repr, B, That]): That
Tutaj metoda skanowania przyjmuje funkcję asocjacyjnego operatora binarnego jako parametr. Ta metoda zwraca jako wynik zaktualizowaną kolekcję. Traktuje pierwsze wejście jako wartość początkową, a drugie wejście jako funkcję.
Stosowanie
Poniżej przykładowy program pokazujący, jak korzystać z metody skanowania -
Przykład
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)
}
}
Tutaj przekazaliśmy 0 jako wartość początkową funkcji skanowania, a następnie wszystkie wartości są dodawane. Zapisz powyższy program w formacieDemo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
List(0, 1, 3, 6, 10)
zip () jest członkiem cechy IterableLike, służy do scalania kolekcji z bieżącą kolekcją, a wynikiem jest kolekcja par elementów krotki z obu kolekcji.
Składnia
Poniżej przedstawiono składnię metody zip.
def zip[B](that: GenIterable[B]): Iterable[(A, B)]
Tutaj metoda zip przyjmuje kolekcję jako parametr. Ta metoda zwraca jako wynik zaktualizowaną kolekcję par.
Stosowanie
Poniżej przykładowy program pokazujący jak korzystać z metody zip -
Przykład
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)
}
}
Zapisz powyższy program w formacie Demo.scala. Poniższe polecenia służą do kompilowania i wykonywania tego programu.
Komenda
\>scalac Demo.scala
\>scala Demo
Wynik
List((1,A), (2,B), (3,C), (4,D))