Kotlin - Objects, High level functions & Filtre (ziua 5)

 object

- introduce un singleton (nu există constructor, instanțe)

- poate extinde un Comparator

- adnotare metodă din interiorul obiectului cu @JvmStatic pentru a putea fi chemată din Java

class Course(val id: Int, val title: String) {
}

object Courses {
    var allCourses = arrayListOf<Course>()

    init {
        allCourses.add(Course(1, "Kotlin"))
        allCourses.add(Course(2, "Maven"))
    }
}

fun enroll(courseName: String){
    val course = Courses.allCourses
        .filter{it.title == courseName}
        .firstOrNull()
}

Companion objects

- keyword: companion objects => Metodele din interiorul obiectului devin statice (factory methods)

open class Student : Person {

  // ....

  companion object : Internship<Student> {

    override fun applyToInternship(title: Student) {
        TODO("Not yet implemented")
    }

    // adding static methods to the class
    fun createUndergrad(name: String) = Undergrad(name)
    fun createPostgrad(name: String) = Postgrad(name)
  }

}

class Undergrad(name: String) : Student(name)

class Postgrad(name: String) : Student(name) 

interface Internship<T> {
    fun applyToInternship(title: T)
}

fun main(args: Array<String>) {

  Student.createPostgrad("Naim")

  Student.createUndergrad("Amir")

}

High level functions

program.fibonacci(8) { n -> println(n) }

program.fibonacci(8) { println(it) }

program.fibonacci(8, ::println)

Lambda

- pot schimba valori (in Java trebuie să fie final)

var total = 0

program.fibonacci(8) { it -> total += it }

with (student) {

  // asignari pe campurile obiectului student

  name = "Geo"

  city = "Bucharest"

}

student.apply {

  name = "Geo"

  city = "Bucharest"

}

Filter, map, predicate

val ints = listOf(1,2,3,4,5)
val smallInts = ints.filter { it < 4 }
for(i: Int in smallInts) println(i)

val sqInts = ints.map { it*it }
for(i: Int in sqInts) println(i)

val smallSqInts = ints.filter { it < 3 }.map { it*it }
for(i: Int in smallSqInts) println(i)

val largeInts = ints.all { it > 3 }
println(largeInts) // false: not all are grt than 3

val largeIntsAny = ints.any { it > 3 }
println(largeIntsAny) // true: there is one elem grt than 3

val grtThnThree = { v: Int -> v > 3 }
val largeCount = ints.count(grtThnThree)
println(largeCount) // 2 

var found :Int? = ints.find(grtThnThree)
println(found) // 4 is the first elem found grt than 3

found = ints.find { it > 5 }
println(found) // null

Secvențe

- folosite atunci când listele create de filter/map ar fi imense

- folosesc evaluare leneșă

- se preferă secvențele în locul listelor

- în Java8, echivalentul este streams

Exemplu:

val titles = meetings.asSequence().filter { ... }.map { ... }

// for (i: String in titles) println(i)

Diferențe: 

- cu asSequence si fara println (comentat), nu se evalueaza deloc expresia (lazy)

- cu asSequence si println, ordinea este filtru + map + printare element din meetings, deoarece rezultatul este evaluat la cerere, cand este nevoie de el in println

- fara asSequence se evalueaza expresia indiferent daca rezultatul este sau nu folositor; ordinea este: toate filtrele, apoi toate maparile, apoi toate printarile

- cu asSequence operatiile pot fi mai eficiente, in special daca se cere doar primul rezultat (ca exemplu cu find = terminal operator)