Scala Cheat Sheet¶
- Author : Waris RADJI student at University of Paris XIII
- Source : https://www.amazon.fr/SCALA-Pas-%C3%A0-Gildas-M%C3%A9nier/dp/2340000092
Table of Contents
- Scala Cheat Sheet
- Scala essentials
- Object oriented programming
- Arrays
- Main collections
- Collections in detail
- Object oriented programming
Scala essentials¶
In [1]:
var a = 5 // variable
var b: Int = 5 // variable with explicit typing
val zero = 0 // constant
Out[1]:
Display and Strings¶
In [2]:
val name = "joe"
"Hello " + name + " how are you ?"
// or
s"Hello $name how are you ?"
Out[2]:
In [3]:
s"2 + 2 = ${2+2}"
Out[3]:
In [4]:
raw"\nature"// The "\n" is not escaped
Out[4]:
In [5]:
printf("pi = %2.2f\n", 3.1415)
f"pi = ${3.1415}%2.2f"
Out[5]:
In [6]:
"""1...
2...
3."""
// ou
"""1...
|2...
|3.""".stripMargin // stripMargin("#") to change the default value
Out[6]:
Blocks and expressions¶
In [7]:
{val a = 6; val b = 4; a + b}
Out[7]:
In [8]:
def f: Int = {val a = 6; return a; val b = 7; a + b} // return interrupts the evaluation
Out[8]:
In [9]:
scala.math.sin(3.14)
// or (when the function only takes one parameter)
scala.math.sin{3.14}
Out[9]:
In [10]:
lazy val a = {println("Statement of a");1} // evaluate when the variable is called
val b = {println("Statement of b");2}
a+b
Out[10]:
Method definitions¶
In [11]:
def a = 1
Out[11]:
In [12]:
def sum(v1: Int, v2: Int) = v1 + v2
def sum1(v1: Int, v2: Int): Int = v1 + v2 // to indicate the type of return
Out[12]:
In [13]:
def zeroOrx(x: Int = 0) = x // parameter with default value
s"${zeroOrx()}, ${zeroOrx(100)}"
Out[13]:
In [14]:
def mean(x: Int*) = x.sum / x.size
mean(1, 2, 3, 4, 5)
Out[14]:
In [15]:
// procedure (Unit): possibility to remove the "="
def unit() {println("Unit")}
Out[15]:
In [16]:
val flagColor: (String, String, String) => String = (c1, c2, c3) => {c1 + " " + c2 + " " + c3}
// ou
val flagColor1 = (c1: String, c2: String, c3: String) => {c1 + " " + c2 + " " + c3}
Out[16]:
Conditional¶
In [17]:
if (scala.util.Random.nextFloat > 0.5) "win" else "loose"
Out[17]:
Pattern matching¶
In [18]:
scala.util.Random.nextInt match {
case 0 => println("zero")
case a if a > 0 => println("positive")
case a if a < 0 => println("negative")
case _ => println("end")
}
Exceptions¶
In [19]:
throw new Exception("...")
In [20]:
try {
1 / 0
} catch {
case ex: ArithmeticException => ex.printStackTrace()
case ex: Exception => ex.printStackTrace()
case _ => println("Nothing")
}
Out[20]:
Parametric type¶
In [21]:
def hey[T](x: T) = "Hey " + x.toString
// equivalent to
def hey1(x: Any) = "Hey " + x.toString
hey[String]("Joe") + " " + hey1(122)
Out[21]:
In [22]:
import Ordering.Implicits._
Out[22]:
In [23]:
def greaterThan[T: Ordering](x: T, y: T): Boolean = x > y
moreThan(1, 3)
In [24]:
type ArrInt = Array[Int] // type alias
Out[24]:
Object oriented programming¶
General hierarchy of classes / traits / objects¶
object¶
In [25]:
object Test {
def main(args: String*){
println("Hello world!")
}
}
Out[25]:
class¶
In [26]:
class Money(startMoney: Int) {
def this() = this(0) // builder
private var contain: Int = 0
def +=(money: Int) = contain += money
def empty = {val solde = contain; contain = 0; solde}
def howMany = contain
override def toString = contain.toString
}
object Money {
// method and static variables
def foo = "bar"
}
Out[26]:
In [27]:
val m = new Money()
m += 10
m.empty
Out[27]:
In [28]:
Money.foo
Out[28]:
Arrays¶
Declaration of array¶
In [29]:
val ints = new Array[Int](30) // empty array
val ints2 = Array[Int](1, 2, 3, 4) // array with init values
Out[29]:
In [30]:
val matrix4x9 = Array.ofDim[Double](4, 9)
Out[30]:
Access to the elements¶
In [31]:
ints2(3)
Out[31]:
In [32]:
ints2(3) = 1000
// or
ints2.update(3, 1000)
ints2(3)
Out[32]:
Iteration on the elements of an array¶
In [33]:
val days = Array("Monday", "Tuesday", "Wednesday", "Thrusday", "Friday", "Saturday", "Sunday")
Out[33]:
In [34]:
var i = 0
while(i < days.length){
println(days(i))
i += 1
}
Out[34]:
In [35]:
for (i <- 0 until days.length) println(days(i))
In [36]:
for (day <- days) println(day)
In [37]:
days foreach println
Creating an array by transformation¶
for/yield¶
In [38]:
val daysToUpperCase = for(day <- days) yield day.toUpperCase
Out[38]:
In [39]:
val daysWithLetterE = for(day <- days if day.contains("e")) yield day
Out[39]:
In [40]:
val ints = Array(1, 2, 3, 4)
val chars = Array('a', 'b', 'c', 'd')
for (int <- ints; char <- chars) yield int.toString + char.toString
Out[40]:
filter¶
In [41]:
Array(1, 2, 3, 4, 5).filter(x => x % 2 == 0)
Out[41]:
map¶
In [42]:
Array(1, 2, 3, 4, 5).map(x => x*x)
Out[42]:
sortWith¶
In [43]:
Array(3, 6, 2, 0, 8, 5).sortWith((e1, e2) => e1 < e2)
Out[43]:
reduce¶
In [44]:
Array(1, 2, 3, 4, 5).reduce((e1, e2) => e1+e2) // équivalent à Array(1, 2, 3, 4, 5).sum
Out[44]:
Arrays with a variable size¶
In [45]:
import scala.collection.mutable.ArrayBuffer
Out[45]:
In [46]:
val arr = ArrayBuffer[Int]()
Out[46]:
In [47]:
arr += 25
Out[47]:
In [48]:
arr += (1, 2, 3, 4)
Out[48]:
In [49]:
arr.insert(2, 5, 5)
arr
Out[49]:
In [50]:
arr ++= Array(99, 99)
Out[50]:
In [51]:
arr.remove(4)
Out[51]:
Main collections¶
Principles¶
Lazy evaluation: Allows to delay the transformation operations and thus to calculate or store only if necessary.
Parallelization support: Method calls do not change. They are just calling in parallel instead of calling them one after the other.
Mutable: Write access.
Immutable: No write access.
Tuples¶
Storage of values
In [52]:
val oneAndTwo = (1, 2)
val oneAndTwo1 = Tuple2(1, 2) // There are tuples that range from 1 element to 22
val oneAndTwo2 = 1 -> 2
Out[52]:
In [53]:
s"${oneAndTwo._1}, ${oneAndTwo._2}"
Out[53]:
In [54]:
val (a, b, _, d) = (1, 2, 3, 4) // "_" for a meaningless value
s"$a $b $d"
Out[54]:
Map¶
Key-value couple
In [55]:
val map = Map(("one", 1), ("two", 2))
val map1 = Map("one" -> 1, "two" -> 2)
In [56]:
map("two")
Out[56]:
In [57]:
map.getOrElse("three", -1)
Out[57]:
In [58]:
val mutableMap = scala.collection.mutable.Map[String, Int]()
mutableMap("three") = 3
mutableMap += (("one" -> 1), ("two" -> 2))
mutableMap -= "one"
mutableMap += "five" -> 5
Out[58]:
In [59]:
val reverseMap = for((key, value) <- mutableMap) yield (value, key)
// or
mutableMap.map(element => (element._2, element._1))
Out[59]:
In [60]:
s"keys: ${mutableMap.keys} values: ${mutableMap.values}"
Out[60]:
In [61]:
mutableMap.partition(_._2 % 2 == 0) // cut a Map according to a predicate
Out[61]:
Map implementations¶
Immutable¶
In [62]:
import scala.collection.immutable
immutable.HashMap[AnyVal, AnyVal]()
immutable.IntMap[AnyVal]()
immutable.ListMap[AnyVal, AnyVal]()
immutable.LongMap[AnyVal]()
immutable.SortedMap[Int, AnyVal]()
immutable.TreeMap[Int, AnyVal]()
Mutable¶
In [63]:
import scala.collection.mutable
mutable.HashMap[AnyVal, AnyVal]()
mutable.LinkedHashMap[AnyVal, AnyVal]()
mutable.ListMap[AnyVal, AnyVal]()
mutable.OpenHashMap[AnyVal, AnyVal]()
mutable.WeakHashMap[AnyVal, AnyVal]()
Out[63]:
Option¶
Presence (Some) or not (None) of value
In [64]:
val emptyOpt: Option[Int] = None
Out[64]:
In [65]:
val fullOpt: Option[Int] = Some(42)
Out[65]:
In [66]:
emptyOpt match {
case Some(value) => println(value)
case None => println("Empty")
}
In [67]:
fullOpt.get
Out[67]:
In [68]:
emptyOpt.isEmpty
Out[68]:
Either¶
Choice between 2 return values
In [69]:
def divide(a: Double, b: Double): Either[String, Double] = {
if (b==0.0) Left("Division by zero") else Right(a/b)
}
divide(4, 0)
Out[69]:
In [70]:
divide(4, 2)
Out[70]:
Lists¶
Object sequence defined in recursive ways
In [71]:
val list = List(1, 2, 3, 4)
Out[71]:
In [72]:
list.head
Out[72]:
In [73]:
list.tail
Out[73]:
In [74]:
list.tail.tail.head
Out[74]:
In [75]:
list.tail.tail.tail.tail
Out[75]:
In [76]:
Nil
Out[76]:
In [77]:
1 :: List(2, 3, 4)
Out[77]:
In [78]:
1 :: 2 :: 3 :: 4 :: Nil
Out[78]:
In [79]:
list(3)
Out[79]:
In [80]:
def lCount(lst: List[Int], func: (Int) => Boolean): Int = {
if (lst == Nil) 0 else
(if (func(lst.head)) 1 else 0) + lCount(lst.tail, func)
}
lCount(List(1, 2, 3, 4), _ % 2 == 0)
Out[80]:
Set¶
Non-ordered collection with each element present only once
In [81]:
val set = Set(1, 2, 3, 4)
set + 3
Out[81]:
In [82]:
set contains 1
// or
set(1)
Out[82]:
Set Implementations¶
Immutable¶
In [83]:
import scala.collection.immutable
immutable.BitSet()
immutable.HashSet[AnyVal]()
immutable.ListSet[AnyVal]()
immutable.TreeSet[Int]()
immutable.SortedSet[Int]()
Out[83]:
Mutable¶
In [84]:
import scala.collection.mutable
mutable.BitSet()
mutable.HashSet[AnyVal]()
mutable.LinkedHashSet[AnyVal]()
mutable.TreeSet[Int]()
Out[84]:
Vector¶
Collection with acceptable performance in access and update.
In [85]:
val v = Vector(1, 2, 3, 4)
Out[85]:
In [86]:
v :+ 5 :+ 6
Out[86]:
In [87]:
v(1)
Out[87]:
In [88]:
v updated(2, 10)
Out[88]:
In [89]:
0 +: v
Out[89]:
Stack¶
LIFO
In [90]:
val s = scala.collection.immutable.Stack[Int](1, 2, 3, 4)
Out[90]:
In [91]:
s push(29) push(98)
Out[91]:
In [92]:
s top
Out[92]:
In [93]:
s pop // Remove the first element from the stack
Out[93]:
Queue¶
FIFO
In [94]:
val q = scala.collection.immutable.Queue[Int](1, 2, 3, 4)
Out[94]:
In [95]:
q enqueue(98) enqueue(76)
Out[95]:
In [96]:
q dequeue
Out[96]:
Range¶
In [97]:
1 to 10
Out[97]:
In [98]:
1 until 10
Out[98]:
In [99]:
0 to 100 by 5
Out[99]:
Streams¶
Lazy List, only the first occurrence is evaluated
In [100]:
val s = 1 #:: 2 #:: 3 #:: Stream.empty
Out[100]:
In [101]:
Stream(1, 2, 3)
Out[101]:
In [102]:
def fibonacci(a: Int, b: Int): Stream[Int] = a #:: fibonacci(b, a + b)
fibonacci(0, 1).take(10).force
Out[102]:
Collections in detail¶
Traversable¶
Traversables collections implement foreach, which allows the collection to be browsed by calling a function.
In [103]:
'a' to 'z' foreach print
Iterable¶
Crossover collections implement iterator, which allows access to each element without modification.
In [104]:
val ite = ('a' to 'z').iterator
while (ite.hasNext) print(ite.next)
Out[104]:
Seq¶
The Seq collections are ordered.
In [105]:
val s = ('a' to 'z')
Out[105]:
In [106]:
s(scala.util.Random.nextInt(25))
Out[106]:
In [107]:
s.segmentLength(v => (v < 'd'), 1) // Length of the longest sequence according to a predicate and an index
Out[107]:
In [108]:
s.prefixLength(v => (v < 'd')) // Length of the longest sequence according to a predicate from index 0
Out[108]:
In [109]:
s.indexWhere(v => "hello world" contains v.toString) // first indice according to a predicate
Out[109]:
In [110]:
s.lastIndexWhere(v => "hello world" contains v.toString) // last indice according to a predicate
Out[110]:
In [111]:
s.indexOf('z')
Out[111]:
In [112]:
s.startsWith(Seq('a', 'b'))
Out[112]:
In [113]:
s.endsWith(Seq('y', 'z'))
Out[113]:
In [114]:
s.reverse
Out[114]:
In [115]:
s.indexOfSlice(Seq('k', 'l'))
Out[115]:
Usual operations¶
Add / remove an element¶
| Operation | Description | Collection |
|---|---|---|
| c + e ; c + (e1,..,en) | Add elements, return a new collection. | Map, Set |
| c += e ; c += (e1,..,en) ; c -= e ; c -= (e1,..,en) | Adds and removes elements by modifying the collection. | Mutable |
| c - e ; c - (e1,..,en) | Retire des éléments, retourne une nouvelle collection. | ArrayBuffer, Map, Set |
| c :+ e ; e +: e | Remove items, return a new collection. | Seq |
| e :: c | Add an element at the beginning. | List |
| e #:: c | Add an element at the beginning. | Stream |
Update¶
| Operation | Description | Collection |
|---|---|---|
| c(k) = e ; c.update(k, e) | Updates the item in the indexed collection k. | mutable.Map, mutable.Seq |
| c.updated(k, e) | New collection in which the element is updated. | Sauf Set. |
Assemblist operations¶
| Opération | Description | Collection |
|---|---|---|
| c ++ c2 | Union. | Iterable |
| c - c2 | c without the elements of c2 | ArrayBuffer, Map, Set |
| c2 ++=: c | Add c2 at the top of c | ArrayBuffer |
| c ++= c2 ; c -= c2 | Rajoute c2 à c ou enlève c2 à c | Mutable |
| c diff c2 | Add c2 to c or remove c2 to c | Seq |
| c ::: c2 | Union | List |
| c | c2 ; c & c2 ; c &~ c2 | Union, Intersection et Difference | Set |
Cast¶
In [116]:
Seq(1).toArray
Seq(1).toBuffer
Seq(1).toList
Seq((1, 2)).toMap
Seq(1).toStream
Seq(1).toString
Seq(1).toVector
Seq(1).toTraversable
Seq(1).toIndexedSeq
Seq(1).toIterable
Set(1).toSeq
Seq(1).toSet
Out[116]:
In [117]:
val collec = 1 to 100 by 8
collec.to[List] // in general
Out[117]:
Operations of Iterables¶
In [118]:
val collec = (1 to 100 by 6) ++ Seq(4)
Out[118]:
In [119]:
collec.size
Out[119]:
In [120]:
collec.count(_%2 == 0)
Out[120]:
In [121]:
collec.isEmpty
Out[121]:
In [122]:
collec.nonEmpty
Out[122]:
In [123]:
collec.sameElements(collec)
Out[123]:
In [124]:
collec.forall(_ > 0)
Out[124]:
In [125]:
collec.exists(_ < 0)
Out[125]:
In [126]:
collec.sum
Out[126]:
In [127]:
collec.product
Out[127]:
In [128]:
collec.min
Out[128]:
In [129]:
collec.max
Out[129]:
Selection and cutting¶
In [130]:
val collec = (1 to 100 by 6) ++ Seq(4)
Out[130]:
In [131]:
collec.head
Out[131]:
In [132]:
collec.last
Out[132]:
In [133]:
collec.tail
Out[133]:
In [134]:
collec.init
Out[134]:
In [135]:
collec.take(5)
Out[135]:
In [136]:
collec.drop(5)
Out[136]:
In [137]:
collec.splitAt(5)
Out[137]:
In [138]:
collec.takeRight(5)
Out[138]:
In [139]:
collec.dropRight(5)
Out[139]:
In [140]:
collec.takeWhile(_ < 30)
Out[140]:
In [141]:
collec.dropWhile(_ < 30)
Out[141]:
In [142]:
collec.span(_ < 30)
Out[142]:
In [143]:
collec.filter(_ % 2 == 0)
Out[143]:
In [144]:
collec.filterNot(_ % 2 == 0)
Out[144]:
In [145]:
collec.partition(_ % 2 == 0)
Out[145]:
In [146]:
collec.slice(3, 7)
Out[146]:
In [147]:
collec.mkString(";")
Out[147]:
In [148]:
collec.mkString("[", ",", "]")
Out[148]:
Transformation of a collection¶
map, flatMap¶
In [149]:
def range(n: Int) = 0 to n
Out[149]:
In [150]:
Seq(1, 2, 3, 4).map(range)
Out[150]:
In [151]:
Seq(1, 2, 3, 4).flatMap(range) // merges collections
Out[151]:
reduceLeft, reduceRight¶
In [152]:
(1 to 5).reduceLeft(_-_)
Out[152]:
In [153]:
(1 to 5).reduceRight(_-_)
Out[153]:
foldRight, foldLeft¶
Same thing as reduction but with an initial element.
In [154]:
((1 to 4) ++ (1 to 6)).foldLeft(Set[Int]())(_+_)
Out[154]:
In [155]:
// number of occurrences
Seq(1, 2, 1, 1, 7, 7, 2, 9).foldLeft(Map[Int, Int]()) ((counter, e) => counter + (e -> (counter.getOrElse(e, 0) + 1)))
scanLeft, scanRight¶
Same as fold by saving the intermediate results in a collection
In [156]:
Seq(1, 2, 4, 1, 3, 4).scanLeft(Set[Int]()) ((s, e) => s + e)
Out[156]:
zip, zipAll, zipWithIndex, unzip¶
In [157]:
"abcde" zip 1.to(5)
Out[157]:
In [158]:
"abcde".zipAll(1.to(2), "*", -1) // with default value on the left and right
Out[158]:
In [159]:
"abcde" zipWithIndex
Out[159]:
In [160]:
Seq((1, 2), (3, 4), (5, 6)) unzip
Out[160]:
Operations of Seq¶
In [161]:
val s = Seq(5, 6, 2, 8, -3, 0, 2, 8)
Out[161]:
In [162]:
s.indexOf(2)
Out[162]:
In [163]:
s.lastIndexOf(2)
Out[163]:
In [164]:
s.indexOfSlice(Seq(2, 8))
Out[164]:
In [165]:
s.lastIndexOfSlice(Seq(2, 8))
Out[165]:
In [166]:
s.indexWhere(_ % 2 == 0)
Out[166]:
In [167]:
s.prefixLength(_ > 0)
Out[167]:
In [168]:
s.segmentLength(_ > 0, 3)
Out[168]:
In [169]:
s.contains(1)
Out[169]:
In [170]:
s.containsSlice(Seq(8, -3))
Out[170]:
In [171]:
s.startsWith(Seq(0))
Out[171]:
In [172]:
s.endsWith(Seq(2, 8))
Out[172]:
In [173]:
s.reverse
Out[173]:
In [174]:
s.intersect(Seq(1, 7, 8, 3))
Out[174]:
In [175]:
s.diff(Seq(1, 7, 8, 3, 2))
Out[175]:
In [176]:
s.slice(0, 4).permutations.toList
Out[176]:
In [177]:
s.slice(0, 4).combinations(2).toList
Out[177]:
In [178]:
s.sorted
Out[178]:
In [179]:
s.sortWith(_ > _)
Out[179]:
In [180]:
s.sortBy(_ - scala.util.Random.nextInt(8)) // transforms the collection before sorting
Out[180]:
Parallel collections¶
par¶
To understand where a parallel collection can be useful, it helps to think about how they work. Conceptually, you can imagine a collection being split into different chunks; your algorithm is then applied to the chunks, and at the end of the operation, the different chunks are recombined. To be used only if the order is not important.
In [181]:
1 to 100 par
Out[181]:
In [182]:
(1 to 100 par) seq
Out[182]:
In [183]:
val start = System.nanoTime
val r = 0 to 1000000
for (i <- 0 to 100) {val cpt = r.count(_ % 3 == 0)}
s"${(System.nanoTime - start) / 1000}ms"
Out[183]:
In [184]:
val start = System.nanoTime
val r = 0 to 1000000
for (i <- 0 to 100) {val cpt = r.par.count(_ % 3 == 0)}
s"${(System.nanoTime - start) / 1000}ms"
Out[184]:
Lazy view¶
In [185]:
val v = (1 to 5).view.map(_ * 3)
println(v) // nothing is evaluated
Out[185]:
In [186]:
println(v(3))
In [187]:
println(v.force)
Object oriented programming¶
Class statement¶
In [188]:
class Money(startMoney: Int) {
def this() = this(0) // builder
private var contain: Int = 0
def +=(money: Int) = contain += money
def empty = {val solde = contain; contain = 0; solde}
def howMany = contain
override def toString = contain.toString
}
Out[188]:
public, private and protected access¶
public¶
In [189]:
class ClassA{ // without indication the methods and variables are by default public
val bar = "foo"
def foo = "bar"
}
Out[189]:
private¶
In [190]:
class ClassA {private val foo ="bar"} // access only for this
(new ClassA).foo
protected¶
In [191]:
class ClassA {protected def hey(s: String) = println(s"Hey $s !")} // access for this and children
Out[191]:
In [192]:
class ClassB extends ClassA {hey("John")}
new ClassB
Out[192]:
In [193]:
class ClassC {
hey("John")
(new ClassA).hey("John")
}
Refine the scope of access¶
Specified a restriction limit that can be this, a package, a class or an object : private[limit] or protected[limit]
Getters and Setters¶
In [194]:
class Money {var amount = 0}
Out[194]:
In [195]:
val money = new Money
Out[195]:
In [196]:
money.amount = 100 //setter
Out[196]:
In [197]:
money.amount //getter
Out[197]:
Constructors¶
In [198]:
class ClassA(attribute1: Int, attribute2: Int){ //main constructors
def this(){ // another constructor
this(0, 0)
}
override def toString: String = s"$attribute1, $attribute2"
}
Out[198]:
In [199]:
new ClassA(30, 40).toString
Out[199]:
In [200]:
new ClassA().toString
Out[200]:
In [201]:
class ClassA(val attribute1: Int, private var attribute2: Int){ // attributes are accessible with getters and setters
def this(){ // another constructor
this(0, 0)
}
override def toString: String = s"$attribute1, $attribute2"
}
Out[201]:
In [202]:
class Fraction(val numerator: Int, val denominator: Int){
require(denominator != 0, "denominator can't be equals 0")
}
Out[202]:
In [203]:
new Fraction(1, 2)
Out[203]:
In [204]:
new Fraction(1, 0)
Nested Classes¶
In [205]:
class ClassA {
classAalias => // defined an alias for ClassA.this
val id = System.nanoTime
class ClassB {
def hey = println("Hello")
def id = ClassA.this.id // access the context of the surrounding class
def id2 = classAalias.id
}
def buildClassB = new ClassB
def bar(v: ClassA#ClassB) = println("Hello") // accepts all varieties of ClassA and ClassB
}
Out[205]:
In [206]:
val a = new ClassA
val b = a.buildClassB
b.hey
a.bar(b)
println(a.id, b.id, b.id2)
Out[206]:
Anonymous Classes¶
In [207]:
val person = new {
val name: String = "John"
def presentation(): Unit = println(s"My name is $name.")
}
person.presentation()
Out[207]:
In [208]:
def printName(person: {val name: String}) = { // {val name: String} is a type.
println(person.name)
}
printName(person)
Out[208]:
Type and this¶
In [209]:
class ClassA(var a: Int = 0) {
def update(newA: Int): this.type = {
a = newA
this
}
}
Out[209]:
In [210]:
val a = new ClassA()
a.update(10) // return a new object
Out[210]:
Transtyping¶
In [211]:
val obj1: Seq[Int] = Seq.empty
obj1.isInstanceOf[Iterable[Int]]
Out[211]:
In [212]:
obj1.asInstanceOf[Iterable[Int]]
Out[212]:
In [213]:
obj1.getClass
Out[213]:
Object¶
Singleton Object¶
In [214]:
object Object { // Usually contains the static elements
val foo = 0
def bar = foo
}
Out[214]:
In [215]:
Object.bar
Out[215]:
Any Methods¶
In [216]:
class ClassA(var a: Int = 0) {
override def toString =s"$a"
override def equals(other: Any) = {
if (other.isInstanceOf[ClassA]) this.a == other.asInstanceOf[ClassA].a
else false
}
}
Out[216]:
In [217]:
val a = new ClassA(10)
val b = new ClassA(99)
a.toString
Out[217]:
In [218]:
a.equals(b) // ou a == b
Out[218]:
Apply and Unapply¶
In [219]:
object Foo {
def apply(name: String, suffix: String) = name + "." + suffix
def unapply(name: String): Option[(String, String)] = {
//simple argument extractor
val parts = name.split("\\.")
if (parts.length == 2) Some(parts(0), parts(1)) else None
}
}
Out[219]:
In [220]:
val file = Foo("test", "txt")
Out[220]:
In [221]:
val Foo(name) = file
Out[221]:
case class¶
In [222]:
case class File(name: String, suffix: String)
Out[222]:
In [223]:
val file: File = File("test", "scala")
Out[223]:
In [224]:
file.name
Out[224]:
In [225]:
val File(name, suffix) = file
Out[225]:
In [226]:
file.copy(name="test1")
Out[226]:
Inheritance¶
extends¶
In [227]:
class Insect
Out[227]:
In [228]:
class Ant extends Insect
Out[228]:
Constructor and super-class¶
In [229]:
class Vehicle(brand: String, nbWheels: Int, fuel: Boolean)
Out[229]:
In [230]:
class Bicycle(brand: String) extends Vehicle(brand, 2, false)
Out[230]:
override¶
In [231]:
class Class1 {
def method = println("class1")
}
Out[231]:
In [232]:
class Class2 extends Class1 {
override def method = println("class2")
}
Out[232]:
In [233]:
val c = new Class2
c.method
Out[233]:
Abstract class¶
In [234]:
abstract class Class1 {
var indefinedVar: Int
def undefinedMethod()
}
Out[234]:
final¶
In [235]:
final class Class1
Out[235]:
In [236]:
class Class2 extends Class1
In [237]:
class Class1 {
final def method = {}
}
Out[237]:
In [238]:
class Class2 extends Class1 {
override def method = {}
}
Implicit conversions¶
Implicit class¶
In [239]:
implicit class StringFile(s: String) {
def splitFile: Option[(String, String)] = {
s.split('.') match {
case Array(name, suffix) => Some((name, suffix))
case _ => None
}
}
}
Out[239]:
In [240]:
"hey".splitFile
Out[240]:
In [241]:
"hey.scala".splitFile
Out[241]:
implicit conversions method¶
In [242]:
object Fraction {
// Implicitly call by the compiler if it needs it
// An import is required: import Fraction.int2Fraction
implicit def int2Fraction(i: Int) = new Fraction(i, 1)
}
class Fraction(val numerator: Int, val denominator: Int) {
def +(f: Fraction) = new Fraction(numerator*f.denominator + f.numerator*denominator, denominator * f.denominator)
override def toString: String = s"$numerator/$denominator"
}
Out[242]:
In [243]:
new Fraction(2, 3) + new Fraction (2, 1)
Out[243]:
In [244]:
new Fraction(2, 3) + 2
Out[244]:
Trait¶
In [245]:
trait Trait1 {
def foo = {}
}
trait Trait2 {
def bar = {}
}
class Class1 extends Trait1 with Trait2
Out[245]:
In [246]:
class Class2
val c = new Class2 with Trait1
Out[246]:
In [247]:
new Trait1
In [ ]: