Kotlin as a Better Java

© Instil Software 2017
September 2017
eamonn.boyle@instil.coeamonn.boyle@instil.cogarth.gilmour@instil.co | eamonn.boyle@instil.co
Kotlin as a Better Java
Cork Functional Programmers
and Cork Java Users Group

C
C++
Java
C#
Pascal
Delphi
Basic
Visual Basic
VB .NET
Perl
F#
Java
Script
CoffeeScript
1990
2000
2010
TypeScript
Jython
JRuby
PowerShell
Dart
Scala
Clojure
Kotlin
Groovy
Go
Objective C
Shell
Scripting
Swift
Python
Ruby

Scala
Kotlin Swift

TypeScript

The New Era of Programming Pt1
Everything is an object
Type inference
Functions
• Can be free
• Can be nested
• Can be single expression
• Can be lambdas
• Can be referenced
• Don’t return null
• Use lambda syntax for
inputs and outputs

The New Era of Programming Pt2
String interpolation
No field declarations
• Primary constructors
• Auto-properties
Collections
• Are unified
• Are really generic
• Include Tuples
• Include Ranges
• Support FP operations

2010: Work begins on Kotlin within JetBrains
2011: First public announcement on Kotlin
2012: Open sourced under Apache 2 license
2016: Version one released
2017: First class support on Android
A Kotlin Timeline

Kotlin On Other Platforms
JVM
Bytecode
Kotlin
(JS)
Kotlin
(Native)
Kotlin
(JVM)
Browser
Interpreter Runtime
OS

A Simple Case Study

Enter some numbers or three 'X' to finish
10
20
30
40
50
XXX
Total of numbers is: 150
wibble
Ignoring wibble
12
13
14
XXX
XXX

public class Program {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner scanner = new Scanner(System.in);
List<Integer> numbers = new ArrayList<>();
System.out.println("Enter some numbers or three 'X' to finish");
Pattern endOfInput = Pattern.compile("[X]{3}");
while(scanner.hasNextLine()) {
if(scanner.hasNextInt()) {
numbers.add(scanner.nextInt());
} else {
if(scanner.hasNext(endOfInput)) {
break;
} else {
String mysteryText = scanner.nextLine();
System.out.printf(“Ignoring %sn", mysteryText);
}
}
}
int total = numbers.stream().reduce((a,b) -> a + b).orElse(17);
System.out.printf("Total of numbers is: %sn",total);
}
}
java.demos.hello
A Sample Java Program

fun main(args: Array<String>) {
val numbers = mutableListOf<Int>()
val scanner = Scanner(System.`in`)
val endOfInput = Regex("[X]{3}")
println("Enter some numbers or three 'X' to finish")
while (scanner.hasNextLine()) {
if (scanner.hasNextInt()) {
numbers += scanner.nextInt()
} else {
if (scanner.hasNext(endOfInput.toPattern())) {
break
} else {
val mysteryText = scanner.nextLine()
println("Ignoring $mysteryText")
}
}
}
//simpler alternative is ‘numbers.sum()’
val total = numbers.fold(0,Int::plus)
println("Total of numbers is: $total")
}
kotlin.demos.hello
The Sample Re-Written in Kotlin
Points to note:
 No redundant class
 No semi-colons
 Type inference
 Both ‘val’ and ‘var’
 Helper functions
 String interpolation
 Simplified collections
 Interop with Java types
 Simpler use of FP

object NumbersDemo {
def main(args: Array[String]) {
var numbers = List[Int]()
val scanner = new Scanner(System.in)
val endOfInput = "[X]{3}".r
println("Enter some numbers or three 'X' to finish")
var notDone = true
while (scanner.hasNextLine() && notDone) {
if (scanner.hasNextInt()) {
numbers = scanner.nextInt() :: numbers
} else {
if (scanner.hasNext(endOfInput.pattern)) {
notDone = false
} else {
val mysteryText = scanner.nextLine()
println(s"Ignoring $mysteryText")
}
}
}
//show support for FP
val total1 = numbers.fold(0)(_ + _)
println(s"Total of numbers is: $total1")
//show simpler alternative in this case
val total2 = numbers.sum
println(s"Total of numbers is: $total2")
}
}
demos.scala
The Sample Rewritten in Scala

Feature Java 9 Kotlin Scala
Type Inference No Yes Yes
Unified Type System No Yes Yes
Protection from Null Results No Yes Yes
String Interpolation No Yes Yes
Extension Functions No Yes Partially
Inline Functions No Yes Yes
Primary Constructors No Yes Yes
Case / Data Classes No Yes Yes
Function Literals Yes Yes Yes
Local Functions No Yes Yes
Enclosure of local variables Partially Yes Yes
Single Expression Functions No Yes Yes
Tuples No Partially Yes
Monads No Partially Yes
Kotlin vs. Scala Comparison

Type Inference

class Person(val name: String)
val a = 123
val b = "ABC"
val c = "[A-Z]{3}".toRegex()
val d = 1..10
val e = Person("Jason")
val f = arrayOf(a, b, c, d, e)
f.forEach { println(it.javaClass.name) }
}
java.lang.Integer
java.lang.String
kotlin.text.Regex
kotlin.ranges.IntRange
basics.type.inference.Person
basics.type.inference.Program
Type Inference In Kotlin

Managing Null Pointers

A design goal for Kotlin was to minimise null pointer errors
• They cant be eliminated without affecting interoperability
The Kotlin compiler checks for nulls automatically
• It is not possible for a regular variable to be set to null
Every type you create has a nullable alternative
• Written as ‘String?’ for ‘String’ and ‘Person?’ for ‘Person’ etc…
• You can explicitly specify this but often it is inferred
Nullable types often occur in function signatures
• So ‘fun foo() Int’ cannot return null but ‘fun foo() Int?’ can
Managing Null Pointers in Kotlin

The ‘?.’ syntax makes a call only if the reference is not null
• So ‘foo?.bar()’ would only call ‘bar’ if ‘foo’ was not null
• Calls can be chained as required e.g. ‘foo?.bar().zed()’
The ‘?:’ syntax is used to specify a backup value
• So ‘foo()?: “bar”’ returns ‘bar’ if the LHS is null
• Note the RHS is only evaluated if required
The ‘!!.’ syntax is for when you want an exception
• For example when replacing a Java library with Kotlin whilst
preserving exactly the same behaviour
• So ‘foo||.bar()’ throws an exception if ‘foo’ is null
• The garishness of the operator makes it easy to spot
during pair programming and/or code reviews
Operators for Nullable Types

fun foo(input: Int) = if(input > 0) "abc" else "def" //return type is String
fun bar(input: Int) = if(input > 0) "abc" else null //return type is String?
val str1 = foo(12) //inferred type is String
val str2 = bar(34) //inferred type is String?
val str3: String = foo(12) //declared type is String
val str4: String? = bar(34) //declared type must be
String?
println(bar(12)?.toUpperCase()) //safe call operator (success)
println(bar(-12)?.toUpperCase()) //safe call operator (failure)
println(bar(12)?: "wibble") //elvis operator (success)
println(bar(-12)?: "wibble") //elvis operator (failure)
println(bar(12)!!.toUpperCase()) //NPE operator (success)
try {
println(bar(-12)!!.toUpperCase()) //NPE operator (failure)
} catch(ex: Throwable) {
println("Finally a NPE :-)")
}
}
basics.safety.Program
Managing Null Pointers in Kotlin
ABC
null
abc
wibble
ABC
Finally a NPE :-)

fun demo1(input: Int) {
println("Demo1 called with $input")
}
fun demo2(input: Int): Unit { //same as above
println("Demo2 called with $input")
}
fun demo3(input: Int): String = "Demo3 called with $input"
fun demo4(input: Int): String {
return "Demo4 called with $input"
}
fun demo5(input: Int = 456): String {
return "Demo5 called with $input"
}
fun demo6(vararg input:Int) = input.reduce { a,b -> a + b}
fun demo7(port: Int, timeout:Int, retries: Int): String {
return “““Trying to connect on port $port
with $retries retries and a timeout of $timeout
”””
}
basics.functions.Program.kt
Function Declarations

demo1(123)
demo2(123)
println(demo3(123))
println(demo4(123))
println(demo5(123))
println(demo5())
println("Adding numbers gives: ${demo6(10,20,30,40,50)}")
println(demo7(timeout = 60, port=8080, retries = 10))
}
basics.functions.Program.kt
Demo1 called with 123
Adding numbers gives: 150
Trying to connect on port 8080
with 10 retries and a timeout of 60
Function Declarations

A Kotlin function can be declared as infix
• This allows it to be used as if it were a keyword
• E.g. ‘12 downTo 1’ is the same as ‘12.downTo(1)’
• An infix function must follow some simple rules:
• It can only take a single parameter
• It must be a member of a type (i.e. a method)
• Or an extension to an existing type
• It must be declared using the ‘infix’ keyword
It is possibly to pass references to functions and anonymous
functions (aka lambdas) as parameters
Special Kinds Of Function

class Number(val value: Int) {
infix fun plus(input: Int): Number {
return Number(value + input)
}
infix fun minus(input: Int): Number {
return Number(value - input)
}
fun forEach(action: (Int) -> Unit) {
for(x in 1..value) {
action(x)
}
}
}
val num1 = Number(5)
val num2 = num1 plus 7
val num3 = num2 minus 3
num1.forEach { print("$it ")}
println()
println()
}
1 2 3 4 5
1 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9
basics.functions.infix
Special Function Declarations

Classes in Kotlin

When coding in Kotlin we think in terms of properties
• In Kotlin it isn’t possible to manually add fields to a class
• Instead you add properties, which are public by default
When you add a property to a class Kotlin will:
• Declare a ‘backing field’ of the appropriate type
• Declare a standard Java getter method
• Unless the property has been declared private
• Declare a standard Java setter method
• Assuming the property has been declared with ‘var’
Accessor methods are automatically invoked for you
• So ‘val wage = emp.salary’ is ‘val wage = emp.getSalary()’
• Similarly ‘emp.salary = n’ becomes ‘emp.setSalary(n)’
Classes and Properties in Kotlin

class Person {
var name: String = "Dave"
fun sayHello() = println("Hello $name")
}
val p = Person()
println(p.name)
p.sayHello()
p.name = "Jane"
println(p.name)
p.sayHello()
}
oo.properties
javap -p oo.properties.Person
Compiled from "Person.kt"
public final class oo.properties.Person {
private java.lang.String name;
public final java.lang.String getName();
public final void setName(java.lang.String);
public final void sayHello();
public oo.properties.regular.Person();
}
Dave
Hello Dave
Jane
Hello Jane
Note Kotlin does
not require ‘new’

$ javap -p -c oo.properties.regular.PersonKt
public final class oo.properties.regular.PersonKt {
public static final void main(java.lang.String[]);
Code:
0: aload_0
1: ldc #9 // String args
3: invokestatic #15 // Method …/Intrinsics.checkParameterIsNotNull:(…)V
6: new #17 // class oo/properties/regular/Person
9: dup
10: invokespecial #21 // Method oo/properties/regular/Person."<init>":()V
13: astore_1
14: aload_1
15: invokevirtual #25 // Method oo/properties/regular/Person.getName:()Ljava/lang/String;
18: astore_2
19: getstatic #31 // Field java/lang/System.out:Ljava/io/PrintStream;
22: aload_2
23: invokevirtual #37 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
26: aload_1
27: invokevirtual #40 // Method oo/properties/regular/Person.sayHello:()V
30: aload_1
31: ldc #42 // String Jane
33: invokevirtual #46 // Method oo/properties/regular/Person.setName:(Ljava/lang/String;)V
36: aload_1
37: invokevirtual #25 // Method oo/properties/regular/Person.getName:()Ljava/lang/String;
40: astore_2
44: aload_2
48: aload_1
49: invokevirtual #40 // Method oo/properties/regular/Person.sayHello:()V
52: return
}

The default accessor methods can be overridden
• By providing ‘get’ and/or ‘set’ blocks after the declaration
• The backing field can be accessed via the keyword ‘field’
• Note this is only allowed within the ‘get/set’ blocks
This is useful in two scenarios:
• When you want to base a property on an expression
• Such as the ‘empty’ property of a custom collection
• When you want to add validation rules
• E.g. the setter method for a ‘wage’ property could check if
the new value was within the salary band of the employee
Customising Properties

val p = Person()
p.sayHello()
p.name = "Jane"
p.sayHello()
}
class Person {
var name: String = "Dave"
get() = "[$field]"
set(value) { field = "$value Jones" }
fun sayHello() = println("Hello $name")
}
oo.properties.customized
Hello [Dave]
Hello [Jane Jones]
Customising Properties

Kotlin provides a feature called ‘primary constructors’
• Also available in Scala and TypeScript and coming in C#
The class and constructor declarations are merged
• Removing the need to retype the class name, introduce extra
braces and both declare and initialize fields manually
The way the parameters are declared is crucial
• If declared without ‘var’ or ‘val’ they are normal inputs
• No extra members will be added to the class
• If declared with var / val then fields and properties are added
• When ‘val’ is used only a getter method is created
The properties will be public by default
• You can alter this by adding an access modifier
Kotlin and Primary Constructors

package oo.basics
class Person(name: String, age: Int)
oo.basics
javap -p oo.basics.Person
public final class oo.basics.Person {
public oo.basics.Person(java.lang.String, int);
}
Understanding Primary Constructors
Here the parameters lack ‘val’ or
‘var’ so no fields or properties are
created.

package oo.basics
class Person(val name: String, val age: Int)
oo.basics
$ javap -p oo.basics.Person
private final java.lang.String name;
private final int age;
public final int getAge();
}
Adding ‘val’ to the parameters means that a
backing field will be created, initialised and
accessible via a ‘getter’ method

package oo.basics
class Person(var name: String, var age: Int)
oo.basics
Compiled from "Person.kt”
private java.lang.String name;
private int age;
public final void setName(java.lang.String);
public final void setAge(int);
}
Using ‘var’ instead of ‘val’ means that the
compiler also generates ‘setter’ methods

package oo.basics
class Person(val name: String, var age: Int)
oo.basics
private int age;
public final void setAge(int);
}
There is no issue with using both ‘val’ and ‘var’ on
different parameters. Note the default access is public.

package oo.basics
class Person(public val name: String, protected var age: Int)
oo.basics
private int age;
protected final int getAge();
protected final void setAge(int);
}
Adding ‘public’ to the ‘name’ field will have no effect as that is the default.
Adding ‘protected’ to ‘age’ will change the access level of the methods but
we would need to declare the class ‘open’ for this to be useful

package oo.basics
class Person(public val name: String, private var age: Int)
oo.basics
javap -p oo.basics.Person
private int age;
}
Declaring a parameter as private causes the
backing field to be created but not the accessor
methods.

package oo.basics
class Person(private val name: String, private var age: Int)
oo.basics
private int age;
}
There is no issue with all the
parameters being private

package oo.basics
class Person(val name: String, val age: Int) {
private val address = "10 Arcatia Road"
init {
println("Person object created")
}
}
oo.basics
javap -p -c oo.basics.Person
private final java.lang.String address;
--------- Earlier code omitted ---------
21: ldc #8 // String 10 Arcatia Road
23: putfield #36 // Field address:Ljava/lang/String;
26: ldc #38 // String Person object created
28: astore_3
32: aload_3
36: return
}

package oo.basics
class Person(val name: String, val age: Int) {
private var address = "10 Arcatia Road"
init {
println("Person object created")
}
constructor(name: String, age: Int, address: String) : this(name,age) {
println("Secondary constructor called")
this.address = address;
}
}
oo.secondary.constructors
private java.lang.String address;
public oo.basics.Person(java.lang.String, int, java.lang.String);
}
Adding Secondary Constructors

Kotlin adds the following to data classes:
• The familiar ‘equals’ and ‘hashCode’ methods
• A straightforward implementation of ‘toString’
• Which returns output of type ‘Foo(bar=123, zed=“abc”)’
• A ‘copy’ method which returns a clone of the object
• Component methods for destructuring (see later)
The ‘copy’ method allows you to make changes
• By default the properties of the copy are set to the same
values as the original, but you can alter them if you like
• E.g. ‘val person2 = person1.copy(age=28)’
Declaring Data Classes

val emp1 = Employee("Dave Jones", "10 Arcatia Road", 30000.0)
val emp2 = Employee("Dave Jones", "10 Arcatia Road", 30000.0)
println(emp1)
println(emp2)
println(emp1 === emp2)
println(emp1 == emp2)
println(emp1.equals(emp2))
println(emp1.hashCode())
println(emp2.hashCode())
val emp3 = emp2.copy(salary = 40000.0)
println(emp3)
}
data class Employee(val name: String, val address: String, val salary: Double)
oo.entities
Declaring Data Classes
Employee(name=Dave Jones, address=10 Arcatia Road, salary=30000.0)
false
true
true
1296289951
1296289951

Generics

Generics in Kotlin
fun thoughtExperiment() {
val myList = LinkedList<Manager>()
foobar(myList) //should this be allowed?
}
fun foobar(input: LinkedList<Employee>) {
input.add(Employee(“Dave”))
}

We can simplify our problem by restricting the generic type
• A read-only list would solve the current problem
• We could pass in a list of any subtype of ‘Employee’
• Since the methods of the list could not accept instances of
‘T’ there would be no danger of adding the wrong type
• A write-only list might be useful as well
• ‘fun foobar(input: WriteOnlyList<Manager>)’ could be
called with a write-only list of ‘Employee’ or ‘Person’
• Since ‘input.add(Manager(“Jane”))’ works in all cases
• Assuming that Manager  Employee  Person
Generics in Kotlin

Kotlin allows you to restrict generic types in this way
• Saying ‘out T’ means that ‘T’ objects can only be returned
• Saying ‘in T’ means that ‘T’ object can only be accepted
• This is referred to as ‘Declaration Site Type Variance’
Generics in Kotlin

open class Employee
open class Manager : Employee()
open class Director : Manager()
class ReadWriteList<T> {
fun get(index: Int) : T? = null
fun findFirst(p: (T) -> Boolean) : T? = null
fun findAll(p: (T) -> Boolean) : ReadWriteList<T>? = null
fun add(item: T) {}
fun add(index: Int, item: T) {}
fun addAll(items: ReadWriteList<T>) {}
}
class ReadOnlyList<out T> {
fun get(index: Int) : T? = null
fun findFirst(p: (T) -> Boolean) : T? = null
fun findAll(p: (T) -> Boolean) : ReadOnlyList<T>? = null
}
class WriteOnlyList<in T> {
fun add(item: T) {}
fun add(index: Int, item: T) {}
fun addAll(vararg items: T) {}
}
generics.declaration.site.variance.Program.kt
Generics in Kotlin

fun demo1(input: ReadWriteList<Manager>) {
input.add(Manager()) //this is not controversial
input.add(Director()) //this surprises most people
}
fun demo2(input: ReadOnlyList<Manager>) {
//can only access items here
}
fun demo3(input: WriteOnlyList<Manager>) {
//can only insert items here
}
//demo1(ReadWriteList<Employee>()) //will not compile
demo1(ReadWriteList<Manager>())
//demo1(ReadWriteList<Director>()) //will not compile
//demo2(ReadOnlyList<Employee>()) //will not compile
demo2(ReadOnlyList<Manager>())
demo2(ReadOnlyList<Director>())
demo3(WriteOnlyList<Employee>())
demo3(WriteOnlyList<Manager>())
//demo3(WriteOnlyList<Director>()) //will not compile
}
generics.declaration.site.variance.Program.kt
Generics in Kotlin

When we say ‘class Foo<out T>’ then:
• A function which takes a ‘Foo<Manager>’ will also accept a
‘Foo<Director>’ or any other subtype (such as ‘Foo<CTO>’)
• Hence the possible set of valid values is infinite
• This is because ‘Foo’ is acting as a producer and a reference
of type Manager can refer to any instance of any subtype
• We say that in this case ‘T’ is covariant
When we say ‘class Foo<in T>’ then:
• A function which takes a ‘Foo<Manager>’ will also accept
either a ‘Foo<Employee>’ or a ‘Foo<Any>’
• This time the set of valid values is fixed
• This is because ‘Foo’ acts as a consumer and an input of
‘Manager’ can be stored via a ref of ‘Employee’ or ‘Any’
• We say that in this case ‘T’ is contravariant
Understanding Declaration Site Variance

Declaration site variance is not always sufficient
• Consider a function which takes two lists of type ‘Employee’
and where we want to transfer items between the lists
• The compiler needs to be able to check, on a call by call
basis, whether the operations we intend to perform are safe
• E.g. it could be called in one place with lists of ‘Employee’
and ‘Manager’ and in another with ‘CTO’ and ‘Director’
We simplify the compilers job by using the ‘in’ and ‘out’
modifiers directly on the parameters to the function
• E.g. fun demo(p1: MyList<out Thing>, p2: MyList<in Thing>)
• This allows the compiler to validate the code in the function
and determine whether a given call should be permitted
• It is known as ‘use-site variance’ or ‘type projection’
Understanding Use Site Variance

fun copyFirstTen(input: ReadWriteList<out Employee>,
output: ReadWriteList<in Employee>) {
//try to copy first 10 items
for(x in 0..9) {
val item = input.get(x)
if(item != null) {
output.add(item)
}
}
}
val tst1 = ReadWriteList<Employee>()
val tst2 = ReadWriteList<Manager>()
val tst3 = ReadWriteList<Director>()
copyFirstTen(tst1,tst1) //fine
//copyFirstTen(tst1,tst2) //will not compile
//copyFirstTen(tst1,tst3) //will not compile
}
generics.use.site.variance.Program.kt
Generics in Kotlin

So far we have assumed our code can be fully generified
• We can rewrite our ‘LinkedList’ of string as ‘LinkedList<T>’
and it will then automatically work for all possible values of ‘T’
This is (mostly) true of collections but false in other cases
• Often we find code which can only be partially generified
• For example it might only work for any type which has a
‘compareTo’ method, or which implements ‘Iterable’
Generic Constraints allow us to state this in code
• For example the function ‘fun <T: Iterable> foobar(p: T)’ can
be invoked with any type which implements ‘Iterable’
• As in Java this is referred to as an ‘upper bound’
Generic Constraints in Kotlin

open class Employee {
fun work() {}
}
open class Manager : Employee() {
fun manage() {}
}
open class Director : Manager() {
fun direct() {}
}
fun <T> demo1(input: T) {
println(input.toString())
}
fun <T : Employee> demo2(input: T) {
input.work()
}
fun <T : Manager> demo3(input: T) {
input.work()
input.manage()
}
fun <T : Director> demo4(input: T) {
input.work()
input.manage()
input.direct()
}
generics.constraints.Program
Generic Constraints

demo1(Employee())
demo1(Manager())
demo1(Director())
demo2(Employee())
demo2(Manager())
demo2(Director())
//demo3(Employee()) // Will not compile
demo3(Manager())
demo3(Director())
//demo4(Employee()) // Will not compile
//demo4(Manager()) // Will not compile
demo4(Director())
}
generics.constraints.Program
Generic Constraints

It is possible to specify multiple generic constraints
• Useful when a type needs to implement multiple interfaces
• E.g. a type might need to be both serializable and cloneable
Multiple constraints use a different syntax
• The function declaration ends in a ‘where’ clause, whose
value is a series of constraints on the type parameter(s)

interface Edible {
fun eat()
}
interface Drinkable {
fun drink()
}
class Pie : Edible {
override fun eat() {}
}
class Ale : Drinkable {
override fun drink() {}
}
class Ramen : Edible, Drinkable {
override fun eat() {}
override fun drink() {}
}
demos.constraints.generics.multiple.Program

fun <T> demo(input: T) where T: Edible,
T: Drinkable {
input.eat()
input.drink()
}
//demo(Pie()) // Will not compile
//demo(Ale()) // Will not compile
demo(Ramen())
}
demos.constraints.generics.multiple.Program

Collections

Kotlin provides data structures via ‘kotlin.collections’
• As in Java, arrays are not part of the collections library
• Support for arrays is provided in the core ‘kotlin’ package
Collections are typically created indirectly
• Via methods such as ‘emptyList’ and ‘listOf’
Both mutable and immutable collections are provided
• ‘listOf’ provides a list where adding returns a new collection
• ‘mutableListOf’ provides a list whose state can be changed
At present everything is implemented via JSE collections
• So you are given a read-only view of a mutable collection
Collections in Kotlin

fun printList(input: List<Int>) {
println("This is a list of type ${input.javaClass.name}")
if(input.isEmpty()) {
println("tThe list is empty")
} else {
val content = input.fold(""){a,b -> a + b + " "}
println("tThe list holds: $content")
}
}
val list1: List<Int> = emptyList()
val list2 = emptyList<Int>()
val list3 = listOf(12)
val list4 = listOf(12,34,56)
val list5 = mutableListOf(12,34,56)
printList(list1)
printList(list2)
printList(list3)
printList(list4)
printList(list5)
collections.basic.Program
Introducing Kotlin Collections

val list6 = list4.plus(78)
list5.add(78)
println("-------------")
printList(list4)
printList(list5)
printList(list6)
}
collections.basic.Program
This is a list of type kotlin.collections.EmptyList
The list is empty
This is a list of type kotlin.collections.EmptyList
The list is empty
This is a list of type java.util.Collections$SingletonList
The list holds: 12
This is a list of type java.util.Arrays$ArrayList
The list holds: 12 34 56
This is a list of type java.util.ArrayList
-------------
This is a list of type java.util.Arrays$ArrayList
The list holds: 12 34 56 78
The list holds: 12 34 56 78
Introducing Kotlin Collections
List 4 was not
modified by the
call to ‘plus’

Example Types from the Collections Hierarchy
Iterable
Collection
MutableCollectionList
MutableList
AbstractMutableList
ArrayList
RandomAcces
s
java.util.AbstractList
listOf
emptyList
arrayListOf
mutableListOf

val myList = listOf("ab","cd","ef")
println(myList.elementAtOrElse(0, {"Nothing at $it"}))
println(myList.elementAtOrElse(3, {"Nothing at $it"}))
val sb = StringBuilder()
myList.joinTo(buffer = sb,separator = " ", prefix=">>", postfix="<<")
println(sb)
val myList2 = myList.reversed()
println(myList2)
}
collections.functions.Program
ab
Nothing at 3
>>ab cd ef<<
[ef, cd, ab]
Accessing Values in Collections

Kotlin provides support for destructuring
• I.e. retrieving multiple values from a collection at once
• This is often found in scripting languages but rare elsewhere
The syntax is ‘val (a,b,c) = myThing’
• If ‘myThing’ is a list this will be compiled as calls to ‘get’
• Otherwise the compiler will expect there to be methods of the
form ‘componentN’ and create declarations as below
Destructuring in Collections
val a = myList.component1()
val b = myList.component2()
val c = myList.component3()

var myList = listOf(12,34,56)
var myPair = Pair(12,"ab")
var (a,b,c) = myList
var (d,e) = myPair
println("List values are ${a}, ${b} and ${c}")
println("Pair values are ${d} and ${e}")
}
collections.destructuring.Program
List values are 12, 34 and 56
Pair values are 12 and ab
Destructuring in Collections

Destructing In Collections
javap -p -c collections.destructuring.ProgramKt
Compiled from "Program.kt"
public final class collections.destructuring.ProgramKt {
public static final void main(java.lang.String[]);
Code:
63: invokeinterface #41, 2 // InterfaceMethod java/util/List.get:(I)Ljava/lang/Object;
68: checkcast #43 // class java/lang/Number
71: invokevirtual #47 // Method java/lang/Number.intValue:()I
123: invokevirtual #51 // Method kotlin/Pair.component1:()Ljava/lang/Object;
136: invokevirtual #54 // Method kotlin/Pair.component2:()Ljava/lang/Object;
139: checkcast #56 // class java/lang/String
Calls to ‘get’ method
Calls to ‘componentN’ methods

Functional Programming

The ‘map’ function converts a list of ‘T’ to a list of ‘U’
• Based on a mapping function that you provide
The ‘filter’ function produces a smaller list
• Based on a predicate function that you provide
The ‘partition’ function is similar to filter
• But it sorts the items into two separate lists based on the test
The ‘Functional Toolkit’
fun <T,U>map(input: List<T>,
mappingFunc: (T)->U): List<U> { … }
fun <T>filter(input: List<T>,
filterFunc: (T)->Boolean): List<T> { … }
fun <T>partition(input: List<T>, filterFunc: (T)->Boolean):
Pair<List<T>,List<T>> {

fun <T,U>map(input: List<T>, mappingFunc: (T)->U): List<U> {
val results = ArrayList<U>()
for(item in input) {
results.add(mappingFunc(item));
}
return results
}
fun <T>filter(input: List<T>, filterFunc: (T)->Boolean): List<T> {
val results = ArrayList<T>()
if(filterFunc(item)) {
results.add(item);
}
}
return results
}
fun <T>partition(input: List<T>, filterFunc: (T)->Boolean): Pair<List<T>,List<T>> {
val results = Pair(ArrayList<T>(),ArrayList<T>())
if(filterFunc(item)) {
results.first.add(item);
} else {
results.second.add(item);
}
}
return results
}
coding.the.functional.toolkit
Implementing the ‘Functional Toolkit’ By Hand

val originalData = arrayListOf<String>("12","34","56","78","90")
val mappedData = map(originalData, String::toInt)
val filteredData = filter(mappedData) { it > 50 }
val partitionedData = partition(mappedData) { it > 50 }
printResults("Results of mapping",mappedData)
printResults("Results of filtering", filteredData)
printResults("Results of partitioning", partitionedData)
}
fun<T> printResults(title: String, input: List<T>) {
println("----- $title -----")
println("t$item")
}
}
fun<T,U> printResults(title: String, input: Pair<List<T>,List<U>>) {
println("----- $title -----")
println("tfirst items in pair")
for(item in input.first) {
println("tt$item")
}
println("tsecond items in pair")
for(item in input.second) {
println("tt$item")
}
}
coding.the.functional.toolkit

----- Results of mapping -----
12
34
56
78
90
----- Results of filtering -----
56
78
90
----- Results of partitioning -----
first items in pair
56
78
90
second items in pair
12
34

Higher level functions can also return new functions
• Functional coders never implement a ‘family’ of functions
• Instead they create a function that returns the one they
currently need, plus as many variants as required
A simple example is wrapping text in HTML tags
• We could define one wrapper function per tag
• This would be tedious and require periodic updates
• We could write a function that took the tag name
• But this would be ‘stringly typed code’ and prone to typos
• We could write a function that takes a tag name and returns a
function that takes arbitrary text and wraps it in the tag
• This prevents us having to build and maintain a library of
trivial functions whilst also protecting against simple errors
Using Functions as Outputs

fun wrapInH1(input: String) = "<h1>$input</h1>"
fun wrapInH2(input: String) = "<h2>$input</h2>"
fun wrapInTag(tagName: String, input: String): String {
val openingTag = "<$tagName>"
val closingTag = "</$tagName>"
return "$openingTag$input$closingTag"
}
fun buildWrapper(tagName: String): (String) -> String {
val openingTag = "<$tagName>"
val closingTag = "</$tagName>"
return { "$openingTag$it$closingTag" }
}
functions.returning.functions

println(wrapInH1("Marge"))
println(wrapInH2("Homer"))
println(wrapInTag("h3","Liza"))
println(wrapInTag("h4","Bart"))
val wrapInBold = buildWrapper("b")
val wrapInItalics = buildWrapper("i")
val wrapInMark = buildWrapper("mark")
println(wrapInBold("Maggie"))
println(wrapInItalics("Snowball III"))
println(wrapInMark("Santas Little Helper"))
}
functions.returning.functions
<h1>Marge</h1>
<h2>Homer</h2>
<h3>Liza</h3>
<h4>Bart</h4>
<b>Maggie</b>
<i>Snowball III</i>
<mark>Santas Little Helper</mark>

In the previous example we returned a function literal
• This worked well but in more complex cases we will be
returning functions that contain larger quantities of code
Instead we can return a reference to a local function
• Functional languages like Kotlin allow functions to be nested
within one another and these local functions to be returned
In the following example we create ‘buildMatcher’ which:
• Takes a regular expression in string format as its input
• Builds and returns a function that takes some text and returns
all the matches for the regular expression as a list of strings
Returning Local Functions

import kotlin.text.Regex
val data = "abcDEFghiJKLmnpPQRstuVWXyz"
val matcher1 = buildMatcher("[A-Z]{3}")
val matcher2 = buildMatcher("[a-z]{2,3}")
println("First matches are:")
for(str in matcher1(data)) {
println("t$str")
}
println("Second matches are:")
for(str in matcher2(data)) {
println("t$str")
}
}
fun buildMatcher(pattern: String): (String) -> Sequence<String> {
fun matcher(text: String): Sequence<String> {
val regex = Regex(pattern)
return regex.findAll(text)
.map { it.value }
}
return ::matcher
}
returning.functions

First matches are:
DEF
JKL
PQR
VWX
Second matches are:
abc
ghi
mnp
stu
yz

Functional Collections

Kotlin collections offer the standard ‘functional toolkit’
• A summary of these operations is provided below
• Remember you can add your own via extensions
In the following example we:
• Create a list of course objects with associated instructors
• Query the data in increasingly complex ways
The Built In Functional Toolkit
Operation Name Description
all, any,name Perform a test using a predicate
first, filter, find, last Locate elements based on a predicate
map, flatMap Transform the elements in a collection
fold, foldRight, reduce, reduceRight Build a single value based on the elements
groupBy, associateBy Group the elements based on a key selector

data class Course(
val id: String,
val title: String,
val courseType: CourseType,
val duration: Int,
val instructors: List<Trainer>)
data class Trainer(
val name: String,
val rate: Double,
val skills : List<String>)
enum class CourseType {
BEGINNER,
INTERMEDIATE,
ADVANCED
}
functional.using.the.toolki
t
Using the Functional Toolkit

fun buildData(): List<Course> {
val dave = Trainer("Dave Jones", 500.0, arrayListOf("SQL","Perl","PHP"))
val jane = Trainer("Jane Smith", 750.0, arrayListOf("SQL","Java","JEE"))
val pete = Trainer("Pete Hughes", 1000.0, arrayListOf("Java", "JEE", "C#", "Scala"))
val mary = Trainer("Mary Donaghy", 1250.0, arrayListOf("Java", "JEE", "C#", "C++"))
return arrayListOf(
Course("AB12","Intro to Scala",BEGINNER,4,arrayListOf(pete)),
Course("CD34","JEE Web Development",INTERMEDIATE,3,arrayListOf(pete, mary, jane)),
Course("EF56","Meta-Programming in Ruby",ADVANCED,2,arrayListOf()),
Course("GH78","OO Design with UML",BEGINNER,3,arrayListOf(jane,pete,mary)),
Course("IJ90","Database Access with JPA",INTERMEDIATE,3, arrayListOf(jane)),
Course("KL12","Design Patterns in C#",ADVANCED,2, arrayListOf(pete,mary)),
Course("MN34","Relational Database Design",BEGINNER,4, arrayListOf(jane, dave)),
Course("OP56",”MySql Stored Procedures",INTERMEDIATE,1, arrayListOf(jane, dave)),
Course("QR78",”Parallel Programming",ADVANCED,2, arrayListOf(pete,mary)),
Course("ST90","C++ Programming for Beginners",BEGINNER,5,arrayListOf(mary)),
Course("UV12","UNIX Threading with PThreads",INTERMEDIATE,2,arrayListOf()),
Course("WX34","Writing Linux Device Drivers",ADVANCED,3,arrayListOf(mary)))
}
t

val data = buildData()
titlesOfCourses(data)
titlesOfCoursesWithoutATrainer(data)
namesAndRatesOfTrainers(data)
theNumberOfAdvancedCourses(data)
totalDurationsOfBeginnerAndNonBeginnerCourses(data)
everyPairOfTrainersThatCouldDeliverJava(data)
possibleCostsOfJeeWebDevelopment(data)
coursesIdsAndTitlesGroupedByType(data)
}
t

fun printTabbed(input: Any) = println("t$input")
fun printTitle(title: String) = println(title)
fun printLine() = println("--------")
//An extension function to return pairs of items without duplicates
// note this is the simplest possible implementation
fun List<String>.combinations(): List<Pair<String,String>> {
val results = ArrayList<Pair<String,String>>()
for(str1 in this) {
for(str2 in this) {
if(!str1.equals(str2)) {
if(!results.contains(Pair(str2,str1))) {
results.add(Pair(str1, str2))
}
}
}
}
return results
}
t

fun titlesOfCourses(courses: List<Course>) {
printTitle("Titles of courses:")
courses.map { it.title }
.forEach(::printTabbed)
printLine()
}
fun titlesOfCoursesWithoutATrainer(courses: List<Course>) {
printTitle("Titles of courses without a trainer:")
courses.filter { it.instructors.isEmpty() }
.map { it.title }
printLine()
}
fun namesAndRatesOfTrainers(courses: List<Course>) {
printTitle("Names and rates of trainers:")
courses.flatMap { it.instructors }
.toSet()
.map { Pair(it.name,it.rate)}
printLine()
}
functional.using.the.toolkit

fun theNumberOfAdvancedCourses(courses: List<Course>) {
printTitle("The number of advanced courses:")
printTabbed(courses.count {it.courseType == ADVANCED})
printLine()
}
fun totalDurationsOfBeginnerAndNonBeginnerCourses(courses: List<Course>) {
printTitle("Total days for both beginner and non-beginner courses")
val splitCourses = courses.partition {it.courseType == BEGINNER}
val beginnerDuration = splitCourses.first.map{it.duration}.sum()
val nonBeginnerDuration = splitCourses.second.map{it.duration}.sum()
printTabbed(Pair(beginnerDuration,nonBeginnerDuration))
printLine()
}
fun everyPairOfTrainersThatCouldDeliverJava(courses: List<Course>) {
printTitle("Pairs of trainers that could deliver Java")
courses.flatMap {it.instructors}
.distinct()
.filter {it.skills.contains("Java")}
.map {it.name}
.combinations()
.forEach {printTabbed("${it.first} and ${it.second}")}
printLine()
}

fun possibleCostsOfJeeWebDevelopment(courses: List<Course>) {
printTitle("Possible costs of 'JEE Web Development'")
val course = courses.find {it.title.equals("JEE Web Development")}
val duration = course?.duration ?: 0
val namesAndCosts = course?.instructors
?.map { Pair(it.name, it.rate * duration)}
namesAndCosts?.forEach(::printTabbed)
printLine()
}
fun coursesIdsAndTitlesGroupedByType(courses: List<Course>) {
fun process(entry: Entry<CourseType, List<Course>>) {
printTabbed(entry.key)
entry.value.forEach { println("tt${it.id} ${it.title}")}
}
printTitle("Course ID's and titles grouped by type")
courses.groupBy {it.courseType}
.forEach(::process)
}

TDD Demonstration

Spring Demonstration

Creating a Spring Boot Project
Key details
Dependencies
Build tool choice
Language choice

Android Demonstration

Conclusions

Conclusions
Kotlin is the ideal language for
the JVM today

Conclusions
Will it be so tomorrow?

Kotlin as a Better Java

More Related Content

What's hot (20)

Similar to Kotlin as a Better Java (20)

More from Garth Gilmour (20)

Recently uploaded (20)

Kotlin as a Better Java