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)
