Topic 1 Extra Material

This page consists of additional reading on basic Kotlin covering some further features. We will not have time to cover this in the lecture but it is provided for you to read.

Mappings: performing the same operation on all members of a list

Another common use of lambdas is to perform a mapping. A mapping transforms each member of an input list by a specified function, and returns a new list containing the transformed data. This example will convert each string in the input list to lower case and return a new list containing the lower case values:

fun main(args: Array<String>) {
    val peopleList = listOf("Mark Cranshaw", "Rob Cooper", "Al Monger", "Mark Udall", "Margaret Jones")
    val lowerCaseList = peopleList.map { person -> person.lowercase() }
    println(lowerCaseList)    
}

Inheritance

• This example shows inheritance in Kotlin:

  open class Person(var name: String, var age: Int, var weight: Int) {
      
      open fun display() {
          println("Name $name Age $age Weight $weight")
      }
  }
  
  class Employee(n: String, a: Int, w: Int, var jobTitle: String, var salary: Double) : Person(n,a,w) {
  
      override fun display() {
          super.display() // as in Java
          println("Job title $jobTitle Salary $salary")
      }
  }
  
  fun main (args: Array<String>) {
      val jake = Person("Jake", 4, 30)
      val tony = Employee("Tony", 60, 100, "Head of Biochemistry", 70000.0)
      jake.display()
      tony.display() 
  }
  

• Note how a base class has to be labelled open, to allow it to be inherited from, and methods which can be overridden (display() in Person here) must also be labelled open
• Note that a method overriding another must be labelled override (display() in Employee here)
• Note also the syntax for calling the superclass constructor:

   class Employee(n: String, a: Int, w: Int, var jobTitle: String, var salary: Double) : Person(n,a,w)

  The Employee constructor takes five parameters, three of which (n, a and w) are passed up to the Person constructor (hence Person(n,a,w)) and two of which are declared attributes of Employee (jobTitle and salary)
• More on classes and objects here.

The Map

• Kotlin has a Map, which is similar to the equivalent HashMap data structure in Java, the dictionary in Python, or the associative array in PHP
• A Map is a collection which can be indexed using non-numeric indices, called keys
• It is the same concept as an associative array in PHP
• A nice feature of Kotlin Maps is that they can be indexed using simple array indexing syntax (i.e. the square brackets, [])
• Like lists, Maps can be mutable or immutable

Creating a mutable Map

• This example creates a MutableMap:

  fun main(args: Array<String>) {
  	val olympus = mutableMapOf("name" to "Mount Olympus", "height" to "2917m", "country" to "Greece")
  	println("Name: ${olympus["name"]}, height: ${olympus["height"]}, highest in: ${olympus["country"]}")
  	
  	// Add another key/value pair to the Map
  	olympus["comment"] = "Legendary home of the gods."
  	println(olympus["comment"])
  }
  

• Note how we use the syntax "key to value" when initialising the map, to set up the keys (indices) and values
• Note that like Java, all keys and all values have to be a particular type (both String here)

forEach() on maps

• forEach() works similarly for a Map
• The difference is that the lambda passed to forEach() must now have two parameters, one for the current key and another for the current value
• e.g.

  fun main(args: Array<String>) {
  	val olympus = mapOf("name" to "Mount Olympus", "height" to "2917m", "country" to "Greece")
  	olympus.forEach { println("The ${it.key} of Mount Olympus is ${it.value}.") }
  }
  

  Each key/value pair within the Map is passed in turn to the specified lambda function as a Pair object (shown here as the implicit it parameter)
• The Pair object has two properties, key and value

Other collection functions which use lambdas

• There are a number of other collection functions which can apply a lambda on some or all members of collections, and can be used to perform common tasks concisely using a functional style
• e.g.
  • filter() - filters a collection by applying a lambda to each member of a collection, and returns the filtered collection. If the lambda returns true for that member, that member will be in the filtered collection.
  • filterNotNull() - filters null values from a collection
  • map() - maps the values of a list or array to another list or array by applying a transformation function. The transformed list or array is returned. There is a similar mapValues() for Maps.
• See the Kotlin documentation for a full list.

Other collection functions - example

• This example shows some of the functions mentioned on the previous slide:

  data class Employee(val name: String, val salary: Double)
  
  fun main(args: Array<String>) {
  	listOf(111, 222, 333, 555, 666, 444, 888, 777).filter { it < 500}.forEach { println(it) }
  	listOf(Employee("Tom", 28000), Employee("Jane", 32000)).map{ Employee(it.name, it.salary*1.2)}.forEach{ println("${it.name} ${it.salary}")
  }
  

  Note how we can chain these functions together, e.g. filter() followed by forEach() in the first example