Scala KOVÁCS VINCENT

Gyűjtemények – Collections  Scala több féle gyűjteménnyel rendelkezik:  Listák (Lists)  Halmazok (Sets)  Maps  Tuple  A gyűjtemények lehetnek:  Strict vagy Lazy  Muttable vagy Inmuttable

Gyűjtemények – Listák 1  A tömbökhöz hasonlóak  Minden elemük azonos  Minden lista láncolt lista lesz  A lista elemei immutable -k így direkten nem módosíthatóak  Két fajta képen lehet deklarálni a listákat: val fruit: List[String] = List("apples", "oranges") val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))

Gyűjtemények – Listák 2  A lista elemeit elvégezhető alap műveletek:  Head  Tail  isEmpty  Két listát többféle képen lehet összefűzni:  list1 ::: list2  list1.:::(list2)  list1.concat(list2)

Gyűjtemények – Listák 3  Lista feltöltését ugyan azzal az elemmel a List.fill() metódussal lehetséges: val fruit = List.fill(3)("apples")  Lista feltöltését egy függvénnyel is definiálhatunk a List.tabulete() metódus segítségével: val squares = List.tabulate(6)(n => n * n)  Lehetőség van a lista elemeinek megfordítására a reverse() metódussal val fruit = "apples" :: ("oranges" :: ("pears" :: Nil)) println("Reversed order : " + fruit.reverse)

Gyűjtemények – Halmazok 1  Nem tartalmaz duplikátumokat  Lehet immutable és mutable  Alapértelmezetten immutable halmazokat érjük el  Ha mutable halmazokat szeretnénk használni akkor a scala.collection.mutable.Set kell importálni  Két féle képen lehet deklarálni: var s : Set[Int] = Set(1,3,5,7) var s = Set(1,3,5,7)

Gyűjtemények – Halmazok 2  A halmazok elemeit elvégezhető alap műveletek (hasonlók a listákhoz):  Head  Tail  isEmpty  Két listát többféle képen lehet összefűzni:  set1 ++ set2  set1.++(set2)

Gyűjtemények – Halmazok 3  Lehetőség van a minimális és a maximális elem megkeresésére a halmazban a min() és a max() metódusokkal val num = Set(5,6,9,20,30,45) println( "Min: " + num.min ) println( "Max: " + num.max )  Két halmaz metszetét a következő módszerekkel lehet elérni:  set1.intersect(set2)  set1.&(set2)

Gyűjtemények – Map 1  Kulcs érték párokat tartalmazó gyűjtemény  A kulcsok egyediek  Lehet immutable és mutable  Alapértelmezetten immutable mapot érjük el  Ha mutable mapot szeretnénk használni akkor a scala.collection.mutable.Map kell importálni  Két féle képen lehet példányosítani: var A:Map[Char,Int] = Map() A += ('I' -> 1) val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

Gyűjtemények – Map 2  A map elemeit elvégezhető alap műveletek (hasonlók a listákhoz):  Keys  Values  isEmpty  contains  Két map összefűzését a következő módszerekkel lehet elérni:  set1 ++ set2  set1.++(set2)

Gyűjtemények – Tuple 1  Gyűjtemények, amik különböző típusú elemeket tartalmazhatnak  Nem lehet őket megváltoztatni val t = (1, "helo" Console)  A fenti kódrészlet rövidítése a következőnek: val t = new Tuple3(1, "helo" Console)  A paraméterszámától függően kell a megadni a TupleN osztály „számát”  Ez a szám 1 < N < 22 között lehet  Az egyes elemeket a t._N sémával lehet elérni

Gyűjtemények – Tuple 2  Végig lehet iterálni a productIterator metódussal val t = (4,3,2,1) t.productIterator.foreach{ i => println("Value = " + i) }  A toString metódussal összefűzi a Tuple -ben található elemeket println("Concatenated string “ + t.toString())  A Tuple2 esetében létezik egy swap metódus amivel, a benne található elemek megcserélhetőek println("Swapped Tuple: " + t.swap)

Ko- és Kontravariancia  A generikus paraméterek megszoríthatjuk két féle képen:  Kovarianciával  Kontravarianciával  Kovariancia  Generikus paraméternél A[+T] –vel tudjuk jelölni  Jelentése, ha B típus C típus altípusa, akkor A[B] az A[C] altípusa lesz  Kontravariancia  Generikus paraméternél A[-T] –vel tudjuk jelölni  Jelentése, ha B típus C típus altípusa, akkor A[C] az A[B] altípusa lesz

Reguláris kifejezések 1  A Regex osztállyal érhetőek el, ami a scala.util.matching csomagban található  A findFirstIn metódussal az első találat kapható vissza  A findAllIn metódussal az összes találat visszakapható egy gyűjtemény formájában val pattern = new Regex("(S|s)cala") val str = "Scala is scalable and cool" println((pattern findAllIn str).mkString(","))

Reguláris kifejezések 2  Lehetőség van reguláris kifejezések alapján cserélni is  A replaceFirstIn kicseréli az első találatot a megadott szövegre  A replaceAllIn kicseréli az összes találatot a megadott szövegre val pattern = "(S|s)cala".r val str = "Scala is scalable and cool" println (pattern replaceFirstIn(str, "Java"))

Case osztályok  Egyik leggyakoribb adatábrázolási forma a fa struktúra  A Scala a fa struktúra megvalósításhoz két nyelv tulajdonságait ötvözi:  JAVA – absztrakt szuper osztály, melyből származnak a specifikus levelek  Funkcionális programozási nyelv – algebrai adattípus  Egy egyszerű matematikai műveletek reprezentáló program abstract class Tree case class Sum(l: Tree, r: Tree) extends Tree case class Var(n: String) extends Tree case class Const(v: Int) extends Tree + 12

Case osztályok – Előnyök  A new kulcsó nem szükséges ezeknek az osztályoknak a példányosításához A new Const(5) helyett írhatjuk, hogy Const(5)  A getter metódusok automatikusan létrehozásra kerülnek a konstruktorban definiált változókhoz Ha c a Const egy példánya, akkor írhatjuk, hogy c.v  A fordító automatikusan generál equals és a hashCode metódusokat, amelyek az adatstruktúra példányain működnek  A toString metódus is alapértelmezetten kitöltésre kerül és forrásban megadott formátumot használja Például a x + 1 kifejezés úgy íródik ki, hogy: Sum(Var(x), Const(1))

Case osztályok – Mintaillesztés 1  Végezzünk kiértékelést az előbb említett adatstruktúrán type Environment = String => Int def eval(t: Tree, env: Environment): Int = t match { case Sum(l, r) => eval(l, env) + eval(r, env) case Var(n) => env(n) case Const(v) => v } eval(Sum(Sum(Var("x"),Var("x")),{case "x" => 5})

Case osztályok – Mintaillesztés 2  Végezzünk kiértékelést az előbb említett adatstruktúrán def derive(t: Tree, v: String): Tree = t match { case Sum(l, r) => Sum(derive(l, v), derive(r, v)) case Var(n) if (v == n) => Const(1) case _ => Const(0) } derive(Sum(Sum(Var("x"), Var("x")), "x")  Eredménye: Sum(Sum(Const(1), Const(1))

Köszönöm a figyelmet! Kovács Vincent